]> code.delx.au - gnu-emacs/blob - src/xdisp.c
Merge from trunk.
[gnu-emacs] / src / xdisp.c
1 /* Display generation from window structure and buffer text.
2
3 Copyright (C) 1985-1988, 1993-1995, 1997-2011 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
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.
11
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.
16
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/>. */
19
20 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
21
22 Redisplay.
23
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
27 the display.
28
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.
34
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.
44
45 +--------------+ redisplay +----------------+
46 | Lisp machine |---------------->| Redisplay code |<--+
47 +--------------+ (xdisp.c) +----------------+ |
48 ^ | |
49 +----------------------------------+ |
50 Don't use this path when called |
51 asynchronously! |
52 |
53 expose_window (asynchronous) |
54 |
55 X expose events -----+
56
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.
61
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
70 terminology.
71
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.
77
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
82 following functions:
83
84 . try_cursor_movement
85
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.
89
90 . try_window_reusing_current_matrix
91
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
94 scrolling).
95
96 . try_window_id
97
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.
101
102 . try_window
103
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.)
109
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.
114
115 Desired matrices.
116
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.
123
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)
129 argument.
130
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.
140
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
146 see in dispextern.h.
147
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).
159
160 Frame matrices.
161
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.
168
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.
180
181 Bidirectional display.
182
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.
195
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...
204
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.
223
224 Bidirectional display and character compositions
225
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
229 category.
230
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.
250
251 Moving an iterator in bidirectional text
252 without producing glyphs
253
254 Note one important detail mentioned above: that the bidi reordering
255 engine, driven by the iterator, produces characters in R2L rows
256 starting at the character that will be the rightmost on display.
257 As far as the iterator is concerned, the geometry of such rows is
258 still left to right, i.e. the iterator "thinks" the first character
259 is at the leftmost pixel position. The iterator does not know that
260 PRODUCE_GLYPHS reverses the order of the glyphs that the iterator
261 delivers. This is important when functions from the move_it_*
262 family are used to get to certain screen position or to match
263 screen coordinates with buffer coordinates: these functions use the
264 iterator geometry, which is left to right even in R2L paragraphs.
265 This works well with most callers of move_it_*, because they need
266 to get to a specific column, and columns are still numbered in the
267 reading order, i.e. the rightmost character in a R2L paragraph is
268 still column zero. But some callers do not get well with this; a
269 notable example is mouse clicks that need to find the character
270 that corresponds to certain pixel coordinates. See
271 buffer_posn_from_coords in dispnew.c for how this is handled. */
272
273 #include <config.h>
274 #include <stdio.h>
275 #include <limits.h>
276 #include <setjmp.h>
277
278 #include "lisp.h"
279 #include "keyboard.h"
280 #include "frame.h"
281 #include "window.h"
282 #include "termchar.h"
283 #include "dispextern.h"
284 #include "buffer.h"
285 #include "character.h"
286 #include "charset.h"
287 #include "indent.h"
288 #include "commands.h"
289 #include "keymap.h"
290 #include "macros.h"
291 #include "disptab.h"
292 #include "termhooks.h"
293 #include "termopts.h"
294 #include "intervals.h"
295 #include "coding.h"
296 #include "process.h"
297 #include "region-cache.h"
298 #include "font.h"
299 #include "fontset.h"
300 #include "blockinput.h"
301
302 #ifdef HAVE_X_WINDOWS
303 #include "xterm.h"
304 #endif
305 #ifdef WINDOWSNT
306 #include "w32term.h"
307 #endif
308 #ifdef HAVE_NS
309 #include "nsterm.h"
310 #endif
311 #ifdef USE_GTK
312 #include "gtkutil.h"
313 #endif
314
315 #include "font.h"
316
317 #ifndef FRAME_X_OUTPUT
318 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
319 #endif
320
321 #define INFINITY 10000000
322
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;
335
336 /* Cursor shapes */
337 Lisp_Object Qbar, Qhbar, Qbox, Qhollow;
338
339 /* Pointer shapes */
340 static Lisp_Object Qarrow, Qhand;
341 Lisp_Object Qtext;
342
343 /* Holds the list (error). */
344 static Lisp_Object list_of_error;
345
346 static Lisp_Object Qfontification_functions;
347
348 static Lisp_Object Qwrap_prefix;
349 static Lisp_Object Qline_prefix;
350
351 /* Non-nil means don't actually do any redisplay. */
352
353 Lisp_Object Qinhibit_redisplay;
354
355 /* Names of text properties relevant for redisplay. */
356
357 Lisp_Object Qdisplay;
358
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;
364 Lisp_Object Qcenter;
365 static Lisp_Object Qmargin, Qpointer;
366 static Lisp_Object Qline_height;
367
368 #ifdef HAVE_WINDOW_SYSTEM
369
370 /* Test if overflow newline into fringe. Called with iterator IT
371 at or past right window margin, and with IT->current_x set. */
372
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)
381
382 #else /* !HAVE_WINDOW_SYSTEM */
383 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
384 #endif /* HAVE_WINDOW_SYSTEM */
385
386 /* Test if the display element loaded in IT is a space or tab
387 character. This is used to determine word wrapping. */
388
389 #define IT_DISPLAYING_WHITESPACE(it) \
390 (it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))
391
392 /* Name of the face used to highlight trailing whitespace. */
393
394 static Lisp_Object Qtrailing_whitespace;
395
396 /* Name and number of the face used to highlight escape glyphs. */
397
398 static Lisp_Object Qescape_glyph;
399
400 /* Name and number of the face used to highlight non-breaking spaces. */
401
402 static Lisp_Object Qnobreak_space;
403
404 /* The symbol `image' which is the car of the lists used to represent
405 images in Lisp. Also a tool bar style. */
406
407 Lisp_Object Qimage;
408
409 /* The image map types. */
410 Lisp_Object QCmap;
411 static Lisp_Object QCpointer;
412 static Lisp_Object Qrect, Qcircle, Qpoly;
413
414 /* Tool bar styles */
415 Lisp_Object Qboth, Qboth_horiz, Qtext_image_horiz;
416
417 /* Non-zero means print newline to stdout before next mini-buffer
418 message. */
419
420 int noninteractive_need_newline;
421
422 /* Non-zero means print newline to message log before next message. */
423
424 static int message_log_need_newline;
425
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;
432 \f
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. */
437
438 static struct text_pos this_line_start_pos;
439
440 /* Number of characters past the end of the line above, including the
441 terminating newline. */
442
443 static struct text_pos this_line_end_pos;
444
445 /* The vertical positions and the height of this line. */
446
447 static int this_line_vpos;
448 static int this_line_y;
449 static int this_line_pixel_height;
450
451 /* X position at which this display line starts. Usually zero;
452 negative if first character is partially visible. */
453
454 static int this_line_start_x;
455
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. */
459
460 static struct text_pos this_line_min_pos;
461
462 /* Buffer that this_line_.* variables are referring to. */
463
464 static struct buffer *this_line_buffer;
465
466
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. */
471
472 static Lisp_Object Qlast_arrow_position, Qlast_arrow_string;
473
474 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
475 properties on a symbol in overlay-arrow-variable-list. */
476
477 static Lisp_Object Qoverlay_arrow_string, Qoverlay_arrow_bitmap;
478
479 Lisp_Object Qmenu_bar_update_hook;
480
481 /* Nonzero if an overlay arrow has been displayed in this window. */
482
483 static int overlay_arrow_seen;
484
485 /* Number of windows showing the buffer of the selected window (or
486 another buffer with the same base buffer). keyboard.c refers to
487 this. */
488
489 int buffer_shared;
490
491 /* Vector containing glyphs for an ellipsis `...'. */
492
493 static Lisp_Object default_invis_vector[3];
494
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. */
498
499 Lisp_Object echo_area_window;
500
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. */
505
506 static Lisp_Object Vmessage_stack;
507
508 /* Nonzero means multibyte characters were enabled when the echo area
509 message was specified. */
510
511 static int message_enable_multibyte;
512
513 /* Nonzero if we should redraw the mode lines on the next redisplay. */
514
515 int update_mode_lines;
516
517 /* Nonzero if window sizes or contents have changed since last
518 redisplay that finished. */
519
520 int windows_or_buffers_changed;
521
522 /* Nonzero means a frame's cursor type has been changed. */
523
524 int cursor_type_changed;
525
526 /* Nonzero after display_mode_line if %l was used and it displayed a
527 line number. */
528
529 static int line_number_displayed;
530
531 /* The name of the *Messages* buffer, a string. */
532
533 static Lisp_Object Vmessages_buffer_name;
534
535 /* Current, index 0, and last displayed echo area message. Either
536 buffers from echo_buffers, or nil to indicate no message. */
537
538 Lisp_Object echo_area_buffer[2];
539
540 /* The buffers referenced from echo_area_buffer. */
541
542 static Lisp_Object echo_buffer[2];
543
544 /* A vector saved used in with_area_buffer to reduce consing. */
545
546 static Lisp_Object Vwith_echo_area_save_vector;
547
548 /* Non-zero means display_echo_area should display the last echo area
549 message again. Set by redisplay_preserve_echo_area. */
550
551 static int display_last_displayed_message_p;
552
553 /* Nonzero if echo area is being used by print; zero if being used by
554 message. */
555
556 static int message_buf_print;
557
558 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
559
560 static Lisp_Object Qinhibit_menubar_update;
561 static Lisp_Object Qmessage_truncate_lines;
562
563 /* Set to 1 in clear_message to make redisplay_internal aware
564 of an emptied echo area. */
565
566 static int message_cleared_p;
567
568 /* A scratch glyph row with contents used for generating truncation
569 glyphs. Also used in direct_output_for_insert. */
570
571 #define MAX_SCRATCH_GLYPHS 100
572 static struct glyph_row scratch_glyph_row;
573 static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
574
575 /* Ascent and height of the last line processed by move_it_to. */
576
577 static int last_max_ascent, last_height;
578
579 /* Non-zero if there's a help-echo in the echo area. */
580
581 int help_echo_showing_p;
582
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. */
586
587 int current_mode_line_height, current_header_line_height;
588
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. */
594
595 #define TEXT_PROP_DISTANCE_LIMIT 100
596
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) \
605 do { \
606 if (CACHE) \
607 bidi_unshelve_cache (CACHE, 1); \
608 ITCOPY = ITORIG; \
609 CACHE = bidi_shelve_cache (); \
610 } while (0)
611
612 #define RESTORE_IT(pITORIG,pITCOPY,CACHE) \
613 do { \
614 if (pITORIG != pITCOPY) \
615 *(pITORIG) = *(pITCOPY); \
616 bidi_unshelve_cache (CACHE, 0); \
617 CACHE = NULL; \
618 } while (0)
619
620 #if GLYPH_DEBUG
621
622 /* Non-zero means print traces of redisplay if compiled with
623 GLYPH_DEBUG != 0. */
624
625 int trace_redisplay_p;
626
627 #endif /* GLYPH_DEBUG */
628
629 #ifdef DEBUG_TRACE_MOVE
630 /* Non-zero means trace with TRACE_MOVE to stderr. */
631 int trace_move;
632
633 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
634 #else
635 #define TRACE_MOVE(x) (void) 0
636 #endif
637
638 static Lisp_Object Qauto_hscroll_mode;
639
640 /* Buffer being redisplayed -- for redisplay_window_error. */
641
642 static struct buffer *displayed_buffer;
643
644 /* Value returned from text property handlers (see below). */
645
646 enum prop_handled
647 {
648 HANDLED_NORMALLY,
649 HANDLED_RECOMPUTE_PROPS,
650 HANDLED_OVERLAY_STRING_CONSUMED,
651 HANDLED_RETURN
652 };
653
654 /* A description of text properties that redisplay is interested
655 in. */
656
657 struct props
658 {
659 /* The name of the property. */
660 Lisp_Object *name;
661
662 /* A unique index for the property. */
663 enum prop_idx idx;
664
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);
668 };
669
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 *);
676
677 /* Properties handled by iterators. */
678
679 static struct props it_props[] =
680 {
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},
688 {NULL, 0, NULL}
689 };
690
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. */
693
694 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
695
696 /* Enumeration returned by some move_it_.* functions internally. */
697
698 enum move_it_result
699 {
700 /* Not used. Undefined value. */
701 MOVE_UNDEFINED,
702
703 /* Move ended at the requested buffer position or ZV. */
704 MOVE_POS_MATCH_OR_ZV,
705
706 /* Move ended at the requested X pixel position. */
707 MOVE_X_REACHED,
708
709 /* Move within a line ended at the end of a line that must be
710 continued. */
711 MOVE_LINE_CONTINUED,
712
713 /* Move within a line ended at the end of a line that would
714 be displayed truncated. */
715 MOVE_LINE_TRUNCATED,
716
717 /* Move within a line ended at a line end. */
718 MOVE_NEWLINE_OR_CR
719 };
720
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
724 cleared. */
725
726 #define CLEAR_FACE_CACHE_COUNT 500
727 static int clear_face_cache_count;
728
729 /* Similarly for the image cache. */
730
731 #ifdef HAVE_WINDOW_SYSTEM
732 #define CLEAR_IMAGE_CACHE_COUNT 101
733 static int clear_image_cache_count;
734
735 /* Null glyph slice */
736 static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
737 #endif
738
739 /* Non-zero while redisplay_internal is in progress. */
740
741 int redisplaying_p;
742
743 static Lisp_Object Qinhibit_free_realized_faces;
744
745 /* If a string, XTread_socket generates an event to display that string.
746 (The display is done in read_char.) */
747
748 Lisp_Object help_echo_string;
749 Lisp_Object help_echo_window;
750 Lisp_Object help_echo_object;
751 ptrdiff_t help_echo_pos;
752
753 /* Temporary variable for XTread_socket. */
754
755 Lisp_Object previous_help_echo_string;
756
757 /* Platform-independent portion of hourglass implementation. */
758
759 /* Non-zero means an hourglass cursor is currently shown. */
760 int hourglass_shown_p;
761
762 /* If non-null, an asynchronous timer that, when it expires, displays
763 an hourglass cursor on all frames. */
764 struct atimer *hourglass_atimer;
765
766 /* Name of the face used to display glyphless characters. */
767 Lisp_Object Qglyphless_char;
768
769 /* Symbol for the purpose of Vglyphless_char_display. */
770 static Lisp_Object Qglyphless_char_display;
771
772 /* Method symbols for Vglyphless_char_display. */
773 static Lisp_Object Qhex_code, Qempty_box, Qthin_space, Qzero_width;
774
775 /* Default pixel width of `thin-space' display method. */
776 #define THIN_SPACE_WIDTH 1
777
778 /* Default number of seconds to wait before displaying an hourglass
779 cursor. */
780 #define DEFAULT_HOURGLASS_DELAY 1
781
782 \f
783 /* Function prototypes. */
784
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);
793
794 static Lisp_Object get_it_property (struct it *it, Lisp_Object prop);
795
796 static void handle_line_prefix (struct it *);
797
798 static void pint2str (char *, int, ptrdiff_t);
799 static void pint2hrstr (char *, int, ptrdiff_t);
800 static struct text_pos run_window_scroll_functions (Lisp_Object,
801 struct text_pos);
802 static void reconsider_clip_changes (struct window *, struct buffer *);
803 static int text_outside_line_unchanged_p (struct window *,
804 ptrdiff_t, ptrdiff_t);
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 *, ptrdiff_t);
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 (*) (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t),
815 ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
816 static void clear_garbaged_frames (void);
817 static int current_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
818 static void pop_message (void);
819 static int truncate_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
820 static void set_message (const char *, Lisp_Object, ptrdiff_t, int);
821 static int set_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
822 static int display_echo_area (struct window *);
823 static int display_echo_area_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
824 static int resize_mini_window_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
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,
828 struct text_pos);
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 *,
833 Lisp_Object);
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, ptrdiff_t, ptrdiff_t, int, int);
838 static int try_cursor_movement (Lisp_Object, struct text_pos, int *);
839 static int trailing_whitespace_p (ptrdiff_t);
840 static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t);
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 *, ptrdiff_t, ptrdiff_t,
854 int, 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 ptrdiff_t display_count_lines (ptrdiff_t, ptrdiff_t, ptrdiff_t,
866 ptrdiff_t *);
867 static int display_string (const char *, Lisp_Object, Lisp_Object,
868 ptrdiff_t, ptrdiff_t, 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 *, ptrdiff_t);
872 static int get_overlay_strings_1 (struct it *, ptrdiff_t, 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 *, ptrdiff_t);
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, ptrdiff_t, ptrdiff_t, 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 *, ptrdiff_t, 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 *,
898 struct glyph_row *);
899 static int init_to_row_end (struct it *, struct window *,
900 struct glyph_row *);
901 static void back_to_previous_line_start (struct it *);
902 static int forward_to_next_line_start (struct it *, int *, struct bidi_it *);
903 static struct text_pos string_pos_nchars_ahead (struct text_pos,
904 Lisp_Object, ptrdiff_t);
905 static struct text_pos string_pos (ptrdiff_t, Lisp_Object);
906 static struct text_pos c_string_pos (ptrdiff_t, const char *, int);
907 static ptrdiff_t 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,
910 Lisp_Object);
911 static int face_before_or_after_it_pos (struct it *, int);
912 static ptrdiff_t next_overlay_change (ptrdiff_t);
913 static int handle_display_spec (struct it *, Lisp_Object, Lisp_Object,
914 Lisp_Object, struct text_pos *, ptrdiff_t, int);
915 static int handle_single_display_spec (struct it *, Lisp_Object,
916 Lisp_Object, Lisp_Object,
917 struct text_pos *, ptrdiff_t, int, int);
918 static int underlying_face_id (struct it *);
919 static int in_ellipses_for_invisible_text_p (struct display_pos *,
920 struct window *);
921
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)
924
925 #ifdef HAVE_WINDOW_SYSTEM
926
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 *,
934 enum glyph_row_area,
935 int, int, int, int);
936 static void append_stretch_glyph (struct it *, Lisp_Object,
937 int, int, int);
938
939
940 #endif /* HAVE_WINDOW_SYSTEM */
941
942 static void show_mouse_face (Mouse_HLInfo *, enum draw_glyphs_face);
943 static int coords_in_mouse_face_p (struct window *, int, int);
944
945
946 \f
947 /***********************************************************************
948 Window display dimensions
949 ***********************************************************************/
950
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.
954
955 This is the height of W minus the height of a mode line, if any. */
956
957 inline int
958 window_text_bottom_y (struct window *w)
959 {
960 int height = WINDOW_TOTAL_HEIGHT (w);
961
962 if (WINDOW_WANTS_MODELINE_P (w))
963 height -= CURRENT_MODE_LINE_HEIGHT (w);
964 return height;
965 }
966
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. */
970
971 inline int
972 window_box_width (struct window *w, int area)
973 {
974 int cols = XFASTINT (w->total_cols);
975 int pixels = 0;
976
977 if (!w->pseudo_window_p)
978 {
979 cols -= WINDOW_SCROLL_BAR_COLS (w);
980
981 if (area == TEXT_AREA)
982 {
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);
988 }
989 else if (area == LEFT_MARGIN_AREA)
990 {
991 cols = (INTEGERP (w->left_margin_cols)
992 ? XFASTINT (w->left_margin_cols) : 0);
993 pixels = 0;
994 }
995 else if (area == RIGHT_MARGIN_AREA)
996 {
997 cols = (INTEGERP (w->right_margin_cols)
998 ? XFASTINT (w->right_margin_cols) : 0);
999 pixels = 0;
1000 }
1001 }
1002
1003 return cols * WINDOW_FRAME_COLUMN_WIDTH (w) + pixels;
1004 }
1005
1006
1007 /* Return the pixel height of the display area of window W, not
1008 including mode lines of W, if any. */
1009
1010 inline int
1011 window_box_height (struct window *w)
1012 {
1013 struct frame *f = XFRAME (w->frame);
1014 int height = WINDOW_TOTAL_HEIGHT (w);
1015
1016 xassert (height >= 0);
1017
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. */
1023
1024 if (WINDOW_WANTS_MODELINE_P (w))
1025 {
1026 struct glyph_row *ml_row
1027 = (w->current_matrix && w->current_matrix->rows
1028 ? MATRIX_MODE_LINE_ROW (w->current_matrix)
1029 : 0);
1030 if (ml_row && ml_row->mode_line_p)
1031 height -= ml_row->height;
1032 else
1033 height -= estimate_mode_line_height (f, CURRENT_MODE_LINE_FACE_ID (w));
1034 }
1035
1036 if (WINDOW_WANTS_HEADER_LINE_P (w))
1037 {
1038 struct glyph_row *hl_row
1039 = (w->current_matrix && w->current_matrix->rows
1040 ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
1041 : 0);
1042 if (hl_row && hl_row->mode_line_p)
1043 height -= hl_row->height;
1044 else
1045 height -= estimate_mode_line_height (f, HEADER_LINE_FACE_ID);
1046 }
1047
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);
1051 }
1052
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. */
1056
1057 inline int
1058 window_box_left_offset (struct window *w, int area)
1059 {
1060 int x;
1061
1062 if (w->pseudo_window_p)
1063 return 0;
1064
1065 x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
1066
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)
1075 ? 0
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);
1080
1081 return x;
1082 }
1083
1084
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. */
1088
1089 inline int
1090 window_box_right_offset (struct window *w, int area)
1091 {
1092 return window_box_left_offset (w, area) + window_box_width (w, area);
1093 }
1094
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. */
1098
1099 inline int
1100 window_box_left (struct window *w, int area)
1101 {
1102 struct frame *f = XFRAME (w->frame);
1103 int x;
1104
1105 if (w->pseudo_window_p)
1106 return FRAME_INTERNAL_BORDER_WIDTH (f);
1107
1108 x = (WINDOW_LEFT_EDGE_X (w)
1109 + window_box_left_offset (w, area));
1110
1111 return x;
1112 }
1113
1114
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. */
1118
1119 inline int
1120 window_box_right (struct window *w, int area)
1121 {
1122 return window_box_left (w, area) + window_box_width (w, area);
1123 }
1124
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. */
1131
1132 inline void
1133 window_box (struct window *w, int area, int *box_x, int *box_y,
1134 int *box_width, int *box_height)
1135 {
1136 if (box_width)
1137 *box_width = window_box_width (w, area);
1138 if (box_height)
1139 *box_height = window_box_height (w);
1140 if (box_x)
1141 *box_x = window_box_left (w, area);
1142 if (box_y)
1143 {
1144 *box_y = WINDOW_TOP_EDGE_Y (w);
1145 if (WINDOW_WANTS_HEADER_LINE_P (w))
1146 *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
1147 }
1148 }
1149
1150
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
1157 box. */
1158
1159 static inline void
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)
1162 {
1163 window_box (w, area, top_left_x, top_left_y, bottom_right_x,
1164 bottom_right_y);
1165 *bottom_right_x += *top_left_x;
1166 *bottom_right_y += *top_left_y;
1167 }
1168
1169
1170 \f
1171 /***********************************************************************
1172 Utilities
1173 ***********************************************************************/
1174
1175 /* Return the bottom y-position of the line the iterator IT is in.
1176 This can modify IT's settings. */
1177
1178 int
1179 line_bottom_y (struct it *it)
1180 {
1181 int line_height = it->max_ascent + it->max_descent;
1182 int line_top_y = it->current_y;
1183
1184 if (line_height == 0)
1185 {
1186 if (last_height)
1187 line_height = last_height;
1188 else if (IT_CHARPOS (*it) < ZV)
1189 {
1190 move_it_by_lines (it, 1);
1191 line_height = (it->max_ascent || it->max_descent
1192 ? it->max_ascent + it->max_descent
1193 : last_height);
1194 }
1195 else
1196 {
1197 struct glyph_row *row = it->glyph_row;
1198
1199 /* Use the default character height. */
1200 it->glyph_row = NULL;
1201 it->what = IT_CHARACTER;
1202 it->c = ' ';
1203 it->len = 1;
1204 PRODUCE_GLYPHS (it);
1205 line_height = it->ascent + it->descent;
1206 it->glyph_row = row;
1207 }
1208 }
1209
1210 return line_top_y + line_height;
1211 }
1212
1213 /* Subroutine of pos_visible_p below. Extracts a display string, if
1214 any, from the display spec given as its argument. */
1215 static Lisp_Object
1216 string_from_display_spec (Lisp_Object spec)
1217 {
1218 if (CONSP (spec))
1219 {
1220 while (CONSP (spec))
1221 {
1222 if (STRINGP (XCAR (spec)))
1223 return XCAR (spec);
1224 spec = XCDR (spec);
1225 }
1226 }
1227 else if (VECTORP (spec))
1228 {
1229 ptrdiff_t i;
1230
1231 for (i = 0; i < ASIZE (spec); i++)
1232 {
1233 if (STRINGP (AREF (spec, i)))
1234 return AREF (spec, i);
1235 }
1236 return Qnil;
1237 }
1238
1239 return spec;
1240 }
1241
1242 /* Return 1 if position CHARPOS is visible in window W.
1243 CHARPOS < 0 means return info about WINDOW_END position.
1244 If visible, set *X and *Y to pixel coordinates of top left corner.
1245 Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
1246 Set *ROWH and *VPOS to row's visible height and VPOS (row number). */
1247
1248 int
1249 pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
1250 int *rtop, int *rbot, int *rowh, int *vpos)
1251 {
1252 struct it it;
1253 void *itdata = bidi_shelve_cache ();
1254 struct text_pos top;
1255 int visible_p = 0;
1256 struct buffer *old_buffer = NULL;
1257
1258 if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w))))
1259 return visible_p;
1260
1261 if (XBUFFER (w->buffer) != current_buffer)
1262 {
1263 old_buffer = current_buffer;
1264 set_buffer_internal_1 (XBUFFER (w->buffer));
1265 }
1266
1267 SET_TEXT_POS_FROM_MARKER (top, w->start);
1268
1269 /* Compute exact mode line heights. */
1270 if (WINDOW_WANTS_MODELINE_P (w))
1271 current_mode_line_height
1272 = display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
1273 BVAR (current_buffer, mode_line_format));
1274
1275 if (WINDOW_WANTS_HEADER_LINE_P (w))
1276 current_header_line_height
1277 = display_mode_line (w, HEADER_LINE_FACE_ID,
1278 BVAR (current_buffer, header_line_format));
1279
1280 start_display (&it, w, top);
1281 move_it_to (&it, charpos, -1, it.last_visible_y-1, -1,
1282 (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
1283
1284 if (charpos >= 0
1285 && (((!it.bidi_p || it.bidi_it.scan_dir == 1)
1286 && IT_CHARPOS (it) >= charpos)
1287 /* When scanning backwards under bidi iteration, move_it_to
1288 stops at or _before_ CHARPOS, because it stops at or to
1289 the _right_ of the character at CHARPOS. */
1290 || (it.bidi_p && it.bidi_it.scan_dir == -1
1291 && IT_CHARPOS (it) <= charpos)))
1292 {
1293 /* We have reached CHARPOS, or passed it. How the call to
1294 move_it_to can overshoot: (i) If CHARPOS is on invisible text
1295 or covered by a display property, move_it_to stops at the end
1296 of the invisible text, to the right of CHARPOS. (ii) If
1297 CHARPOS is in a display vector, move_it_to stops on its last
1298 glyph. */
1299 int top_x = it.current_x;
1300 int top_y = it.current_y;
1301 enum it_method it_method = it.method;
1302 /* Calling line_bottom_y may change it.method, it.position, etc. */
1303 int bottom_y = (last_height = 0, line_bottom_y (&it));
1304 int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
1305
1306 if (top_y < window_top_y)
1307 visible_p = bottom_y > window_top_y;
1308 else if (top_y < it.last_visible_y)
1309 visible_p = 1;
1310 if (visible_p)
1311 {
1312 if (it_method == GET_FROM_DISPLAY_VECTOR)
1313 {
1314 /* We stopped on the last glyph of a display vector.
1315 Try and recompute. Hack alert! */
1316 if (charpos < 2 || top.charpos >= charpos)
1317 top_x = it.glyph_row->x;
1318 else
1319 {
1320 struct it it2;
1321 start_display (&it2, w, top);
1322 move_it_to (&it2, charpos - 1, -1, -1, -1, MOVE_TO_POS);
1323 get_next_display_element (&it2);
1324 PRODUCE_GLYPHS (&it2);
1325 if (ITERATOR_AT_END_OF_LINE_P (&it2)
1326 || it2.current_x > it2.last_visible_x)
1327 top_x = it.glyph_row->x;
1328 else
1329 {
1330 top_x = it2.current_x;
1331 top_y = it2.current_y;
1332 }
1333 }
1334 }
1335 else if (IT_CHARPOS (it) != charpos)
1336 {
1337 Lisp_Object cpos = make_number (charpos);
1338 Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
1339 Lisp_Object string = string_from_display_spec (spec);
1340 int newline_in_string = 0;
1341
1342 if (STRINGP (string))
1343 {
1344 const char *s = SSDATA (string);
1345 const char *e = s + SBYTES (string);
1346 while (s < e)
1347 {
1348 if (*s++ == '\n')
1349 {
1350 newline_in_string = 1;
1351 break;
1352 }
1353 }
1354 }
1355 /* The tricky code below is needed because there's a
1356 discrepancy between move_it_to and how we set cursor
1357 when the display line ends in a newline from a
1358 display string. move_it_to will stop _after_ such
1359 display strings, whereas set_cursor_from_row
1360 conspires with cursor_row_p to place the cursor on
1361 the first glyph produced from the display string. */
1362
1363 /* We have overshoot PT because it is covered by a
1364 display property whose value is a string. If the
1365 string includes embedded newlines, we are also in the
1366 wrong display line. Backtrack to the correct line,
1367 where the display string begins. */
1368 if (newline_in_string)
1369 {
1370 Lisp_Object startpos, endpos;
1371 EMACS_INT start, end;
1372 struct it it3;
1373
1374 /* Find the first and the last buffer positions
1375 covered by the display string. */
1376 endpos =
1377 Fnext_single_char_property_change (cpos, Qdisplay,
1378 Qnil, Qnil);
1379 startpos =
1380 Fprevious_single_char_property_change (endpos, Qdisplay,
1381 Qnil, Qnil);
1382 start = XFASTINT (startpos);
1383 end = XFASTINT (endpos);
1384 /* Move to the last buffer position before the
1385 display property. */
1386 start_display (&it3, w, top);
1387 move_it_to (&it3, start - 1, -1, -1, -1, MOVE_TO_POS);
1388 /* Move forward one more line if the position before
1389 the display string is a newline or if it is the
1390 rightmost character on a line that is
1391 continued or word-wrapped. */
1392 if (it3.method == GET_FROM_BUFFER
1393 && it3.c == '\n')
1394 move_it_by_lines (&it3, 1);
1395 else if (move_it_in_display_line_to (&it3, -1,
1396 it3.current_x
1397 + it3.pixel_width,
1398 MOVE_TO_X)
1399 == MOVE_LINE_CONTINUED)
1400 {
1401 move_it_by_lines (&it3, 1);
1402 /* When we are under word-wrap, the #$@%!
1403 move_it_by_lines moves 2 lines, so we need to
1404 fix that up. */
1405 if (it3.line_wrap == WORD_WRAP)
1406 move_it_by_lines (&it3, -1);
1407 }
1408
1409 /* Record the vertical coordinate of the display
1410 line where we wound up. */
1411 top_y = it3.current_y;
1412 if (it3.bidi_p)
1413 {
1414 /* When characters are reordered for display,
1415 the character displayed to the left of the
1416 display string could be _after_ the display
1417 property in the logical order. Use the
1418 smallest vertical position of these two. */
1419 start_display (&it3, w, top);
1420 move_it_to (&it3, end + 1, -1, -1, -1, MOVE_TO_POS);
1421 if (it3.current_y < top_y)
1422 top_y = it3.current_y;
1423 }
1424 /* Move from the top of the window to the beginning
1425 of the display line where the display string
1426 begins. */
1427 start_display (&it3, w, top);
1428 move_it_to (&it3, -1, 0, top_y, -1, MOVE_TO_X | MOVE_TO_Y);
1429 /* Finally, advance the iterator until we hit the
1430 first display element whose character position is
1431 CHARPOS, or until the first newline from the
1432 display string, which signals the end of the
1433 display line. */
1434 while (get_next_display_element (&it3))
1435 {
1436 PRODUCE_GLYPHS (&it3);
1437 if (IT_CHARPOS (it3) == charpos
1438 || ITERATOR_AT_END_OF_LINE_P (&it3))
1439 break;
1440 set_iterator_to_next (&it3, 0);
1441 }
1442 top_x = it3.current_x - it3.pixel_width;
1443 /* Normally, we would exit the above loop because we
1444 found the display element whose character
1445 position is CHARPOS. For the contingency that we
1446 didn't, and stopped at the first newline from the
1447 display string, move back over the glyphs
1448 prfoduced from the string, until we find the
1449 rightmost glyph not from the string. */
1450 if (IT_CHARPOS (it3) != charpos && EQ (it3.object, string))
1451 {
1452 struct glyph *g = it3.glyph_row->glyphs[TEXT_AREA]
1453 + it3.glyph_row->used[TEXT_AREA];
1454
1455 while (EQ ((g - 1)->object, string))
1456 {
1457 --g;
1458 top_x -= g->pixel_width;
1459 }
1460 xassert (g < it3.glyph_row->glyphs[TEXT_AREA]
1461 + it3.glyph_row->used[TEXT_AREA]);
1462 }
1463 }
1464 }
1465
1466 *x = top_x;
1467 *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
1468 *rtop = max (0, window_top_y - top_y);
1469 *rbot = max (0, bottom_y - it.last_visible_y);
1470 *rowh = max (0, (min (bottom_y, it.last_visible_y)
1471 - max (top_y, window_top_y)));
1472 *vpos = it.vpos;
1473 }
1474 }
1475 else
1476 {
1477 /* We were asked to provide info about WINDOW_END. */
1478 struct it it2;
1479 void *it2data = NULL;
1480
1481 SAVE_IT (it2, it, it2data);
1482 if (IT_CHARPOS (it) < ZV && FETCH_BYTE (IT_BYTEPOS (it)) != '\n')
1483 move_it_by_lines (&it, 1);
1484 if (charpos < IT_CHARPOS (it)
1485 || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
1486 {
1487 visible_p = 1;
1488 RESTORE_IT (&it2, &it2, it2data);
1489 move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
1490 *x = it2.current_x;
1491 *y = it2.current_y + it2.max_ascent - it2.ascent;
1492 *rtop = max (0, -it2.current_y);
1493 *rbot = max (0, ((it2.current_y + it2.max_ascent + it2.max_descent)
1494 - it.last_visible_y));
1495 *rowh = max (0, (min (it2.current_y + it2.max_ascent + it2.max_descent,
1496 it.last_visible_y)
1497 - max (it2.current_y,
1498 WINDOW_HEADER_LINE_HEIGHT (w))));
1499 *vpos = it2.vpos;
1500 }
1501 else
1502 bidi_unshelve_cache (it2data, 1);
1503 }
1504 bidi_unshelve_cache (itdata, 0);
1505
1506 if (old_buffer)
1507 set_buffer_internal_1 (old_buffer);
1508
1509 current_header_line_height = current_mode_line_height = -1;
1510
1511 if (visible_p && XFASTINT (w->hscroll) > 0)
1512 *x -= XFASTINT (w->hscroll) * WINDOW_FRAME_COLUMN_WIDTH (w);
1513
1514 #if 0
1515 /* Debugging code. */
1516 if (visible_p)
1517 fprintf (stderr, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1518 charpos, w->vscroll, *x, *y, *rtop, *rbot, *rowh, *vpos);
1519 else
1520 fprintf (stderr, "-pv pt=%d vs=%d\n", charpos, w->vscroll);
1521 #endif
1522
1523 return visible_p;
1524 }
1525
1526
1527 /* Return the next character from STR. Return in *LEN the length of
1528 the character. This is like STRING_CHAR_AND_LENGTH but never
1529 returns an invalid character. If we find one, we return a `?', but
1530 with the length of the invalid character. */
1531
1532 static inline int
1533 string_char_and_length (const unsigned char *str, int *len)
1534 {
1535 int c;
1536
1537 c = STRING_CHAR_AND_LENGTH (str, *len);
1538 if (!CHAR_VALID_P (c))
1539 /* We may not change the length here because other places in Emacs
1540 don't use this function, i.e. they silently accept invalid
1541 characters. */
1542 c = '?';
1543
1544 return c;
1545 }
1546
1547
1548
1549 /* Given a position POS containing a valid character and byte position
1550 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1551
1552 static struct text_pos
1553 string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, ptrdiff_t nchars)
1554 {
1555 xassert (STRINGP (string) && nchars >= 0);
1556
1557 if (STRING_MULTIBYTE (string))
1558 {
1559 const unsigned char *p = SDATA (string) + BYTEPOS (pos);
1560 int len;
1561
1562 while (nchars--)
1563 {
1564 string_char_and_length (p, &len);
1565 p += len;
1566 CHARPOS (pos) += 1;
1567 BYTEPOS (pos) += len;
1568 }
1569 }
1570 else
1571 SET_TEXT_POS (pos, CHARPOS (pos) + nchars, BYTEPOS (pos) + nchars);
1572
1573 return pos;
1574 }
1575
1576
1577 /* Value is the text position, i.e. character and byte position,
1578 for character position CHARPOS in STRING. */
1579
1580 static inline struct text_pos
1581 string_pos (ptrdiff_t charpos, Lisp_Object string)
1582 {
1583 struct text_pos pos;
1584 xassert (STRINGP (string));
1585 xassert (charpos >= 0);
1586 SET_TEXT_POS (pos, charpos, string_char_to_byte (string, charpos));
1587 return pos;
1588 }
1589
1590
1591 /* Value is a text position, i.e. character and byte position, for
1592 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1593 means recognize multibyte characters. */
1594
1595 static struct text_pos
1596 c_string_pos (ptrdiff_t charpos, const char *s, int multibyte_p)
1597 {
1598 struct text_pos pos;
1599
1600 xassert (s != NULL);
1601 xassert (charpos >= 0);
1602
1603 if (multibyte_p)
1604 {
1605 int len;
1606
1607 SET_TEXT_POS (pos, 0, 0);
1608 while (charpos--)
1609 {
1610 string_char_and_length ((const unsigned char *) s, &len);
1611 s += len;
1612 CHARPOS (pos) += 1;
1613 BYTEPOS (pos) += len;
1614 }
1615 }
1616 else
1617 SET_TEXT_POS (pos, charpos, charpos);
1618
1619 return pos;
1620 }
1621
1622
1623 /* Value is the number of characters in C string S. MULTIBYTE_P
1624 non-zero means recognize multibyte characters. */
1625
1626 static ptrdiff_t
1627 number_of_chars (const char *s, int multibyte_p)
1628 {
1629 ptrdiff_t nchars;
1630
1631 if (multibyte_p)
1632 {
1633 ptrdiff_t rest = strlen (s);
1634 int len;
1635 const unsigned char *p = (const unsigned char *) s;
1636
1637 for (nchars = 0; rest > 0; ++nchars)
1638 {
1639 string_char_and_length (p, &len);
1640 rest -= len, p += len;
1641 }
1642 }
1643 else
1644 nchars = strlen (s);
1645
1646 return nchars;
1647 }
1648
1649
1650 /* Compute byte position NEWPOS->bytepos corresponding to
1651 NEWPOS->charpos. POS is a known position in string STRING.
1652 NEWPOS->charpos must be >= POS.charpos. */
1653
1654 static void
1655 compute_string_pos (struct text_pos *newpos, struct text_pos pos, Lisp_Object string)
1656 {
1657 xassert (STRINGP (string));
1658 xassert (CHARPOS (*newpos) >= CHARPOS (pos));
1659
1660 if (STRING_MULTIBYTE (string))
1661 *newpos = string_pos_nchars_ahead (pos, string,
1662 CHARPOS (*newpos) - CHARPOS (pos));
1663 else
1664 BYTEPOS (*newpos) = CHARPOS (*newpos);
1665 }
1666
1667 /* EXPORT:
1668 Return an estimation of the pixel height of mode or header lines on
1669 frame F. FACE_ID specifies what line's height to estimate. */
1670
1671 int
1672 estimate_mode_line_height (struct frame *f, enum face_id face_id)
1673 {
1674 #ifdef HAVE_WINDOW_SYSTEM
1675 if (FRAME_WINDOW_P (f))
1676 {
1677 int height = FONT_HEIGHT (FRAME_FONT (f));
1678
1679 /* This function is called so early when Emacs starts that the face
1680 cache and mode line face are not yet initialized. */
1681 if (FRAME_FACE_CACHE (f))
1682 {
1683 struct face *face = FACE_FROM_ID (f, face_id);
1684 if (face)
1685 {
1686 if (face->font)
1687 height = FONT_HEIGHT (face->font);
1688 if (face->box_line_width > 0)
1689 height += 2 * face->box_line_width;
1690 }
1691 }
1692
1693 return height;
1694 }
1695 #endif
1696
1697 return 1;
1698 }
1699
1700 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
1701 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
1702 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
1703 not force the value into range. */
1704
1705 void
1706 pixel_to_glyph_coords (FRAME_PTR f, register int pix_x, register int pix_y,
1707 int *x, int *y, NativeRectangle *bounds, int noclip)
1708 {
1709
1710 #ifdef HAVE_WINDOW_SYSTEM
1711 if (FRAME_WINDOW_P (f))
1712 {
1713 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
1714 even for negative values. */
1715 if (pix_x < 0)
1716 pix_x -= FRAME_COLUMN_WIDTH (f) - 1;
1717 if (pix_y < 0)
1718 pix_y -= FRAME_LINE_HEIGHT (f) - 1;
1719
1720 pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
1721 pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);
1722
1723 if (bounds)
1724 STORE_NATIVE_RECT (*bounds,
1725 FRAME_COL_TO_PIXEL_X (f, pix_x),
1726 FRAME_LINE_TO_PIXEL_Y (f, pix_y),
1727 FRAME_COLUMN_WIDTH (f) - 1,
1728 FRAME_LINE_HEIGHT (f) - 1);
1729
1730 if (!noclip)
1731 {
1732 if (pix_x < 0)
1733 pix_x = 0;
1734 else if (pix_x > FRAME_TOTAL_COLS (f))
1735 pix_x = FRAME_TOTAL_COLS (f);
1736
1737 if (pix_y < 0)
1738 pix_y = 0;
1739 else if (pix_y > FRAME_LINES (f))
1740 pix_y = FRAME_LINES (f);
1741 }
1742 }
1743 #endif
1744
1745 *x = pix_x;
1746 *y = pix_y;
1747 }
1748
1749
1750 /* Find the glyph under window-relative coordinates X/Y in window W.
1751 Consider only glyphs from buffer text, i.e. no glyphs from overlay
1752 strings. Return in *HPOS and *VPOS the row and column number of
1753 the glyph found. Return in *AREA the glyph area containing X.
1754 Value is a pointer to the glyph found or null if X/Y is not on
1755 text, or we can't tell because W's current matrix is not up to
1756 date. */
1757
1758 static
1759 struct glyph *
1760 x_y_to_hpos_vpos (struct window *w, int x, int y, int *hpos, int *vpos,
1761 int *dx, int *dy, int *area)
1762 {
1763 struct glyph *glyph, *end;
1764 struct glyph_row *row = NULL;
1765 int x0, i;
1766
1767 /* Find row containing Y. Give up if some row is not enabled. */
1768 for (i = 0; i < w->current_matrix->nrows; ++i)
1769 {
1770 row = MATRIX_ROW (w->current_matrix, i);
1771 if (!row->enabled_p)
1772 return NULL;
1773 if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
1774 break;
1775 }
1776
1777 *vpos = i;
1778 *hpos = 0;
1779
1780 /* Give up if Y is not in the window. */
1781 if (i == w->current_matrix->nrows)
1782 return NULL;
1783
1784 /* Get the glyph area containing X. */
1785 if (w->pseudo_window_p)
1786 {
1787 *area = TEXT_AREA;
1788 x0 = 0;
1789 }
1790 else
1791 {
1792 if (x < window_box_left_offset (w, TEXT_AREA))
1793 {
1794 *area = LEFT_MARGIN_AREA;
1795 x0 = window_box_left_offset (w, LEFT_MARGIN_AREA);
1796 }
1797 else if (x < window_box_right_offset (w, TEXT_AREA))
1798 {
1799 *area = TEXT_AREA;
1800 x0 = window_box_left_offset (w, TEXT_AREA) + min (row->x, 0);
1801 }
1802 else
1803 {
1804 *area = RIGHT_MARGIN_AREA;
1805 x0 = window_box_left_offset (w, RIGHT_MARGIN_AREA);
1806 }
1807 }
1808
1809 /* Find glyph containing X. */
1810 glyph = row->glyphs[*area];
1811 end = glyph + row->used[*area];
1812 x -= x0;
1813 while (glyph < end && x >= glyph->pixel_width)
1814 {
1815 x -= glyph->pixel_width;
1816 ++glyph;
1817 }
1818
1819 if (glyph == end)
1820 return NULL;
1821
1822 if (dx)
1823 {
1824 *dx = x;
1825 *dy = y - (row->y + row->ascent - glyph->ascent);
1826 }
1827
1828 *hpos = glyph - row->glyphs[*area];
1829 return glyph;
1830 }
1831
1832 /* Convert frame-relative x/y to coordinates relative to window W.
1833 Takes pseudo-windows into account. */
1834
1835 static void
1836 frame_to_window_pixel_xy (struct window *w, int *x, int *y)
1837 {
1838 if (w->pseudo_window_p)
1839 {
1840 /* A pseudo-window is always full-width, and starts at the
1841 left edge of the frame, plus a frame border. */
1842 struct frame *f = XFRAME (w->frame);
1843 *x -= FRAME_INTERNAL_BORDER_WIDTH (f);
1844 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
1845 }
1846 else
1847 {
1848 *x -= WINDOW_LEFT_EDGE_X (w);
1849 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
1850 }
1851 }
1852
1853 #ifdef HAVE_WINDOW_SYSTEM
1854
1855 /* EXPORT:
1856 Return in RECTS[] at most N clipping rectangles for glyph string S.
1857 Return the number of stored rectangles. */
1858
1859 int
1860 get_glyph_string_clip_rects (struct glyph_string *s, NativeRectangle *rects, int n)
1861 {
1862 XRectangle r;
1863
1864 if (n <= 0)
1865 return 0;
1866
1867 if (s->row->full_width_p)
1868 {
1869 /* Draw full-width. X coordinates are relative to S->w->left_col. */
1870 r.x = WINDOW_LEFT_EDGE_X (s->w);
1871 r.width = WINDOW_TOTAL_WIDTH (s->w);
1872
1873 /* Unless displaying a mode or menu bar line, which are always
1874 fully visible, clip to the visible part of the row. */
1875 if (s->w->pseudo_window_p)
1876 r.height = s->row->visible_height;
1877 else
1878 r.height = s->height;
1879 }
1880 else
1881 {
1882 /* This is a text line that may be partially visible. */
1883 r.x = window_box_left (s->w, s->area);
1884 r.width = window_box_width (s->w, s->area);
1885 r.height = s->row->visible_height;
1886 }
1887
1888 if (s->clip_head)
1889 if (r.x < s->clip_head->x)
1890 {
1891 if (r.width >= s->clip_head->x - r.x)
1892 r.width -= s->clip_head->x - r.x;
1893 else
1894 r.width = 0;
1895 r.x = s->clip_head->x;
1896 }
1897 if (s->clip_tail)
1898 if (r.x + r.width > s->clip_tail->x + s->clip_tail->background_width)
1899 {
1900 if (s->clip_tail->x + s->clip_tail->background_width >= r.x)
1901 r.width = s->clip_tail->x + s->clip_tail->background_width - r.x;
1902 else
1903 r.width = 0;
1904 }
1905
1906 /* If S draws overlapping rows, it's sufficient to use the top and
1907 bottom of the window for clipping because this glyph string
1908 intentionally draws over other lines. */
1909 if (s->for_overlaps)
1910 {
1911 r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
1912 r.height = window_text_bottom_y (s->w) - r.y;
1913
1914 /* Alas, the above simple strategy does not work for the
1915 environments with anti-aliased text: if the same text is
1916 drawn onto the same place multiple times, it gets thicker.
1917 If the overlap we are processing is for the erased cursor, we
1918 take the intersection with the rectagle of the cursor. */
1919 if (s->for_overlaps & OVERLAPS_ERASED_CURSOR)
1920 {
1921 XRectangle rc, r_save = r;
1922
1923 rc.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (s->w, s->w->phys_cursor.x);
1924 rc.y = s->w->phys_cursor.y;
1925 rc.width = s->w->phys_cursor_width;
1926 rc.height = s->w->phys_cursor_height;
1927
1928 x_intersect_rectangles (&r_save, &rc, &r);
1929 }
1930 }
1931 else
1932 {
1933 /* Don't use S->y for clipping because it doesn't take partially
1934 visible lines into account. For example, it can be negative for
1935 partially visible lines at the top of a window. */
1936 if (!s->row->full_width_p
1937 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
1938 r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
1939 else
1940 r.y = max (0, s->row->y);
1941 }
1942
1943 r.y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r.y);
1944
1945 /* If drawing the cursor, don't let glyph draw outside its
1946 advertised boundaries. Cleartype does this under some circumstances. */
1947 if (s->hl == DRAW_CURSOR)
1948 {
1949 struct glyph *glyph = s->first_glyph;
1950 int height, max_y;
1951
1952 if (s->x > r.x)
1953 {
1954 r.width -= s->x - r.x;
1955 r.x = s->x;
1956 }
1957 r.width = min (r.width, glyph->pixel_width);
1958
1959 /* If r.y is below window bottom, ensure that we still see a cursor. */
1960 height = min (glyph->ascent + glyph->descent,
1961 min (FRAME_LINE_HEIGHT (s->f), s->row->visible_height));
1962 max_y = window_text_bottom_y (s->w) - height;
1963 max_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, max_y);
1964 if (s->ybase - glyph->ascent > max_y)
1965 {
1966 r.y = max_y;
1967 r.height = height;
1968 }
1969 else
1970 {
1971 /* Don't draw cursor glyph taller than our actual glyph. */
1972 height = max (FRAME_LINE_HEIGHT (s->f), glyph->ascent + glyph->descent);
1973 if (height < r.height)
1974 {
1975 max_y = r.y + r.height;
1976 r.y = min (max_y, max (r.y, s->ybase + glyph->descent - height));
1977 r.height = min (max_y - r.y, height);
1978 }
1979 }
1980 }
1981
1982 if (s->row->clip)
1983 {
1984 XRectangle r_save = r;
1985
1986 if (! x_intersect_rectangles (&r_save, s->row->clip, &r))
1987 r.width = 0;
1988 }
1989
1990 if ((s->for_overlaps & OVERLAPS_BOTH) == 0
1991 || ((s->for_overlaps & OVERLAPS_BOTH) == OVERLAPS_BOTH && n == 1))
1992 {
1993 #ifdef CONVERT_FROM_XRECT
1994 CONVERT_FROM_XRECT (r, *rects);
1995 #else
1996 *rects = r;
1997 #endif
1998 return 1;
1999 }
2000 else
2001 {
2002 /* If we are processing overlapping and allowed to return
2003 multiple clipping rectangles, we exclude the row of the glyph
2004 string from the clipping rectangle. This is to avoid drawing
2005 the same text on the environment with anti-aliasing. */
2006 #ifdef CONVERT_FROM_XRECT
2007 XRectangle rs[2];
2008 #else
2009 XRectangle *rs = rects;
2010 #endif
2011 int i = 0, row_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, s->row->y);
2012
2013 if (s->for_overlaps & OVERLAPS_PRED)
2014 {
2015 rs[i] = r;
2016 if (r.y + r.height > row_y)
2017 {
2018 if (r.y < row_y)
2019 rs[i].height = row_y - r.y;
2020 else
2021 rs[i].height = 0;
2022 }
2023 i++;
2024 }
2025 if (s->for_overlaps & OVERLAPS_SUCC)
2026 {
2027 rs[i] = r;
2028 if (r.y < row_y + s->row->visible_height)
2029 {
2030 if (r.y + r.height > row_y + s->row->visible_height)
2031 {
2032 rs[i].y = row_y + s->row->visible_height;
2033 rs[i].height = r.y + r.height - rs[i].y;
2034 }
2035 else
2036 rs[i].height = 0;
2037 }
2038 i++;
2039 }
2040
2041 n = i;
2042 #ifdef CONVERT_FROM_XRECT
2043 for (i = 0; i < n; i++)
2044 CONVERT_FROM_XRECT (rs[i], rects[i]);
2045 #endif
2046 return n;
2047 }
2048 }
2049
2050 /* EXPORT:
2051 Return in *NR the clipping rectangle for glyph string S. */
2052
2053 void
2054 get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
2055 {
2056 get_glyph_string_clip_rects (s, nr, 1);
2057 }
2058
2059
2060 /* EXPORT:
2061 Return the position and height of the phys cursor in window W.
2062 Set w->phys_cursor_width to width of phys cursor.
2063 */
2064
2065 void
2066 get_phys_cursor_geometry (struct window *w, struct glyph_row *row,
2067 struct glyph *glyph, int *xp, int *yp, int *heightp)
2068 {
2069 struct frame *f = XFRAME (WINDOW_FRAME (w));
2070 int x, y, wd, h, h0, y0;
2071
2072 /* Compute the width of the rectangle to draw. If on a stretch
2073 glyph, and `x-stretch-block-cursor' is nil, don't draw a
2074 rectangle as wide as the glyph, but use a canonical character
2075 width instead. */
2076 wd = glyph->pixel_width - 1;
2077 #if defined (HAVE_NTGUI) || defined (HAVE_NS)
2078 wd++; /* Why? */
2079 #endif
2080
2081 x = w->phys_cursor.x;
2082 if (x < 0)
2083 {
2084 wd += x;
2085 x = 0;
2086 }
2087
2088 if (glyph->type == STRETCH_GLYPH
2089 && !x_stretch_cursor_p)
2090 wd = min (FRAME_COLUMN_WIDTH (f), wd);
2091 w->phys_cursor_width = wd;
2092
2093 y = w->phys_cursor.y + row->ascent - glyph->ascent;
2094
2095 /* If y is below window bottom, ensure that we still see a cursor. */
2096 h0 = min (FRAME_LINE_HEIGHT (f), row->visible_height);
2097
2098 h = max (h0, glyph->ascent + glyph->descent);
2099 h0 = min (h0, glyph->ascent + glyph->descent);
2100
2101 y0 = WINDOW_HEADER_LINE_HEIGHT (w);
2102 if (y < y0)
2103 {
2104 h = max (h - (y0 - y) + 1, h0);
2105 y = y0 - 1;
2106 }
2107 else
2108 {
2109 y0 = window_text_bottom_y (w) - h0;
2110 if (y > y0)
2111 {
2112 h += y - y0;
2113 y = y0;
2114 }
2115 }
2116
2117 *xp = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
2118 *yp = WINDOW_TO_FRAME_PIXEL_Y (w, y);
2119 *heightp = h;
2120 }
2121
2122 /*
2123 * Remember which glyph the mouse is over.
2124 */
2125
2126 void
2127 remember_mouse_glyph (struct frame *f, int gx, int gy, NativeRectangle *rect)
2128 {
2129 Lisp_Object window;
2130 struct window *w;
2131 struct glyph_row *r, *gr, *end_row;
2132 enum window_part part;
2133 enum glyph_row_area area;
2134 int x, y, width, height;
2135
2136 /* Try to determine frame pixel position and size of the glyph under
2137 frame pixel coordinates X/Y on frame F. */
2138
2139 if (!f->glyphs_initialized_p
2140 || (window = window_from_coordinates (f, gx, gy, &part, 0),
2141 NILP (window)))
2142 {
2143 width = FRAME_SMALLEST_CHAR_WIDTH (f);
2144 height = FRAME_SMALLEST_FONT_HEIGHT (f);
2145 goto virtual_glyph;
2146 }
2147
2148 w = XWINDOW (window);
2149 width = WINDOW_FRAME_COLUMN_WIDTH (w);
2150 height = WINDOW_FRAME_LINE_HEIGHT (w);
2151
2152 x = window_relative_x_coord (w, part, gx);
2153 y = gy - WINDOW_TOP_EDGE_Y (w);
2154
2155 r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
2156 end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
2157
2158 if (w->pseudo_window_p)
2159 {
2160 area = TEXT_AREA;
2161 part = ON_MODE_LINE; /* Don't adjust margin. */
2162 goto text_glyph;
2163 }
2164
2165 switch (part)
2166 {
2167 case ON_LEFT_MARGIN:
2168 area = LEFT_MARGIN_AREA;
2169 goto text_glyph;
2170
2171 case ON_RIGHT_MARGIN:
2172 area = RIGHT_MARGIN_AREA;
2173 goto text_glyph;
2174
2175 case ON_HEADER_LINE:
2176 case ON_MODE_LINE:
2177 gr = (part == ON_HEADER_LINE
2178 ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
2179 : MATRIX_MODE_LINE_ROW (w->current_matrix));
2180 gy = gr->y;
2181 area = TEXT_AREA;
2182 goto text_glyph_row_found;
2183
2184 case ON_TEXT:
2185 area = TEXT_AREA;
2186
2187 text_glyph:
2188 gr = 0; gy = 0;
2189 for (; r <= end_row && r->enabled_p; ++r)
2190 if (r->y + r->height > y)
2191 {
2192 gr = r; gy = r->y;
2193 break;
2194 }
2195
2196 text_glyph_row_found:
2197 if (gr && gy <= y)
2198 {
2199 struct glyph *g = gr->glyphs[area];
2200 struct glyph *end = g + gr->used[area];
2201
2202 height = gr->height;
2203 for (gx = gr->x; g < end; gx += g->pixel_width, ++g)
2204 if (gx + g->pixel_width > x)
2205 break;
2206
2207 if (g < end)
2208 {
2209 if (g->type == IMAGE_GLYPH)
2210 {
2211 /* Don't remember when mouse is over image, as
2212 image may have hot-spots. */
2213 STORE_NATIVE_RECT (*rect, 0, 0, 0, 0);
2214 return;
2215 }
2216 width = g->pixel_width;
2217 }
2218 else
2219 {
2220 /* Use nominal char spacing at end of line. */
2221 x -= gx;
2222 gx += (x / width) * width;
2223 }
2224
2225 if (part != ON_MODE_LINE && part != ON_HEADER_LINE)
2226 gx += window_box_left_offset (w, area);
2227 }
2228 else
2229 {
2230 /* Use nominal line height at end of window. */
2231 gx = (x / width) * width;
2232 y -= gy;
2233 gy += (y / height) * height;
2234 }
2235 break;
2236
2237 case ON_LEFT_FRINGE:
2238 gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2239 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w)
2240 : window_box_right_offset (w, LEFT_MARGIN_AREA));
2241 width = WINDOW_LEFT_FRINGE_WIDTH (w);
2242 goto row_glyph;
2243
2244 case ON_RIGHT_FRINGE:
2245 gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2246 ? window_box_right_offset (w, RIGHT_MARGIN_AREA)
2247 : window_box_right_offset (w, TEXT_AREA));
2248 width = WINDOW_RIGHT_FRINGE_WIDTH (w);
2249 goto row_glyph;
2250
2251 case ON_SCROLL_BAR:
2252 gx = (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
2253 ? 0
2254 : (window_box_right_offset (w, RIGHT_MARGIN_AREA)
2255 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2256 ? WINDOW_RIGHT_FRINGE_WIDTH (w)
2257 : 0)));
2258 width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
2259
2260 row_glyph:
2261 gr = 0, gy = 0;
2262 for (; r <= end_row && r->enabled_p; ++r)
2263 if (r->y + r->height > y)
2264 {
2265 gr = r; gy = r->y;
2266 break;
2267 }
2268
2269 if (gr && gy <= y)
2270 height = gr->height;
2271 else
2272 {
2273 /* Use nominal line height at end of window. */
2274 y -= gy;
2275 gy += (y / height) * height;
2276 }
2277 break;
2278
2279 default:
2280 ;
2281 virtual_glyph:
2282 /* If there is no glyph under the mouse, then we divide the screen
2283 into a grid of the smallest glyph in the frame, and use that
2284 as our "glyph". */
2285
2286 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
2287 round down even for negative values. */
2288 if (gx < 0)
2289 gx -= width - 1;
2290 if (gy < 0)
2291 gy -= height - 1;
2292
2293 gx = (gx / width) * width;
2294 gy = (gy / height) * height;
2295
2296 goto store_rect;
2297 }
2298
2299 gx += WINDOW_LEFT_EDGE_X (w);
2300 gy += WINDOW_TOP_EDGE_Y (w);
2301
2302 store_rect:
2303 STORE_NATIVE_RECT (*rect, gx, gy, width, height);
2304
2305 /* Visible feedback for debugging. */
2306 #if 0
2307 #if HAVE_X_WINDOWS
2308 XDrawRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2309 f->output_data.x->normal_gc,
2310 gx, gy, width, height);
2311 #endif
2312 #endif
2313 }
2314
2315
2316 #endif /* HAVE_WINDOW_SYSTEM */
2317
2318 \f
2319 /***********************************************************************
2320 Lisp form evaluation
2321 ***********************************************************************/
2322
2323 /* Error handler for safe_eval and safe_call. */
2324
2325 static Lisp_Object
2326 safe_eval_handler (Lisp_Object arg)
2327 {
2328 add_to_log ("Error during redisplay: %S", arg, Qnil);
2329 return Qnil;
2330 }
2331
2332
2333 /* Evaluate SEXPR and return the result, or nil if something went
2334 wrong. Prevent redisplay during the evaluation. */
2335
2336 /* Call function ARGS[0] with arguments ARGS[1] to ARGS[NARGS - 1].
2337 Return the result, or nil if something went wrong. Prevent
2338 redisplay during the evaluation. */
2339
2340 Lisp_Object
2341 safe_call (ptrdiff_t nargs, Lisp_Object *args)
2342 {
2343 Lisp_Object val;
2344
2345 if (inhibit_eval_during_redisplay)
2346 val = Qnil;
2347 else
2348 {
2349 ptrdiff_t count = SPECPDL_INDEX ();
2350 struct gcpro gcpro1;
2351
2352 GCPRO1 (args[0]);
2353 gcpro1.nvars = nargs;
2354 specbind (Qinhibit_redisplay, Qt);
2355 /* Use Qt to ensure debugger does not run,
2356 so there is no possibility of wanting to redisplay. */
2357 val = internal_condition_case_n (Ffuncall, nargs, args, Qt,
2358 safe_eval_handler);
2359 UNGCPRO;
2360 val = unbind_to (count, val);
2361 }
2362
2363 return val;
2364 }
2365
2366
2367 /* Call function FN with one argument ARG.
2368 Return the result, or nil if something went wrong. */
2369
2370 Lisp_Object
2371 safe_call1 (Lisp_Object fn, Lisp_Object arg)
2372 {
2373 Lisp_Object args[2];
2374 args[0] = fn;
2375 args[1] = arg;
2376 return safe_call (2, args);
2377 }
2378
2379 static Lisp_Object Qeval;
2380
2381 Lisp_Object
2382 safe_eval (Lisp_Object sexpr)
2383 {
2384 return safe_call1 (Qeval, sexpr);
2385 }
2386
2387 /* Call function FN with one argument ARG.
2388 Return the result, or nil if something went wrong. */
2389
2390 Lisp_Object
2391 safe_call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
2392 {
2393 Lisp_Object args[3];
2394 args[0] = fn;
2395 args[1] = arg1;
2396 args[2] = arg2;
2397 return safe_call (3, args);
2398 }
2399
2400
2401 \f
2402 /***********************************************************************
2403 Debugging
2404 ***********************************************************************/
2405
2406 #if 0
2407
2408 /* Define CHECK_IT to perform sanity checks on iterators.
2409 This is for debugging. It is too slow to do unconditionally. */
2410
2411 static void
2412 check_it (struct it *it)
2413 {
2414 if (it->method == GET_FROM_STRING)
2415 {
2416 xassert (STRINGP (it->string));
2417 xassert (IT_STRING_CHARPOS (*it) >= 0);
2418 }
2419 else
2420 {
2421 xassert (IT_STRING_CHARPOS (*it) < 0);
2422 if (it->method == GET_FROM_BUFFER)
2423 {
2424 /* Check that character and byte positions agree. */
2425 xassert (IT_CHARPOS (*it) == BYTE_TO_CHAR (IT_BYTEPOS (*it)));
2426 }
2427 }
2428
2429 if (it->dpvec)
2430 xassert (it->current.dpvec_index >= 0);
2431 else
2432 xassert (it->current.dpvec_index < 0);
2433 }
2434
2435 #define CHECK_IT(IT) check_it ((IT))
2436
2437 #else /* not 0 */
2438
2439 #define CHECK_IT(IT) (void) 0
2440
2441 #endif /* not 0 */
2442
2443
2444 #if GLYPH_DEBUG && XASSERTS
2445
2446 /* Check that the window end of window W is what we expect it
2447 to be---the last row in the current matrix displaying text. */
2448
2449 static void
2450 check_window_end (struct window *w)
2451 {
2452 if (!MINI_WINDOW_P (w)
2453 && !NILP (w->window_end_valid))
2454 {
2455 struct glyph_row *row;
2456 xassert ((row = MATRIX_ROW (w->current_matrix,
2457 XFASTINT (w->window_end_vpos)),
2458 !row->enabled_p
2459 || MATRIX_ROW_DISPLAYS_TEXT_P (row)
2460 || MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
2461 }
2462 }
2463
2464 #define CHECK_WINDOW_END(W) check_window_end ((W))
2465
2466 #else
2467
2468 #define CHECK_WINDOW_END(W) (void) 0
2469
2470 #endif
2471
2472
2473 \f
2474 /***********************************************************************
2475 Iterator initialization
2476 ***********************************************************************/
2477
2478 /* Initialize IT for displaying current_buffer in window W, starting
2479 at character position CHARPOS. CHARPOS < 0 means that no buffer
2480 position is specified which is useful when the iterator is assigned
2481 a position later. BYTEPOS is the byte position corresponding to
2482 CHARPOS. BYTEPOS < 0 means compute it from CHARPOS.
2483
2484 If ROW is not null, calls to produce_glyphs with IT as parameter
2485 will produce glyphs in that row.
2486
2487 BASE_FACE_ID is the id of a base face to use. It must be one of
2488 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
2489 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
2490 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
2491
2492 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
2493 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
2494 will be initialized to use the corresponding mode line glyph row of
2495 the desired matrix of W. */
2496
2497 void
2498 init_iterator (struct it *it, struct window *w,
2499 ptrdiff_t charpos, ptrdiff_t bytepos,
2500 struct glyph_row *row, enum face_id base_face_id)
2501 {
2502 int highlight_region_p;
2503 enum face_id remapped_base_face_id = base_face_id;
2504
2505 /* Some precondition checks. */
2506 xassert (w != NULL && it != NULL);
2507 xassert (charpos < 0 || (charpos >= BUF_BEG (current_buffer)
2508 && charpos <= ZV));
2509
2510 /* If face attributes have been changed since the last redisplay,
2511 free realized faces now because they depend on face definitions
2512 that might have changed. Don't free faces while there might be
2513 desired matrices pending which reference these faces. */
2514 if (face_change_count && !inhibit_free_realized_faces)
2515 {
2516 face_change_count = 0;
2517 free_all_realized_faces (Qnil);
2518 }
2519
2520 /* Perhaps remap BASE_FACE_ID to a user-specified alternative. */
2521 if (! NILP (Vface_remapping_alist))
2522 remapped_base_face_id = lookup_basic_face (XFRAME (w->frame), base_face_id);
2523
2524 /* Use one of the mode line rows of W's desired matrix if
2525 appropriate. */
2526 if (row == NULL)
2527 {
2528 if (base_face_id == MODE_LINE_FACE_ID
2529 || base_face_id == MODE_LINE_INACTIVE_FACE_ID)
2530 row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
2531 else if (base_face_id == HEADER_LINE_FACE_ID)
2532 row = MATRIX_HEADER_LINE_ROW (w->desired_matrix);
2533 }
2534
2535 /* Clear IT. */
2536 memset (it, 0, sizeof *it);
2537 it->current.overlay_string_index = -1;
2538 it->current.dpvec_index = -1;
2539 it->base_face_id = remapped_base_face_id;
2540 it->string = Qnil;
2541 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
2542 it->paragraph_embedding = L2R;
2543 it->bidi_it.string.lstring = Qnil;
2544 it->bidi_it.string.s = NULL;
2545 it->bidi_it.string.bufpos = 0;
2546
2547 /* The window in which we iterate over current_buffer: */
2548 XSETWINDOW (it->window, w);
2549 it->w = w;
2550 it->f = XFRAME (w->frame);
2551
2552 it->cmp_it.id = -1;
2553
2554 /* Extra space between lines (on window systems only). */
2555 if (base_face_id == DEFAULT_FACE_ID
2556 && FRAME_WINDOW_P (it->f))
2557 {
2558 if (NATNUMP (BVAR (current_buffer, extra_line_spacing)))
2559 it->extra_line_spacing = XFASTINT (BVAR (current_buffer, extra_line_spacing));
2560 else if (FLOATP (BVAR (current_buffer, extra_line_spacing)))
2561 it->extra_line_spacing = (XFLOAT_DATA (BVAR (current_buffer, extra_line_spacing))
2562 * FRAME_LINE_HEIGHT (it->f));
2563 else if (it->f->extra_line_spacing > 0)
2564 it->extra_line_spacing = it->f->extra_line_spacing;
2565 it->max_extra_line_spacing = 0;
2566 }
2567
2568 /* If realized faces have been removed, e.g. because of face
2569 attribute changes of named faces, recompute them. When running
2570 in batch mode, the face cache of the initial frame is null. If
2571 we happen to get called, make a dummy face cache. */
2572 if (FRAME_FACE_CACHE (it->f) == NULL)
2573 init_frame_faces (it->f);
2574 if (FRAME_FACE_CACHE (it->f)->used == 0)
2575 recompute_basic_faces (it->f);
2576
2577 /* Current value of the `slice', `space-width', and 'height' properties. */
2578 it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
2579 it->space_width = Qnil;
2580 it->font_height = Qnil;
2581 it->override_ascent = -1;
2582
2583 /* Are control characters displayed as `^C'? */
2584 it->ctl_arrow_p = !NILP (BVAR (current_buffer, ctl_arrow));
2585
2586 /* -1 means everything between a CR and the following line end
2587 is invisible. >0 means lines indented more than this value are
2588 invisible. */
2589 it->selective = (INTEGERP (BVAR (current_buffer, selective_display))
2590 ? clip_to_bounds (-1, XINT (BVAR (current_buffer,
2591 selective_display)),
2592 PTRDIFF_MAX)
2593 : (!NILP (BVAR (current_buffer, selective_display))
2594 ? -1 : 0));
2595 it->selective_display_ellipsis_p
2596 = !NILP (BVAR (current_buffer, selective_display_ellipses));
2597
2598 /* Display table to use. */
2599 it->dp = window_display_table (w);
2600
2601 /* Are multibyte characters enabled in current_buffer? */
2602 it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
2603
2604 /* Non-zero if we should highlight the region. */
2605 highlight_region_p
2606 = (!NILP (Vtransient_mark_mode)
2607 && !NILP (BVAR (current_buffer, mark_active))
2608 && XMARKER (BVAR (current_buffer, mark))->buffer != 0);
2609
2610 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
2611 start and end of a visible region in window IT->w. Set both to
2612 -1 to indicate no region. */
2613 if (highlight_region_p
2614 /* Maybe highlight only in selected window. */
2615 && (/* Either show region everywhere. */
2616 highlight_nonselected_windows
2617 /* Or show region in the selected window. */
2618 || w == XWINDOW (selected_window)
2619 /* Or show the region if we are in the mini-buffer and W is
2620 the window the mini-buffer refers to. */
2621 || (MINI_WINDOW_P (XWINDOW (selected_window))
2622 && WINDOWP (minibuf_selected_window)
2623 && w == XWINDOW (minibuf_selected_window))))
2624 {
2625 ptrdiff_t markpos = marker_position (BVAR (current_buffer, mark));
2626 it->region_beg_charpos = min (PT, markpos);
2627 it->region_end_charpos = max (PT, markpos);
2628 }
2629 else
2630 it->region_beg_charpos = it->region_end_charpos = -1;
2631
2632 /* Get the position at which the redisplay_end_trigger hook should
2633 be run, if it is to be run at all. */
2634 if (MARKERP (w->redisplay_end_trigger)
2635 && XMARKER (w->redisplay_end_trigger)->buffer != 0)
2636 it->redisplay_end_trigger_charpos
2637 = marker_position (w->redisplay_end_trigger);
2638 else if (INTEGERP (w->redisplay_end_trigger))
2639 it->redisplay_end_trigger_charpos =
2640 clip_to_bounds (PTRDIFF_MIN, XINT (w->redisplay_end_trigger), PTRDIFF_MAX);
2641
2642 it->tab_width = SANE_TAB_WIDTH (current_buffer);
2643
2644 /* Are lines in the display truncated? */
2645 if (base_face_id != DEFAULT_FACE_ID
2646 || XINT (it->w->hscroll)
2647 || (! WINDOW_FULL_WIDTH_P (it->w)
2648 && ((!NILP (Vtruncate_partial_width_windows)
2649 && !INTEGERP (Vtruncate_partial_width_windows))
2650 || (INTEGERP (Vtruncate_partial_width_windows)
2651 && (WINDOW_TOTAL_COLS (it->w)
2652 < XINT (Vtruncate_partial_width_windows))))))
2653 it->line_wrap = TRUNCATE;
2654 else if (NILP (BVAR (current_buffer, truncate_lines)))
2655 it->line_wrap = NILP (BVAR (current_buffer, word_wrap))
2656 ? WINDOW_WRAP : WORD_WRAP;
2657 else
2658 it->line_wrap = TRUNCATE;
2659
2660 /* Get dimensions of truncation and continuation glyphs. These are
2661 displayed as fringe bitmaps under X, so we don't need them for such
2662 frames. */
2663 if (!FRAME_WINDOW_P (it->f))
2664 {
2665 if (it->line_wrap == TRUNCATE)
2666 {
2667 /* We will need the truncation glyph. */
2668 xassert (it->glyph_row == NULL);
2669 produce_special_glyphs (it, IT_TRUNCATION);
2670 it->truncation_pixel_width = it->pixel_width;
2671 }
2672 else
2673 {
2674 /* We will need the continuation glyph. */
2675 xassert (it->glyph_row == NULL);
2676 produce_special_glyphs (it, IT_CONTINUATION);
2677 it->continuation_pixel_width = it->pixel_width;
2678 }
2679
2680 /* Reset these values to zero because the produce_special_glyphs
2681 above has changed them. */
2682 it->pixel_width = it->ascent = it->descent = 0;
2683 it->phys_ascent = it->phys_descent = 0;
2684 }
2685
2686 /* Set this after getting the dimensions of truncation and
2687 continuation glyphs, so that we don't produce glyphs when calling
2688 produce_special_glyphs, above. */
2689 it->glyph_row = row;
2690 it->area = TEXT_AREA;
2691
2692 /* Forget any previous info about this row being reversed. */
2693 if (it->glyph_row)
2694 it->glyph_row->reversed_p = 0;
2695
2696 /* Get the dimensions of the display area. The display area
2697 consists of the visible window area plus a horizontally scrolled
2698 part to the left of the window. All x-values are relative to the
2699 start of this total display area. */
2700 if (base_face_id != DEFAULT_FACE_ID)
2701 {
2702 /* Mode lines, menu bar in terminal frames. */
2703 it->first_visible_x = 0;
2704 it->last_visible_x = WINDOW_TOTAL_WIDTH (w);
2705 }
2706 else
2707 {
2708 it->first_visible_x
2709 = XFASTINT (it->w->hscroll) * FRAME_COLUMN_WIDTH (it->f);
2710 it->last_visible_x = (it->first_visible_x
2711 + window_box_width (w, TEXT_AREA));
2712
2713 /* If we truncate lines, leave room for the truncator glyph(s) at
2714 the right margin. Otherwise, leave room for the continuation
2715 glyph(s). Truncation and continuation glyphs are not inserted
2716 for window-based redisplay. */
2717 if (!FRAME_WINDOW_P (it->f))
2718 {
2719 if (it->line_wrap == TRUNCATE)
2720 it->last_visible_x -= it->truncation_pixel_width;
2721 else
2722 it->last_visible_x -= it->continuation_pixel_width;
2723 }
2724
2725 it->header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
2726 it->current_y = WINDOW_HEADER_LINE_HEIGHT (w) + w->vscroll;
2727 }
2728
2729 /* Leave room for a border glyph. */
2730 if (!FRAME_WINDOW_P (it->f)
2731 && !WINDOW_RIGHTMOST_P (it->w))
2732 it->last_visible_x -= 1;
2733
2734 it->last_visible_y = window_text_bottom_y (w);
2735
2736 /* For mode lines and alike, arrange for the first glyph having a
2737 left box line if the face specifies a box. */
2738 if (base_face_id != DEFAULT_FACE_ID)
2739 {
2740 struct face *face;
2741
2742 it->face_id = remapped_base_face_id;
2743
2744 /* If we have a boxed mode line, make the first character appear
2745 with a left box line. */
2746 face = FACE_FROM_ID (it->f, remapped_base_face_id);
2747 if (face->box != FACE_NO_BOX)
2748 it->start_of_box_run_p = 1;
2749 }
2750
2751 /* If a buffer position was specified, set the iterator there,
2752 getting overlays and face properties from that position. */
2753 if (charpos >= BUF_BEG (current_buffer))
2754 {
2755 it->end_charpos = ZV;
2756 it->face_id = -1;
2757 IT_CHARPOS (*it) = charpos;
2758
2759 /* Compute byte position if not specified. */
2760 if (bytepos < charpos)
2761 IT_BYTEPOS (*it) = CHAR_TO_BYTE (charpos);
2762 else
2763 IT_BYTEPOS (*it) = bytepos;
2764
2765 it->start = it->current;
2766 /* Do we need to reorder bidirectional text? Not if this is a
2767 unibyte buffer: by definition, none of the single-byte
2768 characters are strong R2L, so no reordering is needed. And
2769 bidi.c doesn't support unibyte buffers anyway. */
2770 it->bidi_p =
2771 !NILP (BVAR (current_buffer, bidi_display_reordering))
2772 && it->multibyte_p;
2773
2774 /* If we are to reorder bidirectional text, init the bidi
2775 iterator. */
2776 if (it->bidi_p)
2777 {
2778 /* Note the paragraph direction that this buffer wants to
2779 use. */
2780 if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
2781 Qleft_to_right))
2782 it->paragraph_embedding = L2R;
2783 else if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
2784 Qright_to_left))
2785 it->paragraph_embedding = R2L;
2786 else
2787 it->paragraph_embedding = NEUTRAL_DIR;
2788 bidi_unshelve_cache (NULL, 0);
2789 bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
2790 &it->bidi_it);
2791 }
2792
2793 /* Compute faces etc. */
2794 reseat (it, it->current.pos, 1);
2795 }
2796
2797 CHECK_IT (it);
2798 }
2799
2800
2801 /* Initialize IT for the display of window W with window start POS. */
2802
2803 void
2804 start_display (struct it *it, struct window *w, struct text_pos pos)
2805 {
2806 struct glyph_row *row;
2807 int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
2808
2809 row = w->desired_matrix->rows + first_vpos;
2810 init_iterator (it, w, CHARPOS (pos), BYTEPOS (pos), row, DEFAULT_FACE_ID);
2811 it->first_vpos = first_vpos;
2812
2813 /* Don't reseat to previous visible line start if current start
2814 position is in a string or image. */
2815 if (it->method == GET_FROM_BUFFER && it->line_wrap != TRUNCATE)
2816 {
2817 int start_at_line_beg_p;
2818 int first_y = it->current_y;
2819
2820 /* If window start is not at a line start, skip forward to POS to
2821 get the correct continuation lines width. */
2822 start_at_line_beg_p = (CHARPOS (pos) == BEGV
2823 || FETCH_BYTE (BYTEPOS (pos) - 1) == '\n');
2824 if (!start_at_line_beg_p)
2825 {
2826 int new_x;
2827
2828 reseat_at_previous_visible_line_start (it);
2829 move_it_to (it, CHARPOS (pos), -1, -1, -1, MOVE_TO_POS);
2830
2831 new_x = it->current_x + it->pixel_width;
2832
2833 /* If lines are continued, this line may end in the middle
2834 of a multi-glyph character (e.g. a control character
2835 displayed as \003, or in the middle of an overlay
2836 string). In this case move_it_to above will not have
2837 taken us to the start of the continuation line but to the
2838 end of the continued line. */
2839 if (it->current_x > 0
2840 && it->line_wrap != TRUNCATE /* Lines are continued. */
2841 && (/* And glyph doesn't fit on the line. */
2842 new_x > it->last_visible_x
2843 /* Or it fits exactly and we're on a window
2844 system frame. */
2845 || (new_x == it->last_visible_x
2846 && FRAME_WINDOW_P (it->f))))
2847 {
2848 if (it->current.dpvec_index >= 0
2849 || it->current.overlay_string_index >= 0)
2850 {
2851 set_iterator_to_next (it, 1);
2852 move_it_in_display_line_to (it, -1, -1, 0);
2853 }
2854
2855 it->continuation_lines_width += it->current_x;
2856 }
2857 /* If the character at POS is displayed via a display
2858 vector, move_it_to above stops at the final glyph of
2859 IT->dpvec. To make the caller redisplay that character
2860 again (a.k.a. start at POS), we need to reset the
2861 dpvec_index to the beginning of IT->dpvec. */
2862 else if (it->current.dpvec_index >= 0)
2863 it->current.dpvec_index = 0;
2864
2865 /* We're starting a new display line, not affected by the
2866 height of the continued line, so clear the appropriate
2867 fields in the iterator structure. */
2868 it->max_ascent = it->max_descent = 0;
2869 it->max_phys_ascent = it->max_phys_descent = 0;
2870
2871 it->current_y = first_y;
2872 it->vpos = 0;
2873 it->current_x = it->hpos = 0;
2874 }
2875 }
2876 }
2877
2878
2879 /* Return 1 if POS is a position in ellipses displayed for invisible
2880 text. W is the window we display, for text property lookup. */
2881
2882 static int
2883 in_ellipses_for_invisible_text_p (struct display_pos *pos, struct window *w)
2884 {
2885 Lisp_Object prop, window;
2886 int ellipses_p = 0;
2887 ptrdiff_t charpos = CHARPOS (pos->pos);
2888
2889 /* If POS specifies a position in a display vector, this might
2890 be for an ellipsis displayed for invisible text. We won't
2891 get the iterator set up for delivering that ellipsis unless
2892 we make sure that it gets aware of the invisible text. */
2893 if (pos->dpvec_index >= 0
2894 && pos->overlay_string_index < 0
2895 && CHARPOS (pos->string_pos) < 0
2896 && charpos > BEGV
2897 && (XSETWINDOW (window, w),
2898 prop = Fget_char_property (make_number (charpos),
2899 Qinvisible, window),
2900 !TEXT_PROP_MEANS_INVISIBLE (prop)))
2901 {
2902 prop = Fget_char_property (make_number (charpos - 1), Qinvisible,
2903 window);
2904 ellipses_p = 2 == TEXT_PROP_MEANS_INVISIBLE (prop);
2905 }
2906
2907 return ellipses_p;
2908 }
2909
2910
2911 /* Initialize IT for stepping through current_buffer in window W,
2912 starting at position POS that includes overlay string and display
2913 vector/ control character translation position information. Value
2914 is zero if there are overlay strings with newlines at POS. */
2915
2916 static int
2917 init_from_display_pos (struct it *it, struct window *w, struct display_pos *pos)
2918 {
2919 ptrdiff_t charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos);
2920 int i, overlay_strings_with_newlines = 0;
2921
2922 /* If POS specifies a position in a display vector, this might
2923 be for an ellipsis displayed for invisible text. We won't
2924 get the iterator set up for delivering that ellipsis unless
2925 we make sure that it gets aware of the invisible text. */
2926 if (in_ellipses_for_invisible_text_p (pos, w))
2927 {
2928 --charpos;
2929 bytepos = 0;
2930 }
2931
2932 /* Keep in mind: the call to reseat in init_iterator skips invisible
2933 text, so we might end up at a position different from POS. This
2934 is only a problem when POS is a row start after a newline and an
2935 overlay starts there with an after-string, and the overlay has an
2936 invisible property. Since we don't skip invisible text in
2937 display_line and elsewhere immediately after consuming the
2938 newline before the row start, such a POS will not be in a string,
2939 but the call to init_iterator below will move us to the
2940 after-string. */
2941 init_iterator (it, w, charpos, bytepos, NULL, DEFAULT_FACE_ID);
2942
2943 /* This only scans the current chunk -- it should scan all chunks.
2944 However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
2945 to 16 in 22.1 to make this a lesser problem. */
2946 for (i = 0; i < it->n_overlay_strings && i < OVERLAY_STRING_CHUNK_SIZE; ++i)
2947 {
2948 const char *s = SSDATA (it->overlay_strings[i]);
2949 const char *e = s + SBYTES (it->overlay_strings[i]);
2950
2951 while (s < e && *s != '\n')
2952 ++s;
2953
2954 if (s < e)
2955 {
2956 overlay_strings_with_newlines = 1;
2957 break;
2958 }
2959 }
2960
2961 /* If position is within an overlay string, set up IT to the right
2962 overlay string. */
2963 if (pos->overlay_string_index >= 0)
2964 {
2965 int relative_index;
2966
2967 /* If the first overlay string happens to have a `display'
2968 property for an image, the iterator will be set up for that
2969 image, and we have to undo that setup first before we can
2970 correct the overlay string index. */
2971 if (it->method == GET_FROM_IMAGE)
2972 pop_it (it);
2973
2974 /* We already have the first chunk of overlay strings in
2975 IT->overlay_strings. Load more until the one for
2976 pos->overlay_string_index is in IT->overlay_strings. */
2977 if (pos->overlay_string_index >= OVERLAY_STRING_CHUNK_SIZE)
2978 {
2979 ptrdiff_t n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE;
2980 it->current.overlay_string_index = 0;
2981 while (n--)
2982 {
2983 load_overlay_strings (it, 0);
2984 it->current.overlay_string_index += OVERLAY_STRING_CHUNK_SIZE;
2985 }
2986 }
2987
2988 it->current.overlay_string_index = pos->overlay_string_index;
2989 relative_index = (it->current.overlay_string_index
2990 % OVERLAY_STRING_CHUNK_SIZE);
2991 it->string = it->overlay_strings[relative_index];
2992 xassert (STRINGP (it->string));
2993 it->current.string_pos = pos->string_pos;
2994 it->method = GET_FROM_STRING;
2995 }
2996
2997 if (CHARPOS (pos->string_pos) >= 0)
2998 {
2999 /* Recorded position is not in an overlay string, but in another
3000 string. This can only be a string from a `display' property.
3001 IT should already be filled with that string. */
3002 it->current.string_pos = pos->string_pos;
3003 xassert (STRINGP (it->string));
3004 }
3005
3006 /* Restore position in display vector translations, control
3007 character translations or ellipses. */
3008 if (pos->dpvec_index >= 0)
3009 {
3010 if (it->dpvec == NULL)
3011 get_next_display_element (it);
3012 xassert (it->dpvec && it->current.dpvec_index == 0);
3013 it->current.dpvec_index = pos->dpvec_index;
3014 }
3015
3016 CHECK_IT (it);
3017 return !overlay_strings_with_newlines;
3018 }
3019
3020
3021 /* Initialize IT for stepping through current_buffer in window W
3022 starting at ROW->start. */
3023
3024 static void
3025 init_to_row_start (struct it *it, struct window *w, struct glyph_row *row)
3026 {
3027 init_from_display_pos (it, w, &row->start);
3028 it->start = row->start;
3029 it->continuation_lines_width = row->continuation_lines_width;
3030 CHECK_IT (it);
3031 }
3032
3033
3034 /* Initialize IT for stepping through current_buffer in window W
3035 starting in the line following ROW, i.e. starting at ROW->end.
3036 Value is zero if there are overlay strings with newlines at ROW's
3037 end position. */
3038
3039 static int
3040 init_to_row_end (struct it *it, struct window *w, struct glyph_row *row)
3041 {
3042 int success = 0;
3043
3044 if (init_from_display_pos (it, w, &row->end))
3045 {
3046 if (row->continued_p)
3047 it->continuation_lines_width
3048 = row->continuation_lines_width + row->pixel_width;
3049 CHECK_IT (it);
3050 success = 1;
3051 }
3052
3053 return success;
3054 }
3055
3056
3057
3058 \f
3059 /***********************************************************************
3060 Text properties
3061 ***********************************************************************/
3062
3063 /* Called when IT reaches IT->stop_charpos. Handle text property and
3064 overlay changes. Set IT->stop_charpos to the next position where
3065 to stop. */
3066
3067 static void
3068 handle_stop (struct it *it)
3069 {
3070 enum prop_handled handled;
3071 int handle_overlay_change_p;
3072 struct props *p;
3073
3074 it->dpvec = NULL;
3075 it->current.dpvec_index = -1;
3076 handle_overlay_change_p = !it->ignore_overlay_strings_at_pos_p;
3077 it->ignore_overlay_strings_at_pos_p = 0;
3078 it->ellipsis_p = 0;
3079
3080 /* Use face of preceding text for ellipsis (if invisible) */
3081 if (it->selective_display_ellipsis_p)
3082 it->saved_face_id = it->face_id;
3083
3084 do
3085 {
3086 handled = HANDLED_NORMALLY;
3087
3088 /* Call text property handlers. */
3089 for (p = it_props; p->handler; ++p)
3090 {
3091 handled = p->handler (it);
3092
3093 if (handled == HANDLED_RECOMPUTE_PROPS)
3094 break;
3095 else if (handled == HANDLED_RETURN)
3096 {
3097 /* We still want to show before and after strings from
3098 overlays even if the actual buffer text is replaced. */
3099 if (!handle_overlay_change_p
3100 || it->sp > 1
3101 || !get_overlay_strings_1 (it, 0, 0))
3102 {
3103 if (it->ellipsis_p)
3104 setup_for_ellipsis (it, 0);
3105 /* When handling a display spec, we might load an
3106 empty string. In that case, discard it here. We
3107 used to discard it in handle_single_display_spec,
3108 but that causes get_overlay_strings_1, above, to
3109 ignore overlay strings that we must check. */
3110 if (STRINGP (it->string) && !SCHARS (it->string))
3111 pop_it (it);
3112 return;
3113 }
3114 else if (STRINGP (it->string) && !SCHARS (it->string))
3115 pop_it (it);
3116 else
3117 {
3118 it->ignore_overlay_strings_at_pos_p = 1;
3119 it->string_from_display_prop_p = 0;
3120 it->from_disp_prop_p = 0;
3121 handle_overlay_change_p = 0;
3122 }
3123 handled = HANDLED_RECOMPUTE_PROPS;
3124 break;
3125 }
3126 else if (handled == HANDLED_OVERLAY_STRING_CONSUMED)
3127 handle_overlay_change_p = 0;
3128 }
3129
3130 if (handled != HANDLED_RECOMPUTE_PROPS)
3131 {
3132 /* Don't check for overlay strings below when set to deliver
3133 characters from a display vector. */
3134 if (it->method == GET_FROM_DISPLAY_VECTOR)
3135 handle_overlay_change_p = 0;
3136
3137 /* Handle overlay changes.
3138 This sets HANDLED to HANDLED_RECOMPUTE_PROPS
3139 if it finds overlays. */
3140 if (handle_overlay_change_p)
3141 handled = handle_overlay_change (it);
3142 }
3143
3144 if (it->ellipsis_p)
3145 {
3146 setup_for_ellipsis (it, 0);
3147 break;
3148 }
3149 }
3150 while (handled == HANDLED_RECOMPUTE_PROPS);
3151
3152 /* Determine where to stop next. */
3153 if (handled == HANDLED_NORMALLY)
3154 compute_stop_pos (it);
3155 }
3156
3157
3158 /* Compute IT->stop_charpos from text property and overlay change
3159 information for IT's current position. */
3160
3161 static void
3162 compute_stop_pos (struct it *it)
3163 {
3164 register INTERVAL iv, next_iv;
3165 Lisp_Object object, limit, position;
3166 ptrdiff_t charpos, bytepos;
3167
3168 /* If nowhere else, stop at the end. */
3169 it->stop_charpos = it->end_charpos;
3170
3171 if (STRINGP (it->string))
3172 {
3173 /* Strings are usually short, so don't limit the search for
3174 properties. */
3175 object = it->string;
3176 limit = Qnil;
3177 charpos = IT_STRING_CHARPOS (*it);
3178 bytepos = IT_STRING_BYTEPOS (*it);
3179 }
3180 else
3181 {
3182 ptrdiff_t pos;
3183
3184 /* If next overlay change is in front of the current stop pos
3185 (which is IT->end_charpos), stop there. Note: value of
3186 next_overlay_change is point-max if no overlay change
3187 follows. */
3188 charpos = IT_CHARPOS (*it);
3189 bytepos = IT_BYTEPOS (*it);
3190 pos = next_overlay_change (charpos);
3191 if (pos < it->stop_charpos)
3192 it->stop_charpos = pos;
3193
3194 /* If showing the region, we have to stop at the region
3195 start or end because the face might change there. */
3196 if (it->region_beg_charpos > 0)
3197 {
3198 if (IT_CHARPOS (*it) < it->region_beg_charpos)
3199 it->stop_charpos = min (it->stop_charpos, it->region_beg_charpos);
3200 else if (IT_CHARPOS (*it) < it->region_end_charpos)
3201 it->stop_charpos = min (it->stop_charpos, it->region_end_charpos);
3202 }
3203
3204 /* Set up variables for computing the stop position from text
3205 property changes. */
3206 XSETBUFFER (object, current_buffer);
3207 limit = make_number (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT);
3208 }
3209
3210 /* Get the interval containing IT's position. Value is a null
3211 interval if there isn't such an interval. */
3212 position = make_number (charpos);
3213 iv = validate_interval_range (object, &position, &position, 0);
3214 if (!NULL_INTERVAL_P (iv))
3215 {
3216 Lisp_Object values_here[LAST_PROP_IDX];
3217 struct props *p;
3218
3219 /* Get properties here. */
3220 for (p = it_props; p->handler; ++p)
3221 values_here[p->idx] = textget (iv->plist, *p->name);
3222
3223 /* Look for an interval following iv that has different
3224 properties. */
3225 for (next_iv = next_interval (iv);
3226 (!NULL_INTERVAL_P (next_iv)
3227 && (NILP (limit)
3228 || XFASTINT (limit) > next_iv->position));
3229 next_iv = next_interval (next_iv))
3230 {
3231 for (p = it_props; p->handler; ++p)
3232 {
3233 Lisp_Object new_value;
3234
3235 new_value = textget (next_iv->plist, *p->name);
3236 if (!EQ (values_here[p->idx], new_value))
3237 break;
3238 }
3239
3240 if (p->handler)
3241 break;
3242 }
3243
3244 if (!NULL_INTERVAL_P (next_iv))
3245 {
3246 if (INTEGERP (limit)
3247 && next_iv->position >= XFASTINT (limit))
3248 /* No text property change up to limit. */
3249 it->stop_charpos = min (XFASTINT (limit), it->stop_charpos);
3250 else
3251 /* Text properties change in next_iv. */
3252 it->stop_charpos = min (it->stop_charpos, next_iv->position);
3253 }
3254 }
3255
3256 if (it->cmp_it.id < 0)
3257 {
3258 ptrdiff_t stoppos = it->end_charpos;
3259
3260 if (it->bidi_p && it->bidi_it.scan_dir < 0)
3261 stoppos = -1;
3262 composition_compute_stop_pos (&it->cmp_it, charpos, bytepos,
3263 stoppos, it->string);
3264 }
3265
3266 xassert (STRINGP (it->string)
3267 || (it->stop_charpos >= BEGV
3268 && it->stop_charpos >= IT_CHARPOS (*it)));
3269 }
3270
3271
3272 /* Return the position of the next overlay change after POS in
3273 current_buffer. Value is point-max if no overlay change
3274 follows. This is like `next-overlay-change' but doesn't use
3275 xmalloc. */
3276
3277 static ptrdiff_t
3278 next_overlay_change (ptrdiff_t pos)
3279 {
3280 ptrdiff_t i, noverlays;
3281 ptrdiff_t endpos;
3282 Lisp_Object *overlays;
3283
3284 /* Get all overlays at the given position. */
3285 GET_OVERLAYS_AT (pos, overlays, noverlays, &endpos, 1);
3286
3287 /* If any of these overlays ends before endpos,
3288 use its ending point instead. */
3289 for (i = 0; i < noverlays; ++i)
3290 {
3291 Lisp_Object oend;
3292 ptrdiff_t oendpos;
3293
3294 oend = OVERLAY_END (overlays[i]);
3295 oendpos = OVERLAY_POSITION (oend);
3296 endpos = min (endpos, oendpos);
3297 }
3298
3299 return endpos;
3300 }
3301
3302 /* How many characters forward to search for a display property or
3303 display string. Searching too far forward makes the bidi display
3304 sluggish, especially in small windows. */
3305 #define MAX_DISP_SCAN 250
3306
3307 /* Return the character position of a display string at or after
3308 position specified by POSITION. If no display string exists at or
3309 after POSITION, return ZV. A display string is either an overlay
3310 with `display' property whose value is a string, or a `display'
3311 text property whose value is a string. STRING is data about the
3312 string to iterate; if STRING->lstring is nil, we are iterating a
3313 buffer. FRAME_WINDOW_P is non-zero when we are displaying a window
3314 on a GUI frame. DISP_PROP is set to zero if we searched
3315 MAX_DISP_SCAN characters forward without finding any display
3316 strings, non-zero otherwise. It is set to 2 if the display string
3317 uses any kind of `(space ...)' spec that will produce a stretch of
3318 white space in the text area. */
3319 ptrdiff_t
3320 compute_display_string_pos (struct text_pos *position,
3321 struct bidi_string_data *string,
3322 int frame_window_p, int *disp_prop)
3323 {
3324 /* OBJECT = nil means current buffer. */
3325 Lisp_Object object =
3326 (string && STRINGP (string->lstring)) ? string->lstring : Qnil;
3327 Lisp_Object pos, spec, limpos;
3328 int string_p = (string && (STRINGP (string->lstring) || string->s));
3329 ptrdiff_t eob = string_p ? string->schars : ZV;
3330 ptrdiff_t begb = string_p ? 0 : BEGV;
3331 ptrdiff_t bufpos, charpos = CHARPOS (*position);
3332 ptrdiff_t lim =
3333 (charpos < eob - MAX_DISP_SCAN) ? charpos + MAX_DISP_SCAN : eob;
3334 struct text_pos tpos;
3335 int rv = 0;
3336
3337 *disp_prop = 1;
3338
3339 if (charpos >= eob
3340 /* We don't support display properties whose values are strings
3341 that have display string properties. */
3342 || string->from_disp_str
3343 /* C strings cannot have display properties. */
3344 || (string->s && !STRINGP (object)))
3345 {
3346 *disp_prop = 0;
3347 return eob;
3348 }
3349
3350 /* If the character at CHARPOS is where the display string begins,
3351 return CHARPOS. */
3352 pos = make_number (charpos);
3353 if (STRINGP (object))
3354 bufpos = string->bufpos;
3355 else
3356 bufpos = charpos;
3357 tpos = *position;
3358 if (!NILP (spec = Fget_char_property (pos, Qdisplay, object))
3359 && (charpos <= begb
3360 || !EQ (Fget_char_property (make_number (charpos - 1), Qdisplay,
3361 object),
3362 spec))
3363 && (rv = handle_display_spec (NULL, spec, object, Qnil, &tpos, bufpos,
3364 frame_window_p)))
3365 {
3366 if (rv == 2)
3367 *disp_prop = 2;
3368 return charpos;
3369 }
3370
3371 /* Look forward for the first character with a `display' property
3372 that will replace the underlying text when displayed. */
3373 limpos = make_number (lim);
3374 do {
3375 pos = Fnext_single_char_property_change (pos, Qdisplay, object, limpos);
3376 CHARPOS (tpos) = XFASTINT (pos);
3377 if (CHARPOS (tpos) >= lim)
3378 {
3379 *disp_prop = 0;
3380 break;
3381 }
3382 if (STRINGP (object))
3383 BYTEPOS (tpos) = string_char_to_byte (object, CHARPOS (tpos));
3384 else
3385 BYTEPOS (tpos) = CHAR_TO_BYTE (CHARPOS (tpos));
3386 spec = Fget_char_property (pos, Qdisplay, object);
3387 if (!STRINGP (object))
3388 bufpos = CHARPOS (tpos);
3389 } while (NILP (spec)
3390 || !(rv = handle_display_spec (NULL, spec, object, Qnil, &tpos,
3391 bufpos, frame_window_p)));
3392 if (rv == 2)
3393 *disp_prop = 2;
3394
3395 return CHARPOS (tpos);
3396 }
3397
3398 /* Return the character position of the end of the display string that
3399 started at CHARPOS. If there's no display string at CHARPOS,
3400 return -1. A display string is either an overlay with `display'
3401 property whose value is a string or a `display' text property whose
3402 value is a string. */
3403 ptrdiff_t
3404 compute_display_string_end (ptrdiff_t charpos, struct bidi_string_data *string)
3405 {
3406 /* OBJECT = nil means current buffer. */
3407 Lisp_Object object =
3408 (string && STRINGP (string->lstring)) ? string->lstring : Qnil;
3409 Lisp_Object pos = make_number (charpos);
3410 ptrdiff_t eob =
3411 (STRINGP (object) || (string && string->s)) ? string->schars : ZV;
3412
3413 if (charpos >= eob || (string->s && !STRINGP (object)))
3414 return eob;
3415
3416 /* It could happen that the display property or overlay was removed
3417 since we found it in compute_display_string_pos above. One way
3418 this can happen is if JIT font-lock was called (through
3419 handle_fontified_prop), and jit-lock-functions remove text
3420 properties or overlays from the portion of buffer that includes
3421 CHARPOS. Muse mode is known to do that, for example. In this
3422 case, we return -1 to the caller, to signal that no display
3423 string is actually present at CHARPOS. See bidi_fetch_char for
3424 how this is handled.
3425
3426 An alternative would be to never look for display properties past
3427 it->stop_charpos. But neither compute_display_string_pos nor
3428 bidi_fetch_char that calls it know or care where the next
3429 stop_charpos is. */
3430 if (NILP (Fget_char_property (pos, Qdisplay, object)))
3431 return -1;
3432
3433 /* Look forward for the first character where the `display' property
3434 changes. */
3435 pos = Fnext_single_char_property_change (pos, Qdisplay, object, Qnil);
3436
3437 return XFASTINT (pos);
3438 }
3439
3440
3441 \f
3442 /***********************************************************************
3443 Fontification
3444 ***********************************************************************/
3445
3446 /* Handle changes in the `fontified' property of the current buffer by
3447 calling hook functions from Qfontification_functions to fontify
3448 regions of text. */
3449
3450 static enum prop_handled
3451 handle_fontified_prop (struct it *it)
3452 {
3453 Lisp_Object prop, pos;
3454 enum prop_handled handled = HANDLED_NORMALLY;
3455
3456 if (!NILP (Vmemory_full))
3457 return handled;
3458
3459 /* Get the value of the `fontified' property at IT's current buffer
3460 position. (The `fontified' property doesn't have a special
3461 meaning in strings.) If the value is nil, call functions from
3462 Qfontification_functions. */
3463 if (!STRINGP (it->string)
3464 && it->s == NULL
3465 && !NILP (Vfontification_functions)
3466 && !NILP (Vrun_hooks)
3467 && (pos = make_number (IT_CHARPOS (*it)),
3468 prop = Fget_char_property (pos, Qfontified, Qnil),
3469 /* Ignore the special cased nil value always present at EOB since
3470 no amount of fontifying will be able to change it. */
3471 NILP (prop) && IT_CHARPOS (*it) < Z))
3472 {
3473 ptrdiff_t count = SPECPDL_INDEX ();
3474 Lisp_Object val;
3475 struct buffer *obuf = current_buffer;
3476 int begv = BEGV, zv = ZV;
3477 int old_clip_changed = current_buffer->clip_changed;
3478
3479 val = Vfontification_functions;
3480 specbind (Qfontification_functions, Qnil);
3481
3482 xassert (it->end_charpos == ZV);
3483
3484 if (!CONSP (val) || EQ (XCAR (val), Qlambda))
3485 safe_call1 (val, pos);
3486 else
3487 {
3488 Lisp_Object fns, fn;
3489 struct gcpro gcpro1, gcpro2;
3490
3491 fns = Qnil;
3492 GCPRO2 (val, fns);
3493
3494 for (; CONSP (val); val = XCDR (val))
3495 {
3496 fn = XCAR (val);
3497
3498 if (EQ (fn, Qt))
3499 {
3500 /* A value of t indicates this hook has a local
3501 binding; it means to run the global binding too.
3502 In a global value, t should not occur. If it
3503 does, we must ignore it to avoid an endless
3504 loop. */
3505 for (fns = Fdefault_value (Qfontification_functions);
3506 CONSP (fns);
3507 fns = XCDR (fns))
3508 {
3509 fn = XCAR (fns);
3510 if (!EQ (fn, Qt))
3511 safe_call1 (fn, pos);
3512 }
3513 }
3514 else
3515 safe_call1 (fn, pos);
3516 }
3517
3518 UNGCPRO;
3519 }
3520
3521 unbind_to (count, Qnil);
3522
3523 /* Fontification functions routinely call `save-restriction'.
3524 Normally, this tags clip_changed, which can confuse redisplay
3525 (see discussion in Bug#6671). Since we don't perform any
3526 special handling of fontification changes in the case where
3527 `save-restriction' isn't called, there's no point doing so in
3528 this case either. So, if the buffer's restrictions are
3529 actually left unchanged, reset clip_changed. */
3530 if (obuf == current_buffer)
3531 {
3532 if (begv == BEGV && zv == ZV)
3533 current_buffer->clip_changed = old_clip_changed;
3534 }
3535 /* There isn't much we can reasonably do to protect against
3536 misbehaving fontification, but here's a fig leaf. */
3537 else if (!NILP (BVAR (obuf, name)))
3538 set_buffer_internal_1 (obuf);
3539
3540 /* The fontification code may have added/removed text.
3541 It could do even a lot worse, but let's at least protect against
3542 the most obvious case where only the text past `pos' gets changed',
3543 as is/was done in grep.el where some escapes sequences are turned
3544 into face properties (bug#7876). */
3545 it->end_charpos = ZV;
3546
3547 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
3548 something. This avoids an endless loop if they failed to
3549 fontify the text for which reason ever. */
3550 if (!NILP (Fget_char_property (pos, Qfontified, Qnil)))
3551 handled = HANDLED_RECOMPUTE_PROPS;
3552 }
3553
3554 return handled;
3555 }
3556
3557
3558 \f
3559 /***********************************************************************
3560 Faces
3561 ***********************************************************************/
3562
3563 /* Set up iterator IT from face properties at its current position.
3564 Called from handle_stop. */
3565
3566 static enum prop_handled
3567 handle_face_prop (struct it *it)
3568 {
3569 int new_face_id;
3570 ptrdiff_t next_stop;
3571
3572 if (!STRINGP (it->string))
3573 {
3574 new_face_id
3575 = face_at_buffer_position (it->w,
3576 IT_CHARPOS (*it),
3577 it->region_beg_charpos,
3578 it->region_end_charpos,
3579 &next_stop,
3580 (IT_CHARPOS (*it)
3581 + TEXT_PROP_DISTANCE_LIMIT),
3582 0, it->base_face_id);
3583
3584 /* Is this a start of a run of characters with box face?
3585 Caveat: this can be called for a freshly initialized
3586 iterator; face_id is -1 in this case. We know that the new
3587 face will not change until limit, i.e. if the new face has a
3588 box, all characters up to limit will have one. But, as
3589 usual, we don't know whether limit is really the end. */
3590 if (new_face_id != it->face_id)
3591 {
3592 struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
3593
3594 /* If new face has a box but old face has not, this is
3595 the start of a run of characters with box, i.e. it has
3596 a shadow on the left side. The value of face_id of the
3597 iterator will be -1 if this is the initial call that gets
3598 the face. In this case, we have to look in front of IT's
3599 position and see whether there is a face != new_face_id. */
3600 it->start_of_box_run_p
3601 = (new_face->box != FACE_NO_BOX
3602 && (it->face_id >= 0
3603 || IT_CHARPOS (*it) == BEG
3604 || new_face_id != face_before_it_pos (it)));
3605 it->face_box_p = new_face->box != FACE_NO_BOX;
3606 }
3607 }
3608 else
3609 {
3610 int base_face_id;
3611 ptrdiff_t bufpos;
3612 int i;
3613 Lisp_Object from_overlay
3614 = (it->current.overlay_string_index >= 0
3615 ? it->string_overlays[it->current.overlay_string_index]
3616 : Qnil);
3617
3618 /* See if we got to this string directly or indirectly from
3619 an overlay property. That includes the before-string or
3620 after-string of an overlay, strings in display properties
3621 provided by an overlay, their text properties, etc.
3622
3623 FROM_OVERLAY is the overlay that brought us here, or nil if none. */
3624 if (! NILP (from_overlay))
3625 for (i = it->sp - 1; i >= 0; i--)
3626 {
3627 if (it->stack[i].current.overlay_string_index >= 0)
3628 from_overlay
3629 = it->string_overlays[it->stack[i].current.overlay_string_index];
3630 else if (! NILP (it->stack[i].from_overlay))
3631 from_overlay = it->stack[i].from_overlay;
3632
3633 if (!NILP (from_overlay))
3634 break;
3635 }
3636
3637 if (! NILP (from_overlay))
3638 {
3639 bufpos = IT_CHARPOS (*it);
3640 /* For a string from an overlay, the base face depends
3641 only on text properties and ignores overlays. */
3642 base_face_id
3643 = face_for_overlay_string (it->w,
3644 IT_CHARPOS (*it),
3645 it->region_beg_charpos,
3646 it->region_end_charpos,
3647 &next_stop,
3648 (IT_CHARPOS (*it)
3649 + TEXT_PROP_DISTANCE_LIMIT),
3650 0,
3651 from_overlay);
3652 }
3653 else
3654 {
3655 bufpos = 0;
3656
3657 /* For strings from a `display' property, use the face at
3658 IT's current buffer position as the base face to merge
3659 with, so that overlay strings appear in the same face as
3660 surrounding text, unless they specify their own
3661 faces. */
3662 base_face_id = underlying_face_id (it);
3663 }
3664
3665 new_face_id = face_at_string_position (it->w,
3666 it->string,
3667 IT_STRING_CHARPOS (*it),
3668 bufpos,
3669 it->region_beg_charpos,
3670 it->region_end_charpos,
3671 &next_stop,
3672 base_face_id, 0);
3673
3674 /* Is this a start of a run of characters with box? Caveat:
3675 this can be called for a freshly allocated iterator; face_id
3676 is -1 is this case. We know that the new face will not
3677 change until the next check pos, i.e. if the new face has a
3678 box, all characters up to that position will have a
3679 box. But, as usual, we don't know whether that position
3680 is really the end. */
3681 if (new_face_id != it->face_id)
3682 {
3683 struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
3684 struct face *old_face = FACE_FROM_ID (it->f, it->face_id);
3685
3686 /* If new face has a box but old face hasn't, this is the
3687 start of a run of characters with box, i.e. it has a
3688 shadow on the left side. */
3689 it->start_of_box_run_p
3690 = new_face->box && (old_face == NULL || !old_face->box);
3691 it->face_box_p = new_face->box != FACE_NO_BOX;
3692 }
3693 }
3694
3695 it->face_id = new_face_id;
3696 return HANDLED_NORMALLY;
3697 }
3698
3699
3700 /* Return the ID of the face ``underlying'' IT's current position,
3701 which is in a string. If the iterator is associated with a
3702 buffer, return the face at IT's current buffer position.
3703 Otherwise, use the iterator's base_face_id. */
3704
3705 static int
3706 underlying_face_id (struct it *it)
3707 {
3708 int face_id = it->base_face_id, i;
3709
3710 xassert (STRINGP (it->string));
3711
3712 for (i = it->sp - 1; i >= 0; --i)
3713 if (NILP (it->stack[i].string))
3714 face_id = it->stack[i].face_id;
3715
3716 return face_id;
3717 }
3718
3719
3720 /* Compute the face one character before or after the current position
3721 of IT, in the visual order. BEFORE_P non-zero means get the face
3722 in front (to the left in L2R paragraphs, to the right in R2L
3723 paragraphs) of IT's screen position. Value is the ID of the face. */
3724
3725 static int
3726 face_before_or_after_it_pos (struct it *it, int before_p)
3727 {
3728 int face_id, limit;
3729 ptrdiff_t next_check_charpos;
3730 struct it it_copy;
3731 void *it_copy_data = NULL;
3732
3733 xassert (it->s == NULL);
3734
3735 if (STRINGP (it->string))
3736 {
3737 ptrdiff_t bufpos, charpos;
3738 int base_face_id;
3739
3740 /* No face change past the end of the string (for the case
3741 we are padding with spaces). No face change before the
3742 string start. */
3743 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string)
3744 || (IT_STRING_CHARPOS (*it) == 0 && before_p))
3745 return it->face_id;
3746
3747 if (!it->bidi_p)
3748 {
3749 /* Set charpos to the position before or after IT's current
3750 position, in the logical order, which in the non-bidi
3751 case is the same as the visual order. */
3752 if (before_p)
3753 charpos = IT_STRING_CHARPOS (*it) - 1;
3754 else if (it->what == IT_COMPOSITION)
3755 /* For composition, we must check the character after the
3756 composition. */
3757 charpos = IT_STRING_CHARPOS (*it) + it->cmp_it.nchars;
3758 else
3759 charpos = IT_STRING_CHARPOS (*it) + 1;
3760 }
3761 else
3762 {
3763 if (before_p)
3764 {
3765 /* With bidi iteration, the character before the current
3766 in the visual order cannot be found by simple
3767 iteration, because "reverse" reordering is not
3768 supported. Instead, we need to use the move_it_*
3769 family of functions. */
3770 /* Ignore face changes before the first visible
3771 character on this display line. */
3772 if (it->current_x <= it->first_visible_x)
3773 return it->face_id;
3774 SAVE_IT (it_copy, *it, it_copy_data);
3775 /* Implementation note: Since move_it_in_display_line
3776 works in the iterator geometry, and thinks the first
3777 character is always the leftmost, even in R2L lines,
3778 we don't need to distinguish between the R2L and L2R
3779 cases here. */
3780 move_it_in_display_line (&it_copy, SCHARS (it_copy.string),
3781 it_copy.current_x - 1, MOVE_TO_X);
3782 charpos = IT_STRING_CHARPOS (it_copy);
3783 RESTORE_IT (it, it, it_copy_data);
3784 }
3785 else
3786 {
3787 /* Set charpos to the string position of the character
3788 that comes after IT's current position in the visual
3789 order. */
3790 int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
3791
3792 it_copy = *it;
3793 while (n--)
3794 bidi_move_to_visually_next (&it_copy.bidi_it);
3795
3796 charpos = it_copy.bidi_it.charpos;
3797 }
3798 }
3799 xassert (0 <= charpos && charpos <= SCHARS (it->string));
3800
3801 if (it->current.overlay_string_index >= 0)
3802 bufpos = IT_CHARPOS (*it);
3803 else
3804 bufpos = 0;
3805
3806 base_face_id = underlying_face_id (it);
3807
3808 /* Get the face for ASCII, or unibyte. */
3809 face_id = face_at_string_position (it->w,
3810 it->string,
3811 charpos,
3812 bufpos,
3813 it->region_beg_charpos,
3814 it->region_end_charpos,
3815 &next_check_charpos,
3816 base_face_id, 0);
3817
3818 /* Correct the face for charsets different from ASCII. Do it
3819 for the multibyte case only. The face returned above is
3820 suitable for unibyte text if IT->string is unibyte. */
3821 if (STRING_MULTIBYTE (it->string))
3822 {
3823 struct text_pos pos1 = string_pos (charpos, it->string);
3824 const unsigned char *p = SDATA (it->string) + BYTEPOS (pos1);
3825 int c, len;
3826 struct face *face = FACE_FROM_ID (it->f, face_id);
3827
3828 c = string_char_and_length (p, &len);
3829 face_id = FACE_FOR_CHAR (it->f, face, c, charpos, it->string);
3830 }
3831 }
3832 else
3833 {
3834 struct text_pos pos;
3835
3836 if ((IT_CHARPOS (*it) >= ZV && !before_p)
3837 || (IT_CHARPOS (*it) <= BEGV && before_p))
3838 return it->face_id;
3839
3840 limit = IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT;
3841 pos = it->current.pos;
3842
3843 if (!it->bidi_p)
3844 {
3845 if (before_p)
3846 DEC_TEXT_POS (pos, it->multibyte_p);
3847 else
3848 {
3849 if (it->what == IT_COMPOSITION)
3850 {
3851 /* For composition, we must check the position after
3852 the composition. */
3853 pos.charpos += it->cmp_it.nchars;
3854 pos.bytepos += it->len;
3855 }
3856 else
3857 INC_TEXT_POS (pos, it->multibyte_p);
3858 }
3859 }
3860 else
3861 {
3862 if (before_p)
3863 {
3864 /* With bidi iteration, the character before the current
3865 in the visual order cannot be found by simple
3866 iteration, because "reverse" reordering is not
3867 supported. Instead, we need to use the move_it_*
3868 family of functions. */
3869 /* Ignore face changes before the first visible
3870 character on this display line. */
3871 if (it->current_x <= it->first_visible_x)
3872 return it->face_id;
3873 SAVE_IT (it_copy, *it, it_copy_data);
3874 /* Implementation note: Since move_it_in_display_line
3875 works in the iterator geometry, and thinks the first
3876 character is always the leftmost, even in R2L lines,
3877 we don't need to distinguish between the R2L and L2R
3878 cases here. */
3879 move_it_in_display_line (&it_copy, ZV,
3880 it_copy.current_x - 1, MOVE_TO_X);
3881 pos = it_copy.current.pos;
3882 RESTORE_IT (it, it, it_copy_data);
3883 }
3884 else
3885 {
3886 /* Set charpos to the buffer position of the character
3887 that comes after IT's current position in the visual
3888 order. */
3889 int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
3890
3891 it_copy = *it;
3892 while (n--)
3893 bidi_move_to_visually_next (&it_copy.bidi_it);
3894
3895 SET_TEXT_POS (pos,
3896 it_copy.bidi_it.charpos, it_copy.bidi_it.bytepos);
3897 }
3898 }
3899 xassert (BEGV <= CHARPOS (pos) && CHARPOS (pos) <= ZV);
3900
3901 /* Determine face for CHARSET_ASCII, or unibyte. */
3902 face_id = face_at_buffer_position (it->w,
3903 CHARPOS (pos),
3904 it->region_beg_charpos,
3905 it->region_end_charpos,
3906 &next_check_charpos,
3907 limit, 0, -1);
3908
3909 /* Correct the face for charsets different from ASCII. Do it
3910 for the multibyte case only. The face returned above is
3911 suitable for unibyte text if current_buffer is unibyte. */
3912 if (it->multibyte_p)
3913 {
3914 int c = FETCH_MULTIBYTE_CHAR (BYTEPOS (pos));
3915 struct face *face = FACE_FROM_ID (it->f, face_id);
3916 face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), Qnil);
3917 }
3918 }
3919
3920 return face_id;
3921 }
3922
3923
3924 \f
3925 /***********************************************************************
3926 Invisible text
3927 ***********************************************************************/
3928
3929 /* Set up iterator IT from invisible properties at its current
3930 position. Called from handle_stop. */
3931
3932 static enum prop_handled
3933 handle_invisible_prop (struct it *it)
3934 {
3935 enum prop_handled handled = HANDLED_NORMALLY;
3936
3937 if (STRINGP (it->string))
3938 {
3939 Lisp_Object prop, end_charpos, limit, charpos;
3940
3941 /* Get the value of the invisible text property at the
3942 current position. Value will be nil if there is no such
3943 property. */
3944 charpos = make_number (IT_STRING_CHARPOS (*it));
3945 prop = Fget_text_property (charpos, Qinvisible, it->string);
3946
3947 if (!NILP (prop)
3948 && IT_STRING_CHARPOS (*it) < it->end_charpos)
3949 {
3950 ptrdiff_t endpos;
3951
3952 handled = HANDLED_RECOMPUTE_PROPS;
3953
3954 /* Get the position at which the next change of the
3955 invisible text property can be found in IT->string.
3956 Value will be nil if the property value is the same for
3957 all the rest of IT->string. */
3958 XSETINT (limit, SCHARS (it->string));
3959 end_charpos = Fnext_single_property_change (charpos, Qinvisible,
3960 it->string, limit);
3961
3962 /* Text at current position is invisible. The next
3963 change in the property is at position end_charpos.
3964 Move IT's current position to that position. */
3965 if (INTEGERP (end_charpos)
3966 && (endpos = XFASTINT (end_charpos)) < XFASTINT (limit))
3967 {
3968 struct text_pos old;
3969 ptrdiff_t oldpos;
3970
3971 old = it->current.string_pos;
3972 oldpos = CHARPOS (old);
3973 if (it->bidi_p)
3974 {
3975 if (it->bidi_it.first_elt
3976 && it->bidi_it.charpos < SCHARS (it->string))
3977 bidi_paragraph_init (it->paragraph_embedding,
3978 &it->bidi_it, 1);
3979 /* Bidi-iterate out of the invisible text. */
3980 do
3981 {
3982 bidi_move_to_visually_next (&it->bidi_it);
3983 }
3984 while (oldpos <= it->bidi_it.charpos
3985 && it->bidi_it.charpos < endpos);
3986
3987 IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
3988 IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
3989 if (IT_CHARPOS (*it) >= endpos)
3990 it->prev_stop = endpos;
3991 }
3992 else
3993 {
3994 IT_STRING_CHARPOS (*it) = XFASTINT (end_charpos);
3995 compute_string_pos (&it->current.string_pos, old, it->string);
3996 }
3997 }
3998 else
3999 {
4000 /* The rest of the string is invisible. If this is an
4001 overlay string, proceed with the next overlay string
4002 or whatever comes and return a character from there. */
4003 if (it->current.overlay_string_index >= 0)
4004 {
4005 next_overlay_string (it);
4006 /* Don't check for overlay strings when we just
4007 finished processing them. */
4008 handled = HANDLED_OVERLAY_STRING_CONSUMED;
4009 }
4010 else
4011 {
4012 IT_STRING_CHARPOS (*it) = SCHARS (it->string);
4013 IT_STRING_BYTEPOS (*it) = SBYTES (it->string);
4014 }
4015 }
4016 }
4017 }
4018 else
4019 {
4020 int invis_p;
4021 ptrdiff_t newpos, next_stop, start_charpos, tem;
4022 Lisp_Object pos, prop, overlay;
4023
4024 /* First of all, is there invisible text at this position? */
4025 tem = start_charpos = IT_CHARPOS (*it);
4026 pos = make_number (tem);
4027 prop = get_char_property_and_overlay (pos, Qinvisible, it->window,
4028 &overlay);
4029 invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
4030
4031 /* If we are on invisible text, skip over it. */
4032 if (invis_p && start_charpos < it->end_charpos)
4033 {
4034 /* Record whether we have to display an ellipsis for the
4035 invisible text. */
4036 int display_ellipsis_p = invis_p == 2;
4037
4038 handled = HANDLED_RECOMPUTE_PROPS;
4039
4040 /* Loop skipping over invisible text. The loop is left at
4041 ZV or with IT on the first char being visible again. */
4042 do
4043 {
4044 /* Try to skip some invisible text. Return value is the
4045 position reached which can be equal to where we start
4046 if there is nothing invisible there. This skips both
4047 over invisible text properties and overlays with
4048 invisible property. */
4049 newpos = skip_invisible (tem, &next_stop, ZV, it->window);
4050
4051 /* If we skipped nothing at all we weren't at invisible
4052 text in the first place. If everything to the end of
4053 the buffer was skipped, end the loop. */
4054 if (newpos == tem || newpos >= ZV)
4055 invis_p = 0;
4056 else
4057 {
4058 /* We skipped some characters but not necessarily
4059 all there are. Check if we ended up on visible
4060 text. Fget_char_property returns the property of
4061 the char before the given position, i.e. if we
4062 get invis_p = 0, this means that the char at
4063 newpos is visible. */
4064 pos = make_number (newpos);
4065 prop = Fget_char_property (pos, Qinvisible, it->window);
4066 invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
4067 }
4068
4069 /* If we ended up on invisible text, proceed to
4070 skip starting with next_stop. */
4071 if (invis_p)
4072 tem = next_stop;
4073
4074 /* If there are adjacent invisible texts, don't lose the
4075 second one's ellipsis. */
4076 if (invis_p == 2)
4077 display_ellipsis_p = 1;
4078 }
4079 while (invis_p);
4080
4081 /* The position newpos is now either ZV or on visible text. */
4082 if (it->bidi_p && newpos < ZV)
4083 {
4084 ptrdiff_t bpos = CHAR_TO_BYTE (newpos);
4085
4086 if (FETCH_BYTE (bpos) == '\n'
4087 || (newpos > BEGV && FETCH_BYTE (bpos - 1) == '\n'))
4088 {
4089 /* If the invisible text ends on a newline or the
4090 character after a newline, we can avoid the
4091 costly, character by character, bidi iteration to
4092 newpos, and instead simply reseat the iterator
4093 there. That's because all bidi reordering
4094 information is tossed at the newline. This is a
4095 big win for modes that hide complete lines, like
4096 Outline, Org, etc. (Implementation note: the
4097 call to reseat_1 is necessary, because it signals
4098 to the bidi iterator that it needs to reinit its
4099 internal information when the next element for
4100 display is requested. */
4101 struct text_pos tpos;
4102
4103 SET_TEXT_POS (tpos, newpos, bpos);
4104 reseat_1 (it, tpos, 0);
4105 }
4106 else /* Must use the slow method. */
4107 {
4108 /* With bidi iteration, the region of invisible text
4109 could start and/or end in the middle of a
4110 non-base embedding level. Therefore, we need to
4111 skip invisible text using the bidi iterator,
4112 starting at IT's current position, until we find
4113 ourselves outside the invisible text. Skipping
4114 invisible text _after_ bidi iteration avoids
4115 affecting the visual order of the displayed text
4116 when invisible properties are added or
4117 removed. */
4118 if (it->bidi_it.first_elt && it->bidi_it.charpos < ZV)
4119 {
4120 /* If we were `reseat'ed to a new paragraph,
4121 determine the paragraph base direction. We
4122 need to do it now because
4123 next_element_from_buffer may not have a
4124 chance to do it, if we are going to skip any
4125 text at the beginning, which resets the
4126 FIRST_ELT flag. */
4127 bidi_paragraph_init (it->paragraph_embedding,
4128 &it->bidi_it, 1);
4129 }
4130 do
4131 {
4132 bidi_move_to_visually_next (&it->bidi_it);
4133 }
4134 while (it->stop_charpos <= it->bidi_it.charpos
4135 && it->bidi_it.charpos < newpos);
4136 IT_CHARPOS (*it) = it->bidi_it.charpos;
4137 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
4138 /* If we overstepped NEWPOS, record its position in
4139 the iterator, so that we skip invisible text if
4140 later the bidi iteration lands us in the
4141 invisible region again. */
4142 if (IT_CHARPOS (*it) >= newpos)
4143 it->prev_stop = newpos;
4144 }
4145 }
4146 else
4147 {
4148 IT_CHARPOS (*it) = newpos;
4149 IT_BYTEPOS (*it) = CHAR_TO_BYTE (newpos);
4150 }
4151
4152 /* If there are before-strings at the start of invisible
4153 text, and the text is invisible because of a text
4154 property, arrange to show before-strings because 20.x did
4155 it that way. (If the text is invisible because of an
4156 overlay property instead of a text property, this is
4157 already handled in the overlay code.) */
4158 if (NILP (overlay)
4159 && get_overlay_strings (it, it->stop_charpos))
4160 {
4161 handled = HANDLED_RECOMPUTE_PROPS;
4162 it->stack[it->sp - 1].display_ellipsis_p = display_ellipsis_p;
4163 }
4164 else if (display_ellipsis_p)
4165 {
4166 /* Make sure that the glyphs of the ellipsis will get
4167 correct `charpos' values. If we would not update
4168 it->position here, the glyphs would belong to the
4169 last visible character _before_ the invisible
4170 text, which confuses `set_cursor_from_row'.
4171
4172 We use the last invisible position instead of the
4173 first because this way the cursor is always drawn on
4174 the first "." of the ellipsis, whenever PT is inside
4175 the invisible text. Otherwise the cursor would be
4176 placed _after_ the ellipsis when the point is after the
4177 first invisible character. */
4178 if (!STRINGP (it->object))
4179 {
4180 it->position.charpos = newpos - 1;
4181 it->position.bytepos = CHAR_TO_BYTE (it->position.charpos);
4182 }
4183 it->ellipsis_p = 1;
4184 /* Let the ellipsis display before
4185 considering any properties of the following char.
4186 Fixes jasonr@gnu.org 01 Oct 07 bug. */
4187 handled = HANDLED_RETURN;
4188 }
4189 }
4190 }
4191
4192 return handled;
4193 }
4194
4195
4196 /* Make iterator IT return `...' next.
4197 Replaces LEN characters from buffer. */
4198
4199 static void
4200 setup_for_ellipsis (struct it *it, int len)
4201 {
4202 /* Use the display table definition for `...'. Invalid glyphs
4203 will be handled by the method returning elements from dpvec. */
4204 if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
4205 {
4206 struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
4207 it->dpvec = v->contents;
4208 it->dpend = v->contents + v->header.size;
4209 }
4210 else
4211 {
4212 /* Default `...'. */
4213 it->dpvec = default_invis_vector;
4214 it->dpend = default_invis_vector + 3;
4215 }
4216
4217 it->dpvec_char_len = len;
4218 it->current.dpvec_index = 0;
4219 it->dpvec_face_id = -1;
4220
4221 /* Remember the current face id in case glyphs specify faces.
4222 IT's face is restored in set_iterator_to_next.
4223 saved_face_id was set to preceding char's face in handle_stop. */
4224 if (it->saved_face_id < 0 || it->saved_face_id != it->face_id)
4225 it->saved_face_id = it->face_id = DEFAULT_FACE_ID;
4226
4227 it->method = GET_FROM_DISPLAY_VECTOR;
4228 it->ellipsis_p = 1;
4229 }
4230
4231
4232 \f
4233 /***********************************************************************
4234 'display' property
4235 ***********************************************************************/
4236
4237 /* Set up iterator IT from `display' property at its current position.
4238 Called from handle_stop.
4239 We return HANDLED_RETURN if some part of the display property
4240 overrides the display of the buffer text itself.
4241 Otherwise we return HANDLED_NORMALLY. */
4242
4243 static enum prop_handled
4244 handle_display_prop (struct it *it)
4245 {
4246 Lisp_Object propval, object, overlay;
4247 struct text_pos *position;
4248 ptrdiff_t bufpos;
4249 /* Nonzero if some property replaces the display of the text itself. */
4250 int display_replaced_p = 0;
4251
4252 if (STRINGP (it->string))
4253 {
4254 object = it->string;
4255 position = &it->current.string_pos;
4256 bufpos = CHARPOS (it->current.pos);
4257 }
4258 else
4259 {
4260 XSETWINDOW (object, it->w);
4261 position = &it->current.pos;
4262 bufpos = CHARPOS (*position);
4263 }
4264
4265 /* Reset those iterator values set from display property values. */
4266 it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
4267 it->space_width = Qnil;
4268 it->font_height = Qnil;
4269 it->voffset = 0;
4270
4271 /* We don't support recursive `display' properties, i.e. string
4272 values that have a string `display' property, that have a string
4273 `display' property etc. */
4274 if (!it->string_from_display_prop_p)
4275 it->area = TEXT_AREA;
4276
4277 propval = get_char_property_and_overlay (make_number (position->charpos),
4278 Qdisplay, object, &overlay);
4279 if (NILP (propval))
4280 return HANDLED_NORMALLY;
4281 /* Now OVERLAY is the overlay that gave us this property, or nil
4282 if it was a text property. */
4283
4284 if (!STRINGP (it->string))
4285 object = it->w->buffer;
4286
4287 display_replaced_p = handle_display_spec (it, propval, object, overlay,
4288 position, bufpos,
4289 FRAME_WINDOW_P (it->f));
4290
4291 return display_replaced_p ? HANDLED_RETURN : HANDLED_NORMALLY;
4292 }
4293
4294 /* Subroutine of handle_display_prop. Returns non-zero if the display
4295 specification in SPEC is a replacing specification, i.e. it would
4296 replace the text covered by `display' property with something else,
4297 such as an image or a display string. If SPEC includes any kind or
4298 `(space ...) specification, the value is 2; this is used by
4299 compute_display_string_pos, which see.
4300
4301 See handle_single_display_spec for documentation of arguments.
4302 frame_window_p is non-zero if the window being redisplayed is on a
4303 GUI frame; this argument is used only if IT is NULL, see below.
4304
4305 IT can be NULL, if this is called by the bidi reordering code
4306 through compute_display_string_pos, which see. In that case, this
4307 function only examines SPEC, but does not otherwise "handle" it, in
4308 the sense that it doesn't set up members of IT from the display
4309 spec. */
4310 static int
4311 handle_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
4312 Lisp_Object overlay, struct text_pos *position,
4313 ptrdiff_t bufpos, int frame_window_p)
4314 {
4315 int replacing_p = 0;
4316 int rv;
4317
4318 if (CONSP (spec)
4319 /* Simple specerties. */
4320 && !EQ (XCAR (spec), Qimage)
4321 && !EQ (XCAR (spec), Qspace)
4322 && !EQ (XCAR (spec), Qwhen)
4323 && !EQ (XCAR (spec), Qslice)
4324 && !EQ (XCAR (spec), Qspace_width)
4325 && !EQ (XCAR (spec), Qheight)
4326 && !EQ (XCAR (spec), Qraise)
4327 /* Marginal area specifications. */
4328 && !(CONSP (XCAR (spec)) && EQ (XCAR (XCAR (spec)), Qmargin))
4329 && !EQ (XCAR (spec), Qleft_fringe)
4330 && !EQ (XCAR (spec), Qright_fringe)
4331 && !NILP (XCAR (spec)))
4332 {
4333 for (; CONSP (spec); spec = XCDR (spec))
4334 {
4335 if ((rv = handle_single_display_spec (it, XCAR (spec), object,
4336 overlay, position, bufpos,
4337 replacing_p, frame_window_p)))
4338 {
4339 replacing_p = rv;
4340 /* If some text in a string is replaced, `position' no
4341 longer points to the position of `object'. */
4342 if (!it || STRINGP (object))
4343 break;
4344 }
4345 }
4346 }
4347 else if (VECTORP (spec))
4348 {
4349 ptrdiff_t i;
4350 for (i = 0; i < ASIZE (spec); ++i)
4351 if ((rv = handle_single_display_spec (it, AREF (spec, i), object,
4352 overlay, position, bufpos,
4353 replacing_p, frame_window_p)))
4354 {
4355 replacing_p = rv;
4356 /* If some text in a string is replaced, `position' no
4357 longer points to the position of `object'. */
4358 if (!it || STRINGP (object))
4359 break;
4360 }
4361 }
4362 else
4363 {
4364 if ((rv = handle_single_display_spec (it, spec, object, overlay,
4365 position, bufpos, 0,
4366 frame_window_p)))
4367 replacing_p = rv;
4368 }
4369
4370 return replacing_p;
4371 }
4372
4373 /* Value is the position of the end of the `display' property starting
4374 at START_POS in OBJECT. */
4375
4376 static struct text_pos
4377 display_prop_end (struct it *it, Lisp_Object object, struct text_pos start_pos)
4378 {
4379 Lisp_Object end;
4380 struct text_pos end_pos;
4381
4382 end = Fnext_single_char_property_change (make_number (CHARPOS (start_pos)),
4383 Qdisplay, object, Qnil);
4384 CHARPOS (end_pos) = XFASTINT (end);
4385 if (STRINGP (object))
4386 compute_string_pos (&end_pos, start_pos, it->string);
4387 else
4388 BYTEPOS (end_pos) = CHAR_TO_BYTE (XFASTINT (end));
4389
4390 return end_pos;
4391 }
4392
4393
4394 /* Set up IT from a single `display' property specification SPEC. OBJECT
4395 is the object in which the `display' property was found. *POSITION
4396 is the position in OBJECT at which the `display' property was found.
4397 BUFPOS is the buffer position of OBJECT (different from POSITION if
4398 OBJECT is not a buffer). DISPLAY_REPLACED_P non-zero means that we
4399 previously saw a display specification which already replaced text
4400 display with something else, for example an image; we ignore such
4401 properties after the first one has been processed.
4402
4403 OVERLAY is the overlay this `display' property came from,
4404 or nil if it was a text property.
4405
4406 If SPEC is a `space' or `image' specification, and in some other
4407 cases too, set *POSITION to the position where the `display'
4408 property ends.
4409
4410 If IT is NULL, only examine the property specification in SPEC, but
4411 don't set up IT. In that case, FRAME_WINDOW_P non-zero means SPEC
4412 is intended to be displayed in a window on a GUI frame.
4413
4414 Value is non-zero if something was found which replaces the display
4415 of buffer or string text. */
4416
4417 static int
4418 handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
4419 Lisp_Object overlay, struct text_pos *position,
4420 ptrdiff_t bufpos, int display_replaced_p,
4421 int frame_window_p)
4422 {
4423 Lisp_Object form;
4424 Lisp_Object location, value;
4425 struct text_pos start_pos = *position;
4426 int valid_p;
4427
4428 /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
4429 If the result is non-nil, use VALUE instead of SPEC. */
4430 form = Qt;
4431 if (CONSP (spec) && EQ (XCAR (spec), Qwhen))
4432 {
4433 spec = XCDR (spec);
4434 if (!CONSP (spec))
4435 return 0;
4436 form = XCAR (spec);
4437 spec = XCDR (spec);
4438 }
4439
4440 if (!NILP (form) && !EQ (form, Qt))
4441 {
4442 ptrdiff_t count = SPECPDL_INDEX ();
4443 struct gcpro gcpro1;
4444
4445 /* Bind `object' to the object having the `display' property, a
4446 buffer or string. Bind `position' to the position in the
4447 object where the property was found, and `buffer-position'
4448 to the current position in the buffer. */
4449
4450 if (NILP (object))
4451 XSETBUFFER (object, current_buffer);
4452 specbind (Qobject, object);
4453 specbind (Qposition, make_number (CHARPOS (*position)));
4454 specbind (Qbuffer_position, make_number (bufpos));
4455 GCPRO1 (form);
4456 form = safe_eval (form);
4457 UNGCPRO;
4458 unbind_to (count, Qnil);
4459 }
4460
4461 if (NILP (form))
4462 return 0;
4463
4464 /* Handle `(height HEIGHT)' specifications. */
4465 if (CONSP (spec)
4466 && EQ (XCAR (spec), Qheight)
4467 && CONSP (XCDR (spec)))
4468 {
4469 if (it)
4470 {
4471 if (!FRAME_WINDOW_P (it->f))
4472 return 0;
4473
4474 it->font_height = XCAR (XCDR (spec));
4475 if (!NILP (it->font_height))
4476 {
4477 struct face *face = FACE_FROM_ID (it->f, it->face_id);
4478 int new_height = -1;
4479
4480 if (CONSP (it->font_height)
4481 && (EQ (XCAR (it->font_height), Qplus)
4482 || EQ (XCAR (it->font_height), Qminus))
4483 && CONSP (XCDR (it->font_height))
4484 && RANGED_INTEGERP (0, XCAR (XCDR (it->font_height)), INT_MAX))
4485 {
4486 /* `(+ N)' or `(- N)' where N is an integer. */
4487 int steps = XINT (XCAR (XCDR (it->font_height)));
4488 if (EQ (XCAR (it->font_height), Qplus))
4489 steps = - steps;
4490 it->face_id = smaller_face (it->f, it->face_id, steps);
4491 }
4492 else if (FUNCTIONP (it->font_height))
4493 {
4494 /* Call function with current height as argument.
4495 Value is the new height. */
4496 Lisp_Object height;
4497 height = safe_call1 (it->font_height,
4498 face->lface[LFACE_HEIGHT_INDEX]);
4499 if (NUMBERP (height))
4500 new_height = XFLOATINT (height);
4501 }
4502 else if (NUMBERP (it->font_height))
4503 {
4504 /* Value is a multiple of the canonical char height. */
4505 struct face *f;
4506
4507 f = FACE_FROM_ID (it->f,
4508 lookup_basic_face (it->f, DEFAULT_FACE_ID));
4509 new_height = (XFLOATINT (it->font_height)
4510 * XINT (f->lface[LFACE_HEIGHT_INDEX]));
4511 }
4512 else
4513 {
4514 /* Evaluate IT->font_height with `height' bound to the
4515 current specified height to get the new height. */
4516 ptrdiff_t count = SPECPDL_INDEX ();
4517
4518 specbind (Qheight, face->lface[LFACE_HEIGHT_INDEX]);
4519 value = safe_eval (it->font_height);
4520 unbind_to (count, Qnil);
4521
4522 if (NUMBERP (value))
4523 new_height = XFLOATINT (value);
4524 }
4525
4526 if (new_height > 0)
4527 it->face_id = face_with_height (it->f, it->face_id, new_height);
4528 }
4529 }
4530
4531 return 0;
4532 }
4533
4534 /* Handle `(space-width WIDTH)'. */
4535 if (CONSP (spec)
4536 && EQ (XCAR (spec), Qspace_width)
4537 && CONSP (XCDR (spec)))
4538 {
4539 if (it)
4540 {
4541 if (!FRAME_WINDOW_P (it->f))
4542 return 0;
4543
4544 value = XCAR (XCDR (spec));
4545 if (NUMBERP (value) && XFLOATINT (value) > 0)
4546 it->space_width = value;
4547 }
4548
4549 return 0;
4550 }
4551
4552 /* Handle `(slice X Y WIDTH HEIGHT)'. */
4553 if (CONSP (spec)
4554 && EQ (XCAR (spec), Qslice))
4555 {
4556 Lisp_Object tem;
4557
4558 if (it)
4559 {
4560 if (!FRAME_WINDOW_P (it->f))
4561 return 0;
4562
4563 if (tem = XCDR (spec), CONSP (tem))
4564 {
4565 it->slice.x = XCAR (tem);
4566 if (tem = XCDR (tem), CONSP (tem))
4567 {
4568 it->slice.y = XCAR (tem);
4569 if (tem = XCDR (tem), CONSP (tem))
4570 {
4571 it->slice.width = XCAR (tem);
4572 if (tem = XCDR (tem), CONSP (tem))
4573 it->slice.height = XCAR (tem);
4574 }
4575 }
4576 }
4577 }
4578
4579 return 0;
4580 }
4581
4582 /* Handle `(raise FACTOR)'. */
4583 if (CONSP (spec)
4584 && EQ (XCAR (spec), Qraise)
4585 && CONSP (XCDR (spec)))
4586 {
4587 if (it)
4588 {
4589 if (!FRAME_WINDOW_P (it->f))
4590 return 0;
4591
4592 #ifdef HAVE_WINDOW_SYSTEM
4593 value = XCAR (XCDR (spec));
4594 if (NUMBERP (value))
4595 {
4596 struct face *face = FACE_FROM_ID (it->f, it->face_id);
4597 it->voffset = - (XFLOATINT (value)
4598 * (FONT_HEIGHT (face->font)));
4599 }
4600 #endif /* HAVE_WINDOW_SYSTEM */
4601 }
4602
4603 return 0;
4604 }
4605
4606 /* Don't handle the other kinds of display specifications
4607 inside a string that we got from a `display' property. */
4608 if (it && it->string_from_display_prop_p)
4609 return 0;
4610
4611 /* Characters having this form of property are not displayed, so
4612 we have to find the end of the property. */
4613 if (it)
4614 {
4615 start_pos = *position;
4616 *position = display_prop_end (it, object, start_pos);
4617 }
4618 value = Qnil;
4619
4620 /* Stop the scan at that end position--we assume that all
4621 text properties change there. */
4622 if (it)
4623 it->stop_charpos = position->charpos;
4624
4625 /* Handle `(left-fringe BITMAP [FACE])'
4626 and `(right-fringe BITMAP [FACE])'. */
4627 if (CONSP (spec)
4628 && (EQ (XCAR (spec), Qleft_fringe)
4629 || EQ (XCAR (spec), Qright_fringe))
4630 && CONSP (XCDR (spec)))
4631 {
4632 int fringe_bitmap;
4633
4634 if (it)
4635 {
4636 if (!FRAME_WINDOW_P (it->f))
4637 /* If we return here, POSITION has been advanced
4638 across the text with this property. */
4639 return 0;
4640 }
4641 else if (!frame_window_p)
4642 return 0;
4643
4644 #ifdef HAVE_WINDOW_SYSTEM
4645 value = XCAR (XCDR (spec));
4646 if (!SYMBOLP (value)
4647 || !(fringe_bitmap = lookup_fringe_bitmap (value)))
4648 /* If we return here, POSITION has been advanced
4649 across the text with this property. */
4650 return 0;
4651
4652 if (it)
4653 {
4654 int face_id = lookup_basic_face (it->f, DEFAULT_FACE_ID);;
4655
4656 if (CONSP (XCDR (XCDR (spec))))
4657 {
4658 Lisp_Object face_name = XCAR (XCDR (XCDR (spec)));
4659 int face_id2 = lookup_derived_face (it->f, face_name,
4660 FRINGE_FACE_ID, 0);
4661 if (face_id2 >= 0)
4662 face_id = face_id2;
4663 }
4664
4665 /* Save current settings of IT so that we can restore them
4666 when we are finished with the glyph property value. */
4667 push_it (it, position);
4668
4669 it->area = TEXT_AREA;
4670 it->what = IT_IMAGE;
4671 it->image_id = -1; /* no image */
4672 it->position = start_pos;
4673 it->object = NILP (object) ? it->w->buffer : object;
4674 it->method = GET_FROM_IMAGE;
4675 it->from_overlay = Qnil;
4676 it->face_id = face_id;
4677 it->from_disp_prop_p = 1;
4678
4679 /* Say that we haven't consumed the characters with
4680 `display' property yet. The call to pop_it in
4681 set_iterator_to_next will clean this up. */
4682 *position = start_pos;
4683
4684 if (EQ (XCAR (spec), Qleft_fringe))
4685 {
4686 it->left_user_fringe_bitmap = fringe_bitmap;
4687 it->left_user_fringe_face_id = face_id;
4688 }
4689 else
4690 {
4691 it->right_user_fringe_bitmap = fringe_bitmap;
4692 it->right_user_fringe_face_id = face_id;
4693 }
4694 }
4695 #endif /* HAVE_WINDOW_SYSTEM */
4696 return 1;
4697 }
4698
4699 /* Prepare to handle `((margin left-margin) ...)',
4700 `((margin right-margin) ...)' and `((margin nil) ...)'
4701 prefixes for display specifications. */
4702 location = Qunbound;
4703 if (CONSP (spec) && CONSP (XCAR (spec)))
4704 {
4705 Lisp_Object tem;
4706
4707 value = XCDR (spec);
4708 if (CONSP (value))
4709 value = XCAR (value);
4710
4711 tem = XCAR (spec);
4712 if (EQ (XCAR (tem), Qmargin)
4713 && (tem = XCDR (tem),
4714 tem = CONSP (tem) ? XCAR (tem) : Qnil,
4715 (NILP (tem)
4716 || EQ (tem, Qleft_margin)
4717 || EQ (tem, Qright_margin))))
4718 location = tem;
4719 }
4720
4721 if (EQ (location, Qunbound))
4722 {
4723 location = Qnil;
4724 value = spec;
4725 }
4726
4727 /* After this point, VALUE is the property after any
4728 margin prefix has been stripped. It must be a string,
4729 an image specification, or `(space ...)'.
4730
4731 LOCATION specifies where to display: `left-margin',
4732 `right-margin' or nil. */
4733
4734 valid_p = (STRINGP (value)
4735 #ifdef HAVE_WINDOW_SYSTEM
4736 || ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
4737 && valid_image_p (value))
4738 #endif /* not HAVE_WINDOW_SYSTEM */
4739 || (CONSP (value) && EQ (XCAR (value), Qspace)));
4740
4741 if (valid_p && !display_replaced_p)
4742 {
4743 int retval = 1;
4744
4745 if (!it)
4746 {
4747 /* Callers need to know whether the display spec is any kind
4748 of `(space ...)' spec that is about to affect text-area
4749 display. */
4750 if (CONSP (value) && EQ (XCAR (value), Qspace) && NILP (location))
4751 retval = 2;
4752 return retval;
4753 }
4754
4755 /* Save current settings of IT so that we can restore them
4756 when we are finished with the glyph property value. */
4757 push_it (it, position);
4758 it->from_overlay = overlay;
4759 it->from_disp_prop_p = 1;
4760
4761 if (NILP (location))
4762 it->area = TEXT_AREA;
4763 else if (EQ (location, Qleft_margin))
4764 it->area = LEFT_MARGIN_AREA;
4765 else
4766 it->area = RIGHT_MARGIN_AREA;
4767
4768 if (STRINGP (value))
4769 {
4770 it->string = value;
4771 it->multibyte_p = STRING_MULTIBYTE (it->string);
4772 it->current.overlay_string_index = -1;
4773 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
4774 it->end_charpos = it->string_nchars = SCHARS (it->string);
4775 it->method = GET_FROM_STRING;
4776 it->stop_charpos = 0;
4777 it->prev_stop = 0;
4778 it->base_level_stop = 0;
4779 it->string_from_display_prop_p = 1;
4780 /* Say that we haven't consumed the characters with
4781 `display' property yet. The call to pop_it in
4782 set_iterator_to_next will clean this up. */
4783 if (BUFFERP (object))
4784 *position = start_pos;
4785
4786 /* Force paragraph direction to be that of the parent
4787 object. If the parent object's paragraph direction is
4788 not yet determined, default to L2R. */
4789 if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
4790 it->paragraph_embedding = it->bidi_it.paragraph_dir;
4791 else
4792 it->paragraph_embedding = L2R;
4793
4794 /* Set up the bidi iterator for this display string. */
4795 if (it->bidi_p)
4796 {
4797 it->bidi_it.string.lstring = it->string;
4798 it->bidi_it.string.s = NULL;
4799 it->bidi_it.string.schars = it->end_charpos;
4800 it->bidi_it.string.bufpos = bufpos;
4801 it->bidi_it.string.from_disp_str = 1;
4802 it->bidi_it.string.unibyte = !it->multibyte_p;
4803 bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
4804 }
4805 }
4806 else if (CONSP (value) && EQ (XCAR (value), Qspace))
4807 {
4808 it->method = GET_FROM_STRETCH;
4809 it->object = value;
4810 *position = it->position = start_pos;
4811 retval = 1 + (it->area == TEXT_AREA);
4812 }
4813 #ifdef HAVE_WINDOW_SYSTEM
4814 else
4815 {
4816 it->what = IT_IMAGE;
4817 it->image_id = lookup_image (it->f, value);
4818 it->position = start_pos;
4819 it->object = NILP (object) ? it->w->buffer : object;
4820 it->method = GET_FROM_IMAGE;
4821
4822 /* Say that we haven't consumed the characters with
4823 `display' property yet. The call to pop_it in
4824 set_iterator_to_next will clean this up. */
4825 *position = start_pos;
4826 }
4827 #endif /* HAVE_WINDOW_SYSTEM */
4828
4829 return retval;
4830 }
4831
4832 /* Invalid property or property not supported. Restore
4833 POSITION to what it was before. */
4834 *position = start_pos;
4835 return 0;
4836 }
4837
4838 /* Check if PROP is a display property value whose text should be
4839 treated as intangible. OVERLAY is the overlay from which PROP
4840 came, or nil if it came from a text property. CHARPOS and BYTEPOS
4841 specify the buffer position covered by PROP. */
4842
4843 int
4844 display_prop_intangible_p (Lisp_Object prop, Lisp_Object overlay,
4845 ptrdiff_t charpos, ptrdiff_t bytepos)
4846 {
4847 int frame_window_p = FRAME_WINDOW_P (XFRAME (selected_frame));
4848 struct text_pos position;
4849
4850 SET_TEXT_POS (position, charpos, bytepos);
4851 return handle_display_spec (NULL, prop, Qnil, overlay,
4852 &position, charpos, frame_window_p);
4853 }
4854
4855
4856 /* Return 1 if PROP is a display sub-property value containing STRING.
4857
4858 Implementation note: this and the following function are really
4859 special cases of handle_display_spec and
4860 handle_single_display_spec, and should ideally use the same code.
4861 Until they do, these two pairs must be consistent and must be
4862 modified in sync. */
4863
4864 static int
4865 single_display_spec_string_p (Lisp_Object prop, Lisp_Object string)
4866 {
4867 if (EQ (string, prop))
4868 return 1;
4869
4870 /* Skip over `when FORM'. */
4871 if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
4872 {
4873 prop = XCDR (prop);
4874 if (!CONSP (prop))
4875 return 0;
4876 /* Actually, the condition following `when' should be eval'ed,
4877 like handle_single_display_spec does, and we should return
4878 zero if it evaluates to nil. However, this function is
4879 called only when the buffer was already displayed and some
4880 glyph in the glyph matrix was found to come from a display
4881 string. Therefore, the condition was already evaluated, and
4882 the result was non-nil, otherwise the display string wouldn't
4883 have been displayed and we would have never been called for
4884 this property. Thus, we can skip the evaluation and assume
4885 its result is non-nil. */
4886 prop = XCDR (prop);
4887 }
4888
4889 if (CONSP (prop))
4890 /* Skip over `margin LOCATION'. */
4891 if (EQ (XCAR (prop), Qmargin))
4892 {
4893 prop = XCDR (prop);
4894 if (!CONSP (prop))
4895 return 0;
4896
4897 prop = XCDR (prop);
4898 if (!CONSP (prop))
4899 return 0;
4900 }
4901
4902 return EQ (prop, string) || (CONSP (prop) && EQ (XCAR (prop), string));
4903 }
4904
4905
4906 /* Return 1 if STRING appears in the `display' property PROP. */
4907
4908 static int
4909 display_prop_string_p (Lisp_Object prop, Lisp_Object string)
4910 {
4911 if (CONSP (prop)
4912 && !EQ (XCAR (prop), Qwhen)
4913 && !(CONSP (XCAR (prop)) && EQ (Qmargin, XCAR (XCAR (prop)))))
4914 {
4915 /* A list of sub-properties. */
4916 while (CONSP (prop))
4917 {
4918 if (single_display_spec_string_p (XCAR (prop), string))
4919 return 1;
4920 prop = XCDR (prop);
4921 }
4922 }
4923 else if (VECTORP (prop))
4924 {
4925 /* A vector of sub-properties. */
4926 ptrdiff_t i;
4927 for (i = 0; i < ASIZE (prop); ++i)
4928 if (single_display_spec_string_p (AREF (prop, i), string))
4929 return 1;
4930 }
4931 else
4932 return single_display_spec_string_p (prop, string);
4933
4934 return 0;
4935 }
4936
4937 /* Look for STRING in overlays and text properties in the current
4938 buffer, between character positions FROM and TO (excluding TO).
4939 BACK_P non-zero means look back (in this case, TO is supposed to be
4940 less than FROM).
4941 Value is the first character position where STRING was found, or
4942 zero if it wasn't found before hitting TO.
4943
4944 This function may only use code that doesn't eval because it is
4945 called asynchronously from note_mouse_highlight. */
4946
4947 static ptrdiff_t
4948 string_buffer_position_lim (Lisp_Object string,
4949 ptrdiff_t from, ptrdiff_t to, int back_p)
4950 {
4951 Lisp_Object limit, prop, pos;
4952 int found = 0;
4953
4954 pos = make_number (from);
4955
4956 if (!back_p) /* looking forward */
4957 {
4958 limit = make_number (min (to, ZV));
4959 while (!found && !EQ (pos, limit))
4960 {
4961 prop = Fget_char_property (pos, Qdisplay, Qnil);
4962 if (!NILP (prop) && display_prop_string_p (prop, string))
4963 found = 1;
4964 else
4965 pos = Fnext_single_char_property_change (pos, Qdisplay, Qnil,
4966 limit);
4967 }
4968 }
4969 else /* looking back */
4970 {
4971 limit = make_number (max (to, BEGV));
4972 while (!found && !EQ (pos, limit))
4973 {
4974 prop = Fget_char_property (pos, Qdisplay, Qnil);
4975 if (!NILP (prop) && display_prop_string_p (prop, string))
4976 found = 1;
4977 else
4978 pos = Fprevious_single_char_property_change (pos, Qdisplay, Qnil,
4979 limit);
4980 }
4981 }
4982
4983 return found ? XINT (pos) : 0;
4984 }
4985
4986 /* Determine which buffer position in current buffer STRING comes from.
4987 AROUND_CHARPOS is an approximate position where it could come from.
4988 Value is the buffer position or 0 if it couldn't be determined.
4989
4990 This function is necessary because we don't record buffer positions
4991 in glyphs generated from strings (to keep struct glyph small).
4992 This function may only use code that doesn't eval because it is
4993 called asynchronously from note_mouse_highlight. */
4994
4995 static ptrdiff_t
4996 string_buffer_position (Lisp_Object string, ptrdiff_t around_charpos)
4997 {
4998 const int MAX_DISTANCE = 1000;
4999 ptrdiff_t found = string_buffer_position_lim (string, around_charpos,
5000 around_charpos + MAX_DISTANCE,
5001 0);
5002
5003 if (!found)
5004 found = string_buffer_position_lim (string, around_charpos,
5005 around_charpos - MAX_DISTANCE, 1);
5006 return found;
5007 }
5008
5009
5010 \f
5011 /***********************************************************************
5012 `composition' property
5013 ***********************************************************************/
5014
5015 /* Set up iterator IT from `composition' property at its current
5016 position. Called from handle_stop. */
5017
5018 static enum prop_handled
5019 handle_composition_prop (struct it *it)
5020 {
5021 Lisp_Object prop, string;
5022 ptrdiff_t pos, pos_byte, start, end;
5023
5024 if (STRINGP (it->string))
5025 {
5026 unsigned char *s;
5027
5028 pos = IT_STRING_CHARPOS (*it);
5029 pos_byte = IT_STRING_BYTEPOS (*it);
5030 string = it->string;
5031 s = SDATA (string) + pos_byte;
5032 it->c = STRING_CHAR (s);
5033 }
5034 else
5035 {
5036 pos = IT_CHARPOS (*it);
5037 pos_byte = IT_BYTEPOS (*it);
5038 string = Qnil;
5039 it->c = FETCH_CHAR (pos_byte);
5040 }
5041
5042 /* If there's a valid composition and point is not inside of the
5043 composition (in the case that the composition is from the current
5044 buffer), draw a glyph composed from the composition components. */
5045 if (find_composition (pos, -1, &start, &end, &prop, string)
5046 && COMPOSITION_VALID_P (start, end, prop)
5047 && (STRINGP (it->string) || (PT <= start || PT >= end)))
5048 {
5049 if (start < pos)
5050 /* As we can't handle this situation (perhaps font-lock added
5051 a new composition), we just return here hoping that next
5052 redisplay will detect this composition much earlier. */
5053 return HANDLED_NORMALLY;
5054 if (start != pos)
5055 {
5056 if (STRINGP (it->string))
5057 pos_byte = string_char_to_byte (it->string, start);
5058 else
5059 pos_byte = CHAR_TO_BYTE (start);
5060 }
5061 it->cmp_it.id = get_composition_id (start, pos_byte, end - start,
5062 prop, string);
5063
5064 if (it->cmp_it.id >= 0)
5065 {
5066 it->cmp_it.ch = -1;
5067 it->cmp_it.nchars = COMPOSITION_LENGTH (prop);
5068 it->cmp_it.nglyphs = -1;
5069 }
5070 }
5071
5072 return HANDLED_NORMALLY;
5073 }
5074
5075
5076 \f
5077 /***********************************************************************
5078 Overlay strings
5079 ***********************************************************************/
5080
5081 /* The following structure is used to record overlay strings for
5082 later sorting in load_overlay_strings. */
5083
5084 struct overlay_entry
5085 {
5086 Lisp_Object overlay;
5087 Lisp_Object string;
5088 EMACS_INT priority;
5089 int after_string_p;
5090 };
5091
5092
5093 /* Set up iterator IT from overlay strings at its current position.
5094 Called from handle_stop. */
5095
5096 static enum prop_handled
5097 handle_overlay_change (struct it *it)
5098 {
5099 if (!STRINGP (it->string) && get_overlay_strings (it, 0))
5100 return HANDLED_RECOMPUTE_PROPS;
5101 else
5102 return HANDLED_NORMALLY;
5103 }
5104
5105
5106 /* Set up the next overlay string for delivery by IT, if there is an
5107 overlay string to deliver. Called by set_iterator_to_next when the
5108 end of the current overlay string is reached. If there are more
5109 overlay strings to display, IT->string and
5110 IT->current.overlay_string_index are set appropriately here.
5111 Otherwise IT->string is set to nil. */
5112
5113 static void
5114 next_overlay_string (struct it *it)
5115 {
5116 ++it->current.overlay_string_index;
5117 if (it->current.overlay_string_index == it->n_overlay_strings)
5118 {
5119 /* No more overlay strings. Restore IT's settings to what
5120 they were before overlay strings were processed, and
5121 continue to deliver from current_buffer. */
5122
5123 it->ellipsis_p = (it->stack[it->sp - 1].display_ellipsis_p != 0);
5124 pop_it (it);
5125 xassert (it->sp > 0
5126 || (NILP (it->string)
5127 && it->method == GET_FROM_BUFFER
5128 && it->stop_charpos >= BEGV
5129 && it->stop_charpos <= it->end_charpos));
5130 it->current.overlay_string_index = -1;
5131 it->n_overlay_strings = 0;
5132 it->overlay_strings_charpos = -1;
5133
5134 /* If we're at the end of the buffer, record that we have
5135 processed the overlay strings there already, so that
5136 next_element_from_buffer doesn't try it again. */
5137 if (NILP (it->string) && IT_CHARPOS (*it) >= it->end_charpos)
5138 it->overlay_strings_at_end_processed_p = 1;
5139 }
5140 else
5141 {
5142 /* There are more overlay strings to process. If
5143 IT->current.overlay_string_index has advanced to a position
5144 where we must load IT->overlay_strings with more strings, do
5145 it. We must load at the IT->overlay_strings_charpos where
5146 IT->n_overlay_strings was originally computed; when invisible
5147 text is present, this might not be IT_CHARPOS (Bug#7016). */
5148 int i = it->current.overlay_string_index % OVERLAY_STRING_CHUNK_SIZE;
5149
5150 if (it->current.overlay_string_index && i == 0)
5151 load_overlay_strings (it, it->overlay_strings_charpos);
5152
5153 /* Initialize IT to deliver display elements from the overlay
5154 string. */
5155 it->string = it->overlay_strings[i];
5156 it->multibyte_p = STRING_MULTIBYTE (it->string);
5157 SET_TEXT_POS (it->current.string_pos, 0, 0);
5158 it->method = GET_FROM_STRING;
5159 it->stop_charpos = 0;
5160 if (it->cmp_it.stop_pos >= 0)
5161 it->cmp_it.stop_pos = 0;
5162 it->prev_stop = 0;
5163 it->base_level_stop = 0;
5164
5165 /* Set up the bidi iterator for this overlay string. */
5166 if (it->bidi_p)
5167 {
5168 it->bidi_it.string.lstring = it->string;
5169 it->bidi_it.string.s = NULL;
5170 it->bidi_it.string.schars = SCHARS (it->string);
5171 it->bidi_it.string.bufpos = it->overlay_strings_charpos;
5172 it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
5173 it->bidi_it.string.unibyte = !it->multibyte_p;
5174 bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
5175 }
5176 }
5177
5178 CHECK_IT (it);
5179 }
5180
5181
5182 /* Compare two overlay_entry structures E1 and E2. Used as a
5183 comparison function for qsort in load_overlay_strings. Overlay
5184 strings for the same position are sorted so that
5185
5186 1. All after-strings come in front of before-strings, except
5187 when they come from the same overlay.
5188
5189 2. Within after-strings, strings are sorted so that overlay strings
5190 from overlays with higher priorities come first.
5191
5192 2. Within before-strings, strings are sorted so that overlay
5193 strings from overlays with higher priorities come last.
5194
5195 Value is analogous to strcmp. */
5196
5197
5198 static int
5199 compare_overlay_entries (const void *e1, const void *e2)
5200 {
5201 struct overlay_entry *entry1 = (struct overlay_entry *) e1;
5202 struct overlay_entry *entry2 = (struct overlay_entry *) e2;
5203 int result;
5204
5205 if (entry1->after_string_p != entry2->after_string_p)
5206 {
5207 /* Let after-strings appear in front of before-strings if
5208 they come from different overlays. */
5209 if (EQ (entry1->overlay, entry2->overlay))
5210 result = entry1->after_string_p ? 1 : -1;
5211 else
5212 result = entry1->after_string_p ? -1 : 1;
5213 }
5214 else if (entry1->priority != entry2->priority)
5215 {
5216 if (entry1->after_string_p)
5217 /* After-strings sorted in order of decreasing priority. */
5218 result = entry2->priority < entry1->priority ? -1 : 1;
5219 else
5220 /* Before-strings sorted in order of increasing priority. */
5221 result = entry1->priority < entry2->priority ? -1 : 1;
5222 }
5223 else
5224 result = 0;
5225
5226 return result;
5227 }
5228
5229
5230 /* Load the vector IT->overlay_strings with overlay strings from IT's
5231 current buffer position, or from CHARPOS if that is > 0. Set
5232 IT->n_overlays to the total number of overlay strings found.
5233
5234 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
5235 a time. On entry into load_overlay_strings,
5236 IT->current.overlay_string_index gives the number of overlay
5237 strings that have already been loaded by previous calls to this
5238 function.
5239
5240 IT->add_overlay_start contains an additional overlay start
5241 position to consider for taking overlay strings from, if non-zero.
5242 This position comes into play when the overlay has an `invisible'
5243 property, and both before and after-strings. When we've skipped to
5244 the end of the overlay, because of its `invisible' property, we
5245 nevertheless want its before-string to appear.
5246 IT->add_overlay_start will contain the overlay start position
5247 in this case.
5248
5249 Overlay strings are sorted so that after-string strings come in
5250 front of before-string strings. Within before and after-strings,
5251 strings are sorted by overlay priority. See also function
5252 compare_overlay_entries. */
5253
5254 static void
5255 load_overlay_strings (struct it *it, ptrdiff_t charpos)
5256 {
5257 Lisp_Object overlay, window, str, invisible;
5258 struct Lisp_Overlay *ov;
5259 ptrdiff_t start, end;
5260 ptrdiff_t size = 20;
5261 ptrdiff_t n = 0, i, j;
5262 int invis_p;
5263 struct overlay_entry *entries
5264 = (struct overlay_entry *) alloca (size * sizeof *entries);
5265 USE_SAFE_ALLOCA;
5266
5267 if (charpos <= 0)
5268 charpos = IT_CHARPOS (*it);
5269
5270 /* Append the overlay string STRING of overlay OVERLAY to vector
5271 `entries' which has size `size' and currently contains `n'
5272 elements. AFTER_P non-zero means STRING is an after-string of
5273 OVERLAY. */
5274 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
5275 do \
5276 { \
5277 Lisp_Object priority; \
5278 \
5279 if (n == size) \
5280 { \
5281 struct overlay_entry *old = entries; \
5282 SAFE_NALLOCA (entries, 2, size); \
5283 memcpy (entries, old, size * sizeof *entries); \
5284 size *= 2; \
5285 } \
5286 \
5287 entries[n].string = (STRING); \
5288 entries[n].overlay = (OVERLAY); \
5289 priority = Foverlay_get ((OVERLAY), Qpriority); \
5290 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
5291 entries[n].after_string_p = (AFTER_P); \
5292 ++n; \
5293 } \
5294 while (0)
5295
5296 /* Process overlay before the overlay center. */
5297 for (ov = current_buffer->overlays_before; ov; ov = ov->next)
5298 {
5299 XSETMISC (overlay, ov);
5300 xassert (OVERLAYP (overlay));
5301 start = OVERLAY_POSITION (OVERLAY_START (overlay));
5302 end = OVERLAY_POSITION (OVERLAY_END (overlay));
5303
5304 if (end < charpos)
5305 break;
5306
5307 /* Skip this overlay if it doesn't start or end at IT's current
5308 position. */
5309 if (end != charpos && start != charpos)
5310 continue;
5311
5312 /* Skip this overlay if it doesn't apply to IT->w. */
5313 window = Foverlay_get (overlay, Qwindow);
5314 if (WINDOWP (window) && XWINDOW (window) != it->w)
5315 continue;
5316
5317 /* If the text ``under'' the overlay is invisible, both before-
5318 and after-strings from this overlay are visible; start and
5319 end position are indistinguishable. */
5320 invisible = Foverlay_get (overlay, Qinvisible);
5321 invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible);
5322
5323 /* If overlay has a non-empty before-string, record it. */
5324 if ((start == charpos || (end == charpos && invis_p))
5325 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
5326 && SCHARS (str))
5327 RECORD_OVERLAY_STRING (overlay, str, 0);
5328
5329 /* If overlay has a non-empty after-string, record it. */
5330 if ((end == charpos || (start == charpos && invis_p))
5331 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
5332 && SCHARS (str))
5333 RECORD_OVERLAY_STRING (overlay, str, 1);
5334 }
5335
5336 /* Process overlays after the overlay center. */
5337 for (ov = current_buffer->overlays_after; ov; ov = ov->next)
5338 {
5339 XSETMISC (overlay, ov);
5340 xassert (OVERLAYP (overlay));
5341 start = OVERLAY_POSITION (OVERLAY_START (overlay));
5342 end = OVERLAY_POSITION (OVERLAY_END (overlay));
5343
5344 if (start > charpos)
5345 break;
5346
5347 /* Skip this overlay if it doesn't start or end at IT's current
5348 position. */
5349 if (end != charpos && start != charpos)
5350 continue;
5351
5352 /* Skip this overlay if it doesn't apply to IT->w. */
5353 window = Foverlay_get (overlay, Qwindow);
5354 if (WINDOWP (window) && XWINDOW (window) != it->w)
5355 continue;
5356
5357 /* If the text ``under'' the overlay is invisible, it has a zero
5358 dimension, and both before- and after-strings apply. */
5359 invisible = Foverlay_get (overlay, Qinvisible);
5360 invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible);
5361
5362 /* If overlay has a non-empty before-string, record it. */
5363 if ((start == charpos || (end == charpos && invis_p))
5364 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
5365 && SCHARS (str))
5366 RECORD_OVERLAY_STRING (overlay, str, 0);
5367
5368 /* If overlay has a non-empty after-string, record it. */
5369 if ((end == charpos || (start == charpos && invis_p))
5370 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
5371 && SCHARS (str))
5372 RECORD_OVERLAY_STRING (overlay, str, 1);
5373 }
5374
5375 #undef RECORD_OVERLAY_STRING
5376
5377 /* Sort entries. */
5378 if (n > 1)
5379 qsort (entries, n, sizeof *entries, compare_overlay_entries);
5380
5381 /* Record number of overlay strings, and where we computed it. */
5382 it->n_overlay_strings = n;
5383 it->overlay_strings_charpos = charpos;
5384
5385 /* IT->current.overlay_string_index is the number of overlay strings
5386 that have already been consumed by IT. Copy some of the
5387 remaining overlay strings to IT->overlay_strings. */
5388 i = 0;
5389 j = it->current.overlay_string_index;
5390 while (i < OVERLAY_STRING_CHUNK_SIZE && j < n)
5391 {
5392 it->overlay_strings[i] = entries[j].string;
5393 it->string_overlays[i++] = entries[j++].overlay;
5394 }
5395
5396 CHECK_IT (it);
5397 SAFE_FREE ();
5398 }
5399
5400
5401 /* Get the first chunk of overlay strings at IT's current buffer
5402 position, or at CHARPOS if that is > 0. Value is non-zero if at
5403 least one overlay string was found. */
5404
5405 static int
5406 get_overlay_strings_1 (struct it *it, ptrdiff_t charpos, int compute_stop_p)
5407 {
5408 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
5409 process. This fills IT->overlay_strings with strings, and sets
5410 IT->n_overlay_strings to the total number of strings to process.
5411 IT->pos.overlay_string_index has to be set temporarily to zero
5412 because load_overlay_strings needs this; it must be set to -1
5413 when no overlay strings are found because a zero value would
5414 indicate a position in the first overlay string. */
5415 it->current.overlay_string_index = 0;
5416 load_overlay_strings (it, charpos);
5417
5418 /* If we found overlay strings, set up IT to deliver display
5419 elements from the first one. Otherwise set up IT to deliver
5420 from current_buffer. */
5421 if (it->n_overlay_strings)
5422 {
5423 /* Make sure we know settings in current_buffer, so that we can
5424 restore meaningful values when we're done with the overlay
5425 strings. */
5426 if (compute_stop_p)
5427 compute_stop_pos (it);
5428 xassert (it->face_id >= 0);
5429
5430 /* Save IT's settings. They are restored after all overlay
5431 strings have been processed. */
5432 xassert (!compute_stop_p || it->sp == 0);
5433
5434 /* When called from handle_stop, there might be an empty display
5435 string loaded. In that case, don't bother saving it. */
5436 if (!STRINGP (it->string) || SCHARS (it->string))
5437 push_it (it, NULL);
5438
5439 /* Set up IT to deliver display elements from the first overlay
5440 string. */
5441 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
5442 it->string = it->overlay_strings[0];
5443 it->from_overlay = Qnil;
5444 it->stop_charpos = 0;
5445 xassert (STRINGP (it->string));
5446 it->end_charpos = SCHARS (it->string);
5447 it->prev_stop = 0;
5448 it->base_level_stop = 0;
5449 it->multibyte_p = STRING_MULTIBYTE (it->string);
5450 it->method = GET_FROM_STRING;
5451 it->from_disp_prop_p = 0;
5452
5453 /* Force paragraph direction to be that of the parent
5454 buffer. */
5455 if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
5456 it->paragraph_embedding = it->bidi_it.paragraph_dir;
5457 else
5458 it->paragraph_embedding = L2R;
5459
5460 /* Set up the bidi iterator for this overlay string. */
5461 if (it->bidi_p)
5462 {
5463 ptrdiff_t pos = (charpos > 0 ? charpos : IT_CHARPOS (*it));
5464
5465 it->bidi_it.string.lstring = it->string;
5466 it->bidi_it.string.s = NULL;
5467 it->bidi_it.string.schars = SCHARS (it->string);
5468 it->bidi_it.string.bufpos = pos;
5469 it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
5470 it->bidi_it.string.unibyte = !it->multibyte_p;
5471 bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
5472 }
5473 return 1;
5474 }
5475
5476 it->current.overlay_string_index = -1;
5477 return 0;
5478 }
5479
5480 static int
5481 get_overlay_strings (struct it *it, ptrdiff_t charpos)
5482 {
5483 it->string = Qnil;
5484 it->method = GET_FROM_BUFFER;
5485
5486 (void) get_overlay_strings_1 (it, charpos, 1);
5487
5488 CHECK_IT (it);
5489
5490 /* Value is non-zero if we found at least one overlay string. */
5491 return STRINGP (it->string);
5492 }
5493
5494
5495 \f
5496 /***********************************************************************
5497 Saving and restoring state
5498 ***********************************************************************/
5499
5500 /* Save current settings of IT on IT->stack. Called, for example,
5501 before setting up IT for an overlay string, to be able to restore
5502 IT's settings to what they were after the overlay string has been
5503 processed. If POSITION is non-NULL, it is the position to save on
5504 the stack instead of IT->position. */
5505
5506 static void
5507 push_it (struct it *it, struct text_pos *position)
5508 {
5509 struct iterator_stack_entry *p;
5510
5511 xassert (it->sp < IT_STACK_SIZE);
5512 p = it->stack + it->sp;
5513
5514 p->stop_charpos = it->stop_charpos;
5515 p->prev_stop = it->prev_stop;
5516 p->base_level_stop = it->base_level_stop;
5517 p->cmp_it = it->cmp_it;
5518 xassert (it->face_id >= 0);
5519 p->face_id = it->face_id;
5520 p->string = it->string;
5521 p->method = it->method;
5522 p->from_overlay = it->from_overlay;
5523 switch (p->method)
5524 {
5525 case GET_FROM_IMAGE:
5526 p->u.image.object = it->object;
5527 p->u.image.image_id = it->image_id;
5528 p->u.image.slice = it->slice;
5529 break;
5530 case GET_FROM_STRETCH:
5531 p->u.stretch.object = it->object;
5532 break;
5533 }
5534 p->position = position ? *position : it->position;
5535 p->current = it->current;
5536 p->end_charpos = it->end_charpos;
5537 p->string_nchars = it->string_nchars;
5538 p->area = it->area;
5539 p->multibyte_p = it->multibyte_p;
5540 p->avoid_cursor_p = it->avoid_cursor_p;
5541 p->space_width = it->space_width;
5542 p->font_height = it->font_height;
5543 p->voffset = it->voffset;
5544 p->string_from_display_prop_p = it->string_from_display_prop_p;
5545 p->display_ellipsis_p = 0;
5546 p->line_wrap = it->line_wrap;
5547 p->bidi_p = it->bidi_p;
5548 p->paragraph_embedding = it->paragraph_embedding;
5549 p->from_disp_prop_p = it->from_disp_prop_p;
5550 ++it->sp;
5551
5552 /* Save the state of the bidi iterator as well. */
5553 if (it->bidi_p)
5554 bidi_push_it (&it->bidi_it);
5555 }
5556
5557 static void
5558 iterate_out_of_display_property (struct it *it)
5559 {
5560 int buffer_p = BUFFERP (it->object);
5561 ptrdiff_t eob = (buffer_p ? ZV : it->end_charpos);
5562 ptrdiff_t bob = (buffer_p ? BEGV : 0);
5563
5564 xassert (eob >= CHARPOS (it->position) && CHARPOS (it->position) >= bob);
5565
5566 /* Maybe initialize paragraph direction. If we are at the beginning
5567 of a new paragraph, next_element_from_buffer may not have a
5568 chance to do that. */
5569 if (it->bidi_it.first_elt && it->bidi_it.charpos < eob)
5570 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
5571 /* prev_stop can be zero, so check against BEGV as well. */
5572 while (it->bidi_it.charpos >= bob
5573 && it->prev_stop <= it->bidi_it.charpos
5574 && it->bidi_it.charpos < CHARPOS (it->position)
5575 && it->bidi_it.charpos < eob)
5576 bidi_move_to_visually_next (&it->bidi_it);
5577 /* Record the stop_pos we just crossed, for when we cross it
5578 back, maybe. */
5579 if (it->bidi_it.charpos > CHARPOS (it->position))
5580 it->prev_stop = CHARPOS (it->position);
5581 /* If we ended up not where pop_it put us, resync IT's
5582 positional members with the bidi iterator. */
5583 if (it->bidi_it.charpos != CHARPOS (it->position))
5584 SET_TEXT_POS (it->position, it->bidi_it.charpos, it->bidi_it.bytepos);
5585 if (buffer_p)
5586 it->current.pos = it->position;
5587 else
5588 it->current.string_pos = it->position;
5589 }
5590
5591 /* Restore IT's settings from IT->stack. Called, for example, when no
5592 more overlay strings must be processed, and we return to delivering
5593 display elements from a buffer, or when the end of a string from a
5594 `display' property is reached and we return to delivering display
5595 elements from an overlay string, or from a buffer. */
5596
5597 static void
5598 pop_it (struct it *it)
5599 {
5600 struct iterator_stack_entry *p;
5601 int from_display_prop = it->from_disp_prop_p;
5602
5603 xassert (it->sp > 0);
5604 --it->sp;
5605 p = it->stack + it->sp;
5606 it->stop_charpos = p->stop_charpos;
5607 it->prev_stop = p->prev_stop;
5608 it->base_level_stop = p->base_level_stop;
5609 it->cmp_it = p->cmp_it;
5610 it->face_id = p->face_id;
5611 it->current = p->current;
5612 it->position = p->position;
5613 it->string = p->string;
5614 it->from_overlay = p->from_overlay;
5615 if (NILP (it->string))
5616 SET_TEXT_POS (it->current.string_pos, -1, -1);
5617 it->method = p->method;
5618 switch (it->method)
5619 {
5620 case GET_FROM_IMAGE:
5621 it->image_id = p->u.image.image_id;
5622 it->object = p->u.image.object;
5623 it->slice = p->u.image.slice;
5624 break;
5625 case GET_FROM_STRETCH:
5626 it->object = p->u.stretch.object;
5627 break;
5628 case GET_FROM_BUFFER:
5629 it->object = it->w->buffer;
5630 break;
5631 case GET_FROM_STRING:
5632 it->object = it->string;
5633 break;
5634 case GET_FROM_DISPLAY_VECTOR:
5635 if (it->s)
5636 it->method = GET_FROM_C_STRING;
5637 else if (STRINGP (it->string))
5638 it->method = GET_FROM_STRING;
5639 else
5640 {
5641 it->method = GET_FROM_BUFFER;
5642 it->object = it->w->buffer;
5643 }
5644 }
5645 it->end_charpos = p->end_charpos;
5646 it->string_nchars = p->string_nchars;
5647 it->area = p->area;
5648 it->multibyte_p = p->multibyte_p;
5649 it->avoid_cursor_p = p->avoid_cursor_p;
5650 it->space_width = p->space_width;
5651 it->font_height = p->font_height;
5652 it->voffset = p->voffset;
5653 it->string_from_display_prop_p = p->string_from_display_prop_p;
5654 it->line_wrap = p->line_wrap;
5655 it->bidi_p = p->bidi_p;
5656 it->paragraph_embedding = p->paragraph_embedding;
5657 it->from_disp_prop_p = p->from_disp_prop_p;
5658 if (it->bidi_p)
5659 {
5660 bidi_pop_it (&it->bidi_it);
5661 /* Bidi-iterate until we get out of the portion of text, if any,
5662 covered by a `display' text property or by an overlay with
5663 `display' property. (We cannot just jump there, because the
5664 internal coherency of the bidi iterator state can not be
5665 preserved across such jumps.) We also must determine the
5666 paragraph base direction if the overlay we just processed is
5667 at the beginning of a new paragraph. */
5668 if (from_display_prop
5669 && (it->method == GET_FROM_BUFFER || it->method == GET_FROM_STRING))
5670 iterate_out_of_display_property (it);
5671
5672 xassert ((BUFFERP (it->object)
5673 && IT_CHARPOS (*it) == it->bidi_it.charpos
5674 && IT_BYTEPOS (*it) == it->bidi_it.bytepos)
5675 || (STRINGP (it->object)
5676 && IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
5677 && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos)
5678 || (CONSP (it->object) && it->method == GET_FROM_STRETCH));
5679 }
5680 }
5681
5682
5683 \f
5684 /***********************************************************************
5685 Moving over lines
5686 ***********************************************************************/
5687
5688 /* Set IT's current position to the previous line start. */
5689
5690 static void
5691 back_to_previous_line_start (struct it *it)
5692 {
5693 IT_CHARPOS (*it) = find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1);
5694 IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
5695 }
5696
5697
5698 /* Move IT to the next line start.
5699
5700 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
5701 we skipped over part of the text (as opposed to moving the iterator
5702 continuously over the text). Otherwise, don't change the value
5703 of *SKIPPED_P.
5704
5705 If BIDI_IT_PREV is non-NULL, store into it the state of the bidi
5706 iterator on the newline, if it was found.
5707
5708 Newlines may come from buffer text, overlay strings, or strings
5709 displayed via the `display' property. That's the reason we can't
5710 simply use find_next_newline_no_quit.
5711
5712 Note that this function may not skip over invisible text that is so
5713 because of text properties and immediately follows a newline. If
5714 it would, function reseat_at_next_visible_line_start, when called
5715 from set_iterator_to_next, would effectively make invisible
5716 characters following a newline part of the wrong glyph row, which
5717 leads to wrong cursor motion. */
5718
5719 static int
5720 forward_to_next_line_start (struct it *it, int *skipped_p,
5721 struct bidi_it *bidi_it_prev)
5722 {
5723 ptrdiff_t old_selective;
5724 int newline_found_p, n;
5725 const int MAX_NEWLINE_DISTANCE = 500;
5726
5727 /* If already on a newline, just consume it to avoid unintended
5728 skipping over invisible text below. */
5729 if (it->what == IT_CHARACTER
5730 && it->c == '\n'
5731 && CHARPOS (it->position) == IT_CHARPOS (*it))
5732 {
5733 if (it->bidi_p && bidi_it_prev)
5734 *bidi_it_prev = it->bidi_it;
5735 set_iterator_to_next (it, 0);
5736 it->c = 0;
5737 return 1;
5738 }
5739
5740 /* Don't handle selective display in the following. It's (a)
5741 unnecessary because it's done by the caller, and (b) leads to an
5742 infinite recursion because next_element_from_ellipsis indirectly
5743 calls this function. */
5744 old_selective = it->selective;
5745 it->selective = 0;
5746
5747 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
5748 from buffer text. */
5749 for (n = newline_found_p = 0;
5750 !newline_found_p && n < MAX_NEWLINE_DISTANCE;
5751 n += STRINGP (it->string) ? 0 : 1)
5752 {
5753 if (!get_next_display_element (it))
5754 return 0;
5755 newline_found_p = it->what == IT_CHARACTER && it->c == '\n';
5756 if (newline_found_p && it->bidi_p && bidi_it_prev)
5757 *bidi_it_prev = it->bidi_it;
5758 set_iterator_to_next (it, 0);
5759 }
5760
5761 /* If we didn't find a newline near enough, see if we can use a
5762 short-cut. */
5763 if (!newline_found_p)
5764 {
5765 ptrdiff_t start = IT_CHARPOS (*it);
5766 ptrdiff_t limit = find_next_newline_no_quit (start, 1);
5767 Lisp_Object pos;
5768
5769 xassert (!STRINGP (it->string));
5770
5771 /* If there isn't any `display' property in sight, and no
5772 overlays, we can just use the position of the newline in
5773 buffer text. */
5774 if (it->stop_charpos >= limit
5775 || ((pos = Fnext_single_property_change (make_number (start),
5776 Qdisplay, Qnil,
5777 make_number (limit)),
5778 NILP (pos))
5779 && next_overlay_change (start) == ZV))
5780 {
5781 if (!it->bidi_p)
5782 {
5783 IT_CHARPOS (*it) = limit;
5784 IT_BYTEPOS (*it) = CHAR_TO_BYTE (limit);
5785 }
5786 else
5787 {
5788 struct bidi_it bprev;
5789
5790 /* Help bidi.c avoid expensive searches for display
5791 properties and overlays, by telling it that there are
5792 none up to `limit'. */
5793 if (it->bidi_it.disp_pos < limit)
5794 {
5795 it->bidi_it.disp_pos = limit;
5796 it->bidi_it.disp_prop = 0;
5797 }
5798 do {
5799 bprev = it->bidi_it;
5800 bidi_move_to_visually_next (&it->bidi_it);
5801 } while (it->bidi_it.charpos != limit);
5802 IT_CHARPOS (*it) = limit;
5803 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
5804 if (bidi_it_prev)
5805 *bidi_it_prev = bprev;
5806 }
5807 *skipped_p = newline_found_p = 1;
5808 }
5809 else
5810 {
5811 while (get_next_display_element (it)
5812 && !newline_found_p)
5813 {
5814 newline_found_p = ITERATOR_AT_END_OF_LINE_P (it);
5815 if (newline_found_p && it->bidi_p && bidi_it_prev)
5816 *bidi_it_prev = it->bidi_it;
5817 set_iterator_to_next (it, 0);
5818 }
5819 }
5820 }
5821
5822 it->selective = old_selective;
5823 return newline_found_p;
5824 }
5825
5826
5827 /* Set IT's current position to the previous visible line start. Skip
5828 invisible text that is so either due to text properties or due to
5829 selective display. Caution: this does not change IT->current_x and
5830 IT->hpos. */
5831
5832 static void
5833 back_to_previous_visible_line_start (struct it *it)
5834 {
5835 while (IT_CHARPOS (*it) > BEGV)
5836 {
5837 back_to_previous_line_start (it);
5838
5839 if (IT_CHARPOS (*it) <= BEGV)
5840 break;
5841
5842 /* If selective > 0, then lines indented more than its value are
5843 invisible. */
5844 if (it->selective > 0
5845 && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
5846 it->selective))
5847 continue;
5848
5849 /* Check the newline before point for invisibility. */
5850 {
5851 Lisp_Object prop;
5852 prop = Fget_char_property (make_number (IT_CHARPOS (*it) - 1),
5853 Qinvisible, it->window);
5854 if (TEXT_PROP_MEANS_INVISIBLE (prop))
5855 continue;
5856 }
5857
5858 if (IT_CHARPOS (*it) <= BEGV)
5859 break;
5860
5861 {
5862 struct it it2;
5863 void *it2data = NULL;
5864 ptrdiff_t pos;
5865 ptrdiff_t beg, end;
5866 Lisp_Object val, overlay;
5867
5868 SAVE_IT (it2, *it, it2data);
5869
5870 /* If newline is part of a composition, continue from start of composition */
5871 if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil)
5872 && beg < IT_CHARPOS (*it))
5873 goto replaced;
5874
5875 /* If newline is replaced by a display property, find start of overlay
5876 or interval and continue search from that point. */
5877 pos = --IT_CHARPOS (it2);
5878 --IT_BYTEPOS (it2);
5879 it2.sp = 0;
5880 bidi_unshelve_cache (NULL, 0);
5881 it2.string_from_display_prop_p = 0;
5882 it2.from_disp_prop_p = 0;
5883 if (handle_display_prop (&it2) == HANDLED_RETURN
5884 && !NILP (val = get_char_property_and_overlay
5885 (make_number (pos), Qdisplay, Qnil, &overlay))
5886 && (OVERLAYP (overlay)
5887 ? (beg = OVERLAY_POSITION (OVERLAY_START (overlay)))
5888 : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
5889 {
5890 RESTORE_IT (it, it, it2data);
5891 goto replaced;
5892 }
5893
5894 /* Newline is not replaced by anything -- so we are done. */
5895 RESTORE_IT (it, it, it2data);
5896 break;
5897
5898 replaced:
5899 if (beg < BEGV)
5900 beg = BEGV;
5901 IT_CHARPOS (*it) = beg;
5902 IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
5903 }
5904 }
5905
5906 it->continuation_lines_width = 0;
5907
5908 xassert (IT_CHARPOS (*it) >= BEGV);
5909 xassert (IT_CHARPOS (*it) == BEGV
5910 || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
5911 CHECK_IT (it);
5912 }
5913
5914
5915 /* Reseat iterator IT at the previous visible line start. Skip
5916 invisible text that is so either due to text properties or due to
5917 selective display. At the end, update IT's overlay information,
5918 face information etc. */
5919
5920 void
5921 reseat_at_previous_visible_line_start (struct it *it)
5922 {
5923 back_to_previous_visible_line_start (it);
5924 reseat (it, it->current.pos, 1);
5925 CHECK_IT (it);
5926 }
5927
5928
5929 /* Reseat iterator IT on the next visible line start in the current
5930 buffer. ON_NEWLINE_P non-zero means position IT on the newline
5931 preceding the line start. Skip over invisible text that is so
5932 because of selective display. Compute faces, overlays etc at the
5933 new position. Note that this function does not skip over text that
5934 is invisible because of text properties. */
5935
5936 static void
5937 reseat_at_next_visible_line_start (struct it *it, int on_newline_p)
5938 {
5939 int newline_found_p, skipped_p = 0;
5940 struct bidi_it bidi_it_prev;
5941
5942 newline_found_p = forward_to_next_line_start (it, &skipped_p, &bidi_it_prev);
5943
5944 /* Skip over lines that are invisible because they are indented
5945 more than the value of IT->selective. */
5946 if (it->selective > 0)
5947 while (IT_CHARPOS (*it) < ZV
5948 && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
5949 it->selective))
5950 {
5951 xassert (IT_BYTEPOS (*it) == BEGV
5952 || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
5953 newline_found_p =
5954 forward_to_next_line_start (it, &skipped_p, &bidi_it_prev);
5955 }
5956
5957 /* Position on the newline if that's what's requested. */
5958 if (on_newline_p && newline_found_p)
5959 {
5960 if (STRINGP (it->string))
5961 {
5962 if (IT_STRING_CHARPOS (*it) > 0)
5963 {
5964 if (!it->bidi_p)
5965 {
5966 --IT_STRING_CHARPOS (*it);
5967 --IT_STRING_BYTEPOS (*it);
5968 }
5969 else
5970 {
5971 /* We need to restore the bidi iterator to the state
5972 it had on the newline, and resync the IT's
5973 position with that. */
5974 it->bidi_it = bidi_it_prev;
5975 IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
5976 IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
5977 }
5978 }
5979 }
5980 else if (IT_CHARPOS (*it) > BEGV)
5981 {
5982 if (!it->bidi_p)
5983 {
5984 --IT_CHARPOS (*it);
5985 --IT_BYTEPOS (*it);
5986 }
5987 else
5988 {
5989 /* We need to restore the bidi iterator to the state it
5990 had on the newline and resync IT with that. */
5991 it->bidi_it = bidi_it_prev;
5992 IT_CHARPOS (*it) = it->bidi_it.charpos;
5993 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
5994 }
5995 reseat (it, it->current.pos, 0);
5996 }
5997 }
5998 else if (skipped_p)
5999 reseat (it, it->current.pos, 0);
6000
6001 CHECK_IT (it);
6002 }
6003
6004
6005 \f
6006 /***********************************************************************
6007 Changing an iterator's position
6008 ***********************************************************************/
6009
6010 /* Change IT's current position to POS in current_buffer. If FORCE_P
6011 is non-zero, always check for text properties at the new position.
6012 Otherwise, text properties are only looked up if POS >=
6013 IT->check_charpos of a property. */
6014
6015 static void
6016 reseat (struct it *it, struct text_pos pos, int force_p)
6017 {
6018 ptrdiff_t original_pos = IT_CHARPOS (*it);
6019
6020 reseat_1 (it, pos, 0);
6021
6022 /* Determine where to check text properties. Avoid doing it
6023 where possible because text property lookup is very expensive. */
6024 if (force_p
6025 || CHARPOS (pos) > it->stop_charpos
6026 || CHARPOS (pos) < original_pos)
6027 {
6028 if (it->bidi_p)
6029 {
6030 /* For bidi iteration, we need to prime prev_stop and
6031 base_level_stop with our best estimations. */
6032 /* Implementation note: Of course, POS is not necessarily a
6033 stop position, so assigning prev_pos to it is a lie; we
6034 should have called compute_stop_backwards. However, if
6035 the current buffer does not include any R2L characters,
6036 that call would be a waste of cycles, because the
6037 iterator will never move back, and thus never cross this
6038 "fake" stop position. So we delay that backward search
6039 until the time we really need it, in next_element_from_buffer. */
6040 if (CHARPOS (pos) != it->prev_stop)
6041 it->prev_stop = CHARPOS (pos);
6042 if (CHARPOS (pos) < it->base_level_stop)
6043 it->base_level_stop = 0; /* meaning it's unknown */
6044 handle_stop (it);
6045 }
6046 else
6047 {
6048 handle_stop (it);
6049 it->prev_stop = it->base_level_stop = 0;
6050 }
6051
6052 }
6053
6054 CHECK_IT (it);
6055 }
6056
6057
6058 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
6059 IT->stop_pos to POS, also. */
6060
6061 static void
6062 reseat_1 (struct it *it, struct text_pos pos, int set_stop_p)
6063 {
6064 /* Don't call this function when scanning a C string. */
6065 xassert (it->s == NULL);
6066
6067 /* POS must be a reasonable value. */
6068 xassert (CHARPOS (pos) >= BEGV && CHARPOS (pos) <= ZV);
6069
6070 it->current.pos = it->position = pos;
6071 it->end_charpos = ZV;
6072 it->dpvec = NULL;
6073 it->current.dpvec_index = -1;
6074 it->current.overlay_string_index = -1;
6075 IT_STRING_CHARPOS (*it) = -1;
6076 IT_STRING_BYTEPOS (*it) = -1;
6077 it->string = Qnil;
6078 it->method = GET_FROM_BUFFER;
6079 it->object = it->w->buffer;
6080 it->area = TEXT_AREA;
6081 it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
6082 it->sp = 0;
6083 it->string_from_display_prop_p = 0;
6084 it->from_disp_prop_p = 0;
6085 it->face_before_selective_p = 0;
6086 if (it->bidi_p)
6087 {
6088 bidi_init_it (IT_CHARPOS (*it), IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
6089 &it->bidi_it);
6090 bidi_unshelve_cache (NULL, 0);
6091 it->bidi_it.paragraph_dir = NEUTRAL_DIR;
6092 it->bidi_it.string.s = NULL;
6093 it->bidi_it.string.lstring = Qnil;
6094 it->bidi_it.string.bufpos = 0;
6095 it->bidi_it.string.unibyte = 0;
6096 }
6097
6098 if (set_stop_p)
6099 {
6100 it->stop_charpos = CHARPOS (pos);
6101 it->base_level_stop = CHARPOS (pos);
6102 }
6103 }
6104
6105
6106 /* Set up IT for displaying a string, starting at CHARPOS in window W.
6107 If S is non-null, it is a C string to iterate over. Otherwise,
6108 STRING gives a Lisp string to iterate over.
6109
6110 If PRECISION > 0, don't return more then PRECISION number of
6111 characters from the string.
6112
6113 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
6114 characters have been returned. FIELD_WIDTH < 0 means an infinite
6115 field width.
6116
6117 MULTIBYTE = 0 means disable processing of multibyte characters,
6118 MULTIBYTE > 0 means enable it,
6119 MULTIBYTE < 0 means use IT->multibyte_p.
6120
6121 IT must be initialized via a prior call to init_iterator before
6122 calling this function. */
6123
6124 static void
6125 reseat_to_string (struct it *it, const char *s, Lisp_Object string,
6126 ptrdiff_t charpos, ptrdiff_t precision, int field_width,
6127 int multibyte)
6128 {
6129 /* No region in strings. */
6130 it->region_beg_charpos = it->region_end_charpos = -1;
6131
6132 /* No text property checks performed by default, but see below. */
6133 it->stop_charpos = -1;
6134
6135 /* Set iterator position and end position. */
6136 memset (&it->current, 0, sizeof it->current);
6137 it->current.overlay_string_index = -1;
6138 it->current.dpvec_index = -1;
6139 xassert (charpos >= 0);
6140
6141 /* If STRING is specified, use its multibyteness, otherwise use the
6142 setting of MULTIBYTE, if specified. */
6143 if (multibyte >= 0)
6144 it->multibyte_p = multibyte > 0;
6145
6146 /* Bidirectional reordering of strings is controlled by the default
6147 value of bidi-display-reordering. */
6148 it->bidi_p = !NILP (BVAR (&buffer_defaults, bidi_display_reordering));
6149
6150 if (s == NULL)
6151 {
6152 xassert (STRINGP (string));
6153 it->string = string;
6154 it->s = NULL;
6155 it->end_charpos = it->string_nchars = SCHARS (string);
6156 it->method = GET_FROM_STRING;
6157 it->current.string_pos = string_pos (charpos, string);
6158
6159 if (it->bidi_p)
6160 {
6161 it->bidi_it.string.lstring = string;
6162 it->bidi_it.string.s = NULL;
6163 it->bidi_it.string.schars = it->end_charpos;
6164 it->bidi_it.string.bufpos = 0;
6165 it->bidi_it.string.from_disp_str = 0;
6166 it->bidi_it.string.unibyte = !it->multibyte_p;
6167 bidi_init_it (charpos, IT_STRING_BYTEPOS (*it),
6168 FRAME_WINDOW_P (it->f), &it->bidi_it);
6169 }
6170 }
6171 else
6172 {
6173 it->s = (const unsigned char *) s;
6174 it->string = Qnil;
6175
6176 /* Note that we use IT->current.pos, not it->current.string_pos,
6177 for displaying C strings. */
6178 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
6179 if (it->multibyte_p)
6180 {
6181 it->current.pos = c_string_pos (charpos, s, 1);
6182 it->end_charpos = it->string_nchars = number_of_chars (s, 1);
6183 }
6184 else
6185 {
6186 IT_CHARPOS (*it) = IT_BYTEPOS (*it) = charpos;
6187 it->end_charpos = it->string_nchars = strlen (s);
6188 }
6189
6190 if (it->bidi_p)
6191 {
6192 it->bidi_it.string.lstring = Qnil;
6193 it->bidi_it.string.s = (const unsigned char *) s;
6194 it->bidi_it.string.schars = it->end_charpos;
6195 it->bidi_it.string.bufpos = 0;
6196 it->bidi_it.string.from_disp_str = 0;
6197 it->bidi_it.string.unibyte = !it->multibyte_p;
6198 bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
6199 &it->bidi_it);
6200 }
6201 it->method = GET_FROM_C_STRING;
6202 }
6203
6204 /* PRECISION > 0 means don't return more than PRECISION characters
6205 from the string. */
6206 if (precision > 0 && it->end_charpos - charpos > precision)
6207 {
6208 it->end_charpos = it->string_nchars = charpos + precision;
6209 if (it->bidi_p)
6210 it->bidi_it.string.schars = it->end_charpos;
6211 }
6212
6213 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
6214 characters have been returned. FIELD_WIDTH == 0 means don't pad,
6215 FIELD_WIDTH < 0 means infinite field width. This is useful for
6216 padding with `-' at the end of a mode line. */
6217 if (field_width < 0)
6218 field_width = INFINITY;
6219 /* Implementation note: We deliberately don't enlarge
6220 it->bidi_it.string.schars here to fit it->end_charpos, because
6221 the bidi iterator cannot produce characters out of thin air. */
6222 if (field_width > it->end_charpos - charpos)
6223 it->end_charpos = charpos + field_width;
6224
6225 /* Use the standard display table for displaying strings. */
6226 if (DISP_TABLE_P (Vstandard_display_table))
6227 it->dp = XCHAR_TABLE (Vstandard_display_table);
6228
6229 it->stop_charpos = charpos;
6230 it->prev_stop = charpos;
6231 it->base_level_stop = 0;
6232 if (it->bidi_p)
6233 {
6234 it->bidi_it.first_elt = 1;
6235 it->bidi_it.paragraph_dir = NEUTRAL_DIR;
6236 it->bidi_it.disp_pos = -1;
6237 }
6238 if (s == NULL && it->multibyte_p)
6239 {
6240 ptrdiff_t endpos = SCHARS (it->string);
6241 if (endpos > it->end_charpos)
6242 endpos = it->end_charpos;
6243 composition_compute_stop_pos (&it->cmp_it, charpos, -1, endpos,
6244 it->string);
6245 }
6246 CHECK_IT (it);
6247 }
6248
6249
6250 \f
6251 /***********************************************************************
6252 Iteration
6253 ***********************************************************************/
6254
6255 /* Map enum it_method value to corresponding next_element_from_* function. */
6256
6257 static int (* get_next_element[NUM_IT_METHODS]) (struct it *it) =
6258 {
6259 next_element_from_buffer,
6260 next_element_from_display_vector,
6261 next_element_from_string,
6262 next_element_from_c_string,
6263 next_element_from_image,
6264 next_element_from_stretch
6265 };
6266
6267 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
6268
6269
6270 /* Return 1 iff a character at CHARPOS (and BYTEPOS) is composed
6271 (possibly with the following characters). */
6272
6273 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS) \
6274 ((IT)->cmp_it.id >= 0 \
6275 || ((IT)->cmp_it.stop_pos == (CHARPOS) \
6276 && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS, \
6277 END_CHARPOS, (IT)->w, \
6278 FACE_FROM_ID ((IT)->f, (IT)->face_id), \
6279 (IT)->string)))
6280
6281
6282 /* Lookup the char-table Vglyphless_char_display for character C (-1
6283 if we want information for no-font case), and return the display
6284 method symbol. By side-effect, update it->what and
6285 it->glyphless_method. This function is called from
6286 get_next_display_element for each character element, and from
6287 x_produce_glyphs when no suitable font was found. */
6288
6289 Lisp_Object
6290 lookup_glyphless_char_display (int c, struct it *it)
6291 {
6292 Lisp_Object glyphless_method = Qnil;
6293
6294 if (CHAR_TABLE_P (Vglyphless_char_display)
6295 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display)) >= 1)
6296 {
6297 if (c >= 0)
6298 {
6299 glyphless_method = CHAR_TABLE_REF (Vglyphless_char_display, c);
6300 if (CONSP (glyphless_method))
6301 glyphless_method = FRAME_WINDOW_P (it->f)
6302 ? XCAR (glyphless_method)
6303 : XCDR (glyphless_method);
6304 }
6305 else
6306 glyphless_method = XCHAR_TABLE (Vglyphless_char_display)->extras[0];
6307 }
6308
6309 retry:
6310 if (NILP (glyphless_method))
6311 {
6312 if (c >= 0)
6313 /* The default is to display the character by a proper font. */
6314 return Qnil;
6315 /* The default for the no-font case is to display an empty box. */
6316 glyphless_method = Qempty_box;
6317 }
6318 if (EQ (glyphless_method, Qzero_width))
6319 {
6320 if (c >= 0)
6321 return glyphless_method;
6322 /* This method can't be used for the no-font case. */
6323 glyphless_method = Qempty_box;
6324 }
6325 if (EQ (glyphless_method, Qthin_space))
6326 it->glyphless_method = GLYPHLESS_DISPLAY_THIN_SPACE;
6327 else if (EQ (glyphless_method, Qempty_box))
6328 it->glyphless_method = GLYPHLESS_DISPLAY_EMPTY_BOX;
6329 else if (EQ (glyphless_method, Qhex_code))
6330 it->glyphless_method = GLYPHLESS_DISPLAY_HEX_CODE;
6331 else if (STRINGP (glyphless_method))
6332 it->glyphless_method = GLYPHLESS_DISPLAY_ACRONYM;
6333 else
6334 {
6335 /* Invalid value. We use the default method. */
6336 glyphless_method = Qnil;
6337 goto retry;
6338 }
6339 it->what = IT_GLYPHLESS;
6340 return glyphless_method;
6341 }
6342
6343 /* Load IT's display element fields with information about the next
6344 display element from the current position of IT. Value is zero if
6345 end of buffer (or C string) is reached. */
6346
6347 static struct frame *last_escape_glyph_frame = NULL;
6348 static int last_escape_glyph_face_id = (1 << FACE_ID_BITS);
6349 static int last_escape_glyph_merged_face_id = 0;
6350
6351 struct frame *last_glyphless_glyph_frame = NULL;
6352 int last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
6353 int last_glyphless_glyph_merged_face_id = 0;
6354
6355 static int
6356 get_next_display_element (struct it *it)
6357 {
6358 /* Non-zero means that we found a display element. Zero means that
6359 we hit the end of what we iterate over. Performance note: the
6360 function pointer `method' used here turns out to be faster than
6361 using a sequence of if-statements. */
6362 int success_p;
6363
6364 get_next:
6365 success_p = GET_NEXT_DISPLAY_ELEMENT (it);
6366
6367 if (it->what == IT_CHARACTER)
6368 {
6369 /* UAX#9, L4: "A character is depicted by a mirrored glyph if
6370 and only if (a) the resolved directionality of that character
6371 is R..." */
6372 /* FIXME: Do we need an exception for characters from display
6373 tables? */
6374 if (it->bidi_p && it->bidi_it.type == STRONG_R)
6375 it->c = bidi_mirror_char (it->c);
6376 /* Map via display table or translate control characters.
6377 IT->c, IT->len etc. have been set to the next character by
6378 the function call above. If we have a display table, and it
6379 contains an entry for IT->c, translate it. Don't do this if
6380 IT->c itself comes from a display table, otherwise we could
6381 end up in an infinite recursion. (An alternative could be to
6382 count the recursion depth of this function and signal an
6383 error when a certain maximum depth is reached.) Is it worth
6384 it? */
6385 if (success_p && it->dpvec == NULL)
6386 {
6387 Lisp_Object dv;
6388 struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
6389 int nonascii_space_p = 0;
6390 int nonascii_hyphen_p = 0;
6391 int c = it->c; /* This is the character to display. */
6392
6393 if (! it->multibyte_p && ! ASCII_CHAR_P (c))
6394 {
6395 xassert (SINGLE_BYTE_CHAR_P (c));
6396 if (unibyte_display_via_language_environment)
6397 {
6398 c = DECODE_CHAR (unibyte, c);
6399 if (c < 0)
6400 c = BYTE8_TO_CHAR (it->c);
6401 }
6402 else
6403 c = BYTE8_TO_CHAR (it->c);
6404 }
6405
6406 if (it->dp
6407 && (dv = DISP_CHAR_VECTOR (it->dp, c),
6408 VECTORP (dv)))
6409 {
6410 struct Lisp_Vector *v = XVECTOR (dv);
6411
6412 /* Return the first character from the display table
6413 entry, if not empty. If empty, don't display the
6414 current character. */
6415 if (v->header.size)
6416 {
6417 it->dpvec_char_len = it->len;
6418 it->dpvec = v->contents;
6419 it->dpend = v->contents + v->header.size;
6420 it->current.dpvec_index = 0;
6421 it->dpvec_face_id = -1;
6422 it->saved_face_id = it->face_id;
6423 it->method = GET_FROM_DISPLAY_VECTOR;
6424 it->ellipsis_p = 0;
6425 }
6426 else
6427 {
6428 set_iterator_to_next (it, 0);
6429 }
6430 goto get_next;
6431 }
6432
6433 if (! NILP (lookup_glyphless_char_display (c, it)))
6434 {
6435 if (it->what == IT_GLYPHLESS)
6436 goto done;
6437 /* Don't display this character. */
6438 set_iterator_to_next (it, 0);
6439 goto get_next;
6440 }
6441
6442 /* If `nobreak-char-display' is non-nil, we display
6443 non-ASCII spaces and hyphens specially. */
6444 if (! ASCII_CHAR_P (c) && ! NILP (Vnobreak_char_display))
6445 {
6446 if (c == 0xA0)
6447 nonascii_space_p = 1;
6448 else if (c == 0xAD || c == 0x2010 || c == 0x2011)
6449 nonascii_hyphen_p = 1;
6450 }
6451
6452 /* Translate control characters into `\003' or `^C' form.
6453 Control characters coming from a display table entry are
6454 currently not translated because we use IT->dpvec to hold
6455 the translation. This could easily be changed but I
6456 don't believe that it is worth doing.
6457
6458 The characters handled by `nobreak-char-display' must be
6459 translated too.
6460
6461 Non-printable characters and raw-byte characters are also
6462 translated to octal form. */
6463 if (((c < ' ' || c == 127) /* ASCII control chars */
6464 ? (it->area != TEXT_AREA
6465 /* In mode line, treat \n, \t like other crl chars. */
6466 || (c != '\t'
6467 && it->glyph_row
6468 && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
6469 || (c != '\n' && c != '\t'))
6470 : (nonascii_space_p
6471 || nonascii_hyphen_p
6472 || CHAR_BYTE8_P (c)
6473 || ! CHAR_PRINTABLE_P (c))))
6474 {
6475 /* C is a control character, non-ASCII space/hyphen,
6476 raw-byte, or a non-printable character which must be
6477 displayed either as '\003' or as `^C' where the '\\'
6478 and '^' can be defined in the display table. Fill
6479 IT->ctl_chars with glyphs for what we have to
6480 display. Then, set IT->dpvec to these glyphs. */
6481 Lisp_Object gc;
6482 int ctl_len;
6483 int face_id;
6484 int lface_id = 0;
6485 int escape_glyph;
6486
6487 /* Handle control characters with ^. */
6488
6489 if (ASCII_CHAR_P (c) && it->ctl_arrow_p)
6490 {
6491 int g;
6492
6493 g = '^'; /* default glyph for Control */
6494 /* Set IT->ctl_chars[0] to the glyph for `^'. */
6495 if (it->dp
6496 && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc)))
6497 {
6498 g = GLYPH_CODE_CHAR (gc);
6499 lface_id = GLYPH_CODE_FACE (gc);
6500 }
6501 if (lface_id)
6502 {
6503 face_id = merge_faces (it->f, Qt, lface_id, it->face_id);
6504 }
6505 else if (it->f == last_escape_glyph_frame
6506 && it->face_id == last_escape_glyph_face_id)
6507 {
6508 face_id = last_escape_glyph_merged_face_id;
6509 }
6510 else
6511 {
6512 /* Merge the escape-glyph face into the current face. */
6513 face_id = merge_faces (it->f, Qescape_glyph, 0,
6514 it->face_id);
6515 last_escape_glyph_frame = it->f;
6516 last_escape_glyph_face_id = it->face_id;
6517 last_escape_glyph_merged_face_id = face_id;
6518 }
6519
6520 XSETINT (it->ctl_chars[0], g);
6521 XSETINT (it->ctl_chars[1], c ^ 0100);
6522 ctl_len = 2;
6523 goto display_control;
6524 }
6525
6526 /* Handle non-ascii space in the mode where it only gets
6527 highlighting. */
6528
6529 if (nonascii_space_p && EQ (Vnobreak_char_display, Qt))
6530 {
6531 /* Merge `nobreak-space' into the current face. */
6532 face_id = merge_faces (it->f, Qnobreak_space, 0,
6533 it->face_id);
6534 XSETINT (it->ctl_chars[0], ' ');
6535 ctl_len = 1;
6536 goto display_control;
6537 }
6538
6539 /* Handle sequences that start with the "escape glyph". */
6540
6541 /* the default escape glyph is \. */
6542 escape_glyph = '\\';
6543
6544 if (it->dp
6545 && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc)))
6546 {
6547 escape_glyph = GLYPH_CODE_CHAR (gc);
6548 lface_id = GLYPH_CODE_FACE (gc);
6549 }
6550 if (lface_id)
6551 {
6552 /* The display table specified a face.
6553 Merge it into face_id and also into escape_glyph. */
6554 face_id = merge_faces (it->f, Qt, lface_id,
6555 it->face_id);
6556 }
6557 else if (it->f == last_escape_glyph_frame
6558 && it->face_id == last_escape_glyph_face_id)
6559 {
6560 face_id = last_escape_glyph_merged_face_id;
6561 }
6562 else
6563 {
6564 /* Merge the escape-glyph face into the current face. */
6565 face_id = merge_faces (it->f, Qescape_glyph, 0,
6566 it->face_id);
6567 last_escape_glyph_frame = it->f;
6568 last_escape_glyph_face_id = it->face_id;
6569 last_escape_glyph_merged_face_id = face_id;
6570 }
6571
6572 /* Draw non-ASCII hyphen with just highlighting: */
6573
6574 if (nonascii_hyphen_p && EQ (Vnobreak_char_display, Qt))
6575 {
6576 XSETINT (it->ctl_chars[0], '-');
6577 ctl_len = 1;
6578 goto display_control;
6579 }
6580
6581 /* Draw non-ASCII space/hyphen with escape glyph: */
6582
6583 if (nonascii_space_p || nonascii_hyphen_p)
6584 {
6585 XSETINT (it->ctl_chars[0], escape_glyph);
6586 XSETINT (it->ctl_chars[1], nonascii_space_p ? ' ' : '-');
6587 ctl_len = 2;
6588 goto display_control;
6589 }
6590
6591 {
6592 char str[10];
6593 int len, i;
6594
6595 if (CHAR_BYTE8_P (c))
6596 /* Display \200 instead of \17777600. */
6597 c = CHAR_TO_BYTE8 (c);
6598 len = sprintf (str, "%03o", c);
6599
6600 XSETINT (it->ctl_chars[0], escape_glyph);
6601 for (i = 0; i < len; i++)
6602 XSETINT (it->ctl_chars[i + 1], str[i]);
6603 ctl_len = len + 1;
6604 }
6605
6606 display_control:
6607 /* Set up IT->dpvec and return first character from it. */
6608 it->dpvec_char_len = it->len;
6609 it->dpvec = it->ctl_chars;
6610 it->dpend = it->dpvec + ctl_len;
6611 it->current.dpvec_index = 0;
6612 it->dpvec_face_id = face_id;
6613 it->saved_face_id = it->face_id;
6614 it->method = GET_FROM_DISPLAY_VECTOR;
6615 it->ellipsis_p = 0;
6616 goto get_next;
6617 }
6618 it->char_to_display = c;
6619 }
6620 else if (success_p)
6621 {
6622 it->char_to_display = it->c;
6623 }
6624 }
6625
6626 /* Adjust face id for a multibyte character. There are no multibyte
6627 character in unibyte text. */
6628 if ((it->what == IT_CHARACTER || it->what == IT_COMPOSITION)
6629 && it->multibyte_p
6630 && success_p
6631 && FRAME_WINDOW_P (it->f))
6632 {
6633 struct face *face = FACE_FROM_ID (it->f, it->face_id);
6634
6635 if (it->what == IT_COMPOSITION && it->cmp_it.ch >= 0)
6636 {
6637 /* Automatic composition with glyph-string. */
6638 Lisp_Object gstring = composition_gstring_from_id (it->cmp_it.id);
6639
6640 it->face_id = face_for_font (it->f, LGSTRING_FONT (gstring), face);
6641 }
6642 else
6643 {
6644 ptrdiff_t pos = (it->s ? -1
6645 : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
6646 : IT_CHARPOS (*it));
6647 int c;
6648
6649 if (it->what == IT_CHARACTER)
6650 c = it->char_to_display;
6651 else
6652 {
6653 struct composition *cmp = composition_table[it->cmp_it.id];
6654 int i;
6655
6656 c = ' ';
6657 for (i = 0; i < cmp->glyph_len; i++)
6658 /* TAB in a composition means display glyphs with
6659 padding space on the left or right. */
6660 if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
6661 break;
6662 }
6663 it->face_id = FACE_FOR_CHAR (it->f, face, c, pos, it->string);
6664 }
6665 }
6666
6667 done:
6668 /* Is this character the last one of a run of characters with
6669 box? If yes, set IT->end_of_box_run_p to 1. */
6670 if (it->face_box_p
6671 && it->s == NULL)
6672 {
6673 if (it->method == GET_FROM_STRING && it->sp)
6674 {
6675 int face_id = underlying_face_id (it);
6676 struct face *face = FACE_FROM_ID (it->f, face_id);
6677
6678 if (face)
6679 {
6680 if (face->box == FACE_NO_BOX)
6681 {
6682 /* If the box comes from face properties in a
6683 display string, check faces in that string. */
6684 int string_face_id = face_after_it_pos (it);
6685 it->end_of_box_run_p
6686 = (FACE_FROM_ID (it->f, string_face_id)->box
6687 == FACE_NO_BOX);
6688 }
6689 /* Otherwise, the box comes from the underlying face.
6690 If this is the last string character displayed, check
6691 the next buffer location. */
6692 else if ((IT_STRING_CHARPOS (*it) >= SCHARS (it->string) - 1)
6693 && (it->current.overlay_string_index
6694 == it->n_overlay_strings - 1))
6695 {
6696 ptrdiff_t ignore;
6697 int next_face_id;
6698 struct text_pos pos = it->current.pos;
6699 INC_TEXT_POS (pos, it->multibyte_p);
6700
6701 next_face_id = face_at_buffer_position
6702 (it->w, CHARPOS (pos), it->region_beg_charpos,
6703 it->region_end_charpos, &ignore,
6704 (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT), 0,
6705 -1);
6706 it->end_of_box_run_p
6707 = (FACE_FROM_ID (it->f, next_face_id)->box
6708 == FACE_NO_BOX);
6709 }
6710 }
6711 }
6712 else
6713 {
6714 int face_id = face_after_it_pos (it);
6715 it->end_of_box_run_p
6716 = (face_id != it->face_id
6717 && FACE_FROM_ID (it->f, face_id)->box == FACE_NO_BOX);
6718 }
6719 }
6720
6721 /* Value is 0 if end of buffer or string reached. */
6722 return success_p;
6723 }
6724
6725
6726 /* Move IT to the next display element.
6727
6728 RESEAT_P non-zero means if called on a newline in buffer text,
6729 skip to the next visible line start.
6730
6731 Functions get_next_display_element and set_iterator_to_next are
6732 separate because I find this arrangement easier to handle than a
6733 get_next_display_element function that also increments IT's
6734 position. The way it is we can first look at an iterator's current
6735 display element, decide whether it fits on a line, and if it does,
6736 increment the iterator position. The other way around we probably
6737 would either need a flag indicating whether the iterator has to be
6738 incremented the next time, or we would have to implement a
6739 decrement position function which would not be easy to write. */
6740
6741 void
6742 set_iterator_to_next (struct it *it, int reseat_p)
6743 {
6744 /* Reset flags indicating start and end of a sequence of characters
6745 with box. Reset them at the start of this function because
6746 moving the iterator to a new position might set them. */
6747 it->start_of_box_run_p = it->end_of_box_run_p = 0;
6748
6749 switch (it->method)
6750 {
6751 case GET_FROM_BUFFER:
6752 /* The current display element of IT is a character from
6753 current_buffer. Advance in the buffer, and maybe skip over
6754 invisible lines that are so because of selective display. */
6755 if (ITERATOR_AT_END_OF_LINE_P (it) && reseat_p)
6756 reseat_at_next_visible_line_start (it, 0);
6757 else if (it->cmp_it.id >= 0)
6758 {
6759 /* We are currently getting glyphs from a composition. */
6760 int i;
6761
6762 if (! it->bidi_p)
6763 {
6764 IT_CHARPOS (*it) += it->cmp_it.nchars;
6765 IT_BYTEPOS (*it) += it->cmp_it.nbytes;
6766 if (it->cmp_it.to < it->cmp_it.nglyphs)
6767 {
6768 it->cmp_it.from = it->cmp_it.to;
6769 }
6770 else
6771 {
6772 it->cmp_it.id = -1;
6773 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6774 IT_BYTEPOS (*it),
6775 it->end_charpos, Qnil);
6776 }
6777 }
6778 else if (! it->cmp_it.reversed_p)
6779 {
6780 /* Composition created while scanning forward. */
6781 /* Update IT's char/byte positions to point to the first
6782 character of the next grapheme cluster, or to the
6783 character visually after the current composition. */
6784 for (i = 0; i < it->cmp_it.nchars; i++)
6785 bidi_move_to_visually_next (&it->bidi_it);
6786 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
6787 IT_CHARPOS (*it) = it->bidi_it.charpos;
6788
6789 if (it->cmp_it.to < it->cmp_it.nglyphs)
6790 {
6791 /* Proceed to the next grapheme cluster. */
6792 it->cmp_it.from = it->cmp_it.to;
6793 }
6794 else
6795 {
6796 /* No more grapheme clusters in this composition.
6797 Find the next stop position. */
6798 ptrdiff_t stop = it->end_charpos;
6799 if (it->bidi_it.scan_dir < 0)
6800 /* Now we are scanning backward and don't know
6801 where to stop. */
6802 stop = -1;
6803 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6804 IT_BYTEPOS (*it), stop, Qnil);
6805 }
6806 }
6807 else
6808 {
6809 /* Composition created while scanning backward. */
6810 /* Update IT's char/byte positions to point to the last
6811 character of the previous grapheme cluster, or the
6812 character visually after the current composition. */
6813 for (i = 0; i < it->cmp_it.nchars; i++)
6814 bidi_move_to_visually_next (&it->bidi_it);
6815 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
6816 IT_CHARPOS (*it) = it->bidi_it.charpos;
6817 if (it->cmp_it.from > 0)
6818 {
6819 /* Proceed to the previous grapheme cluster. */
6820 it->cmp_it.to = it->cmp_it.from;
6821 }
6822 else
6823 {
6824 /* No more grapheme clusters in this composition.
6825 Find the next stop position. */
6826 ptrdiff_t stop = it->end_charpos;
6827 if (it->bidi_it.scan_dir < 0)
6828 /* Now we are scanning backward and don't know
6829 where to stop. */
6830 stop = -1;
6831 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6832 IT_BYTEPOS (*it), stop, Qnil);
6833 }
6834 }
6835 }
6836 else
6837 {
6838 xassert (it->len != 0);
6839
6840 if (!it->bidi_p)
6841 {
6842 IT_BYTEPOS (*it) += it->len;
6843 IT_CHARPOS (*it) += 1;
6844 }
6845 else
6846 {
6847 int prev_scan_dir = it->bidi_it.scan_dir;
6848 /* If this is a new paragraph, determine its base
6849 direction (a.k.a. its base embedding level). */
6850 if (it->bidi_it.new_paragraph)
6851 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 0);
6852 bidi_move_to_visually_next (&it->bidi_it);
6853 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
6854 IT_CHARPOS (*it) = it->bidi_it.charpos;
6855 if (prev_scan_dir != it->bidi_it.scan_dir)
6856 {
6857 /* As the scan direction was changed, we must
6858 re-compute the stop position for composition. */
6859 ptrdiff_t stop = it->end_charpos;
6860 if (it->bidi_it.scan_dir < 0)
6861 stop = -1;
6862 composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
6863 IT_BYTEPOS (*it), stop, Qnil);
6864 }
6865 }
6866 xassert (IT_BYTEPOS (*it) == CHAR_TO_BYTE (IT_CHARPOS (*it)));
6867 }
6868 break;
6869
6870 case GET_FROM_C_STRING:
6871 /* Current display element of IT is from a C string. */
6872 if (!it->bidi_p
6873 /* If the string position is beyond string's end, it means
6874 next_element_from_c_string is padding the string with
6875 blanks, in which case we bypass the bidi iterator,
6876 because it cannot deal with such virtual characters. */
6877 || IT_CHARPOS (*it) >= it->bidi_it.string.schars)
6878 {
6879 IT_BYTEPOS (*it) += it->len;
6880 IT_CHARPOS (*it) += 1;
6881 }
6882 else
6883 {
6884 bidi_move_to_visually_next (&it->bidi_it);
6885 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
6886 IT_CHARPOS (*it) = it->bidi_it.charpos;
6887 }
6888 break;
6889
6890 case GET_FROM_DISPLAY_VECTOR:
6891 /* Current display element of IT is from a display table entry.
6892 Advance in the display table definition. Reset it to null if
6893 end reached, and continue with characters from buffers/
6894 strings. */
6895 ++it->current.dpvec_index;
6896
6897 /* Restore face of the iterator to what they were before the
6898 display vector entry (these entries may contain faces). */
6899 it->face_id = it->saved_face_id;
6900
6901 if (it->dpvec + it->current.dpvec_index == it->dpend)
6902 {
6903 int recheck_faces = it->ellipsis_p;
6904
6905 if (it->s)
6906 it->method = GET_FROM_C_STRING;
6907 else if (STRINGP (it->string))
6908 it->method = GET_FROM_STRING;
6909 else
6910 {
6911 it->method = GET_FROM_BUFFER;
6912 it->object = it->w->buffer;
6913 }
6914
6915 it->dpvec = NULL;
6916 it->current.dpvec_index = -1;
6917
6918 /* Skip over characters which were displayed via IT->dpvec. */
6919 if (it->dpvec_char_len < 0)
6920 reseat_at_next_visible_line_start (it, 1);
6921 else if (it->dpvec_char_len > 0)
6922 {
6923 if (it->method == GET_FROM_STRING
6924 && it->n_overlay_strings > 0)
6925 it->ignore_overlay_strings_at_pos_p = 1;
6926 it->len = it->dpvec_char_len;
6927 set_iterator_to_next (it, reseat_p);
6928 }
6929
6930 /* Maybe recheck faces after display vector */
6931 if (recheck_faces)
6932 it->stop_charpos = IT_CHARPOS (*it);
6933 }
6934 break;
6935
6936 case GET_FROM_STRING:
6937 /* Current display element is a character from a Lisp string. */
6938 xassert (it->s == NULL && STRINGP (it->string));
6939 if (it->cmp_it.id >= 0)
6940 {
6941 int i;
6942
6943 if (! it->bidi_p)
6944 {
6945 IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
6946 IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
6947 if (it->cmp_it.to < it->cmp_it.nglyphs)
6948 it->cmp_it.from = it->cmp_it.to;
6949 else
6950 {
6951 it->cmp_it.id = -1;
6952 composition_compute_stop_pos (&it->cmp_it,
6953 IT_STRING_CHARPOS (*it),
6954 IT_STRING_BYTEPOS (*it),
6955 it->end_charpos, it->string);
6956 }
6957 }
6958 else if (! it->cmp_it.reversed_p)
6959 {
6960 for (i = 0; i < it->cmp_it.nchars; i++)
6961 bidi_move_to_visually_next (&it->bidi_it);
6962 IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
6963 IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
6964
6965 if (it->cmp_it.to < it->cmp_it.nglyphs)
6966 it->cmp_it.from = it->cmp_it.to;
6967 else
6968 {
6969 ptrdiff_t stop = it->end_charpos;
6970 if (it->bidi_it.scan_dir < 0)
6971 stop = -1;
6972 composition_compute_stop_pos (&it->cmp_it,
6973 IT_STRING_CHARPOS (*it),
6974 IT_STRING_BYTEPOS (*it), stop,
6975 it->string);
6976 }
6977 }
6978 else
6979 {
6980 for (i = 0; i < it->cmp_it.nchars; i++)
6981 bidi_move_to_visually_next (&it->bidi_it);
6982 IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
6983 IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
6984 if (it->cmp_it.from > 0)
6985 it->cmp_it.to = it->cmp_it.from;
6986 else
6987 {
6988 ptrdiff_t stop = it->end_charpos;
6989 if (it->bidi_it.scan_dir < 0)
6990 stop = -1;
6991 composition_compute_stop_pos (&it->cmp_it,
6992 IT_STRING_CHARPOS (*it),
6993 IT_STRING_BYTEPOS (*it), stop,
6994 it->string);
6995 }
6996 }
6997 }
6998 else
6999 {
7000 if (!it->bidi_p
7001 /* If the string position is beyond string's end, it
7002 means next_element_from_string is padding the string
7003 with blanks, in which case we bypass the bidi
7004 iterator, because it cannot deal with such virtual
7005 characters. */
7006 || IT_STRING_CHARPOS (*it) >= it->bidi_it.string.schars)
7007 {
7008 IT_STRING_BYTEPOS (*it) += it->len;
7009 IT_STRING_CHARPOS (*it) += 1;
7010 }
7011 else
7012 {
7013 int prev_scan_dir = it->bidi_it.scan_dir;
7014
7015 bidi_move_to_visually_next (&it->bidi_it);
7016 IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
7017 IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
7018 if (prev_scan_dir != it->bidi_it.scan_dir)
7019 {
7020 ptrdiff_t stop = it->end_charpos;
7021
7022 if (it->bidi_it.scan_dir < 0)
7023 stop = -1;
7024 composition_compute_stop_pos (&it->cmp_it,
7025 IT_STRING_CHARPOS (*it),
7026 IT_STRING_BYTEPOS (*it), stop,
7027 it->string);
7028 }
7029 }
7030 }
7031
7032 consider_string_end:
7033
7034 if (it->current.overlay_string_index >= 0)
7035 {
7036 /* IT->string is an overlay string. Advance to the
7037 next, if there is one. */
7038 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
7039 {
7040 it->ellipsis_p = 0;
7041 next_overlay_string (it);
7042 if (it->ellipsis_p)
7043 setup_for_ellipsis (it, 0);
7044 }
7045 }
7046 else
7047 {
7048 /* IT->string is not an overlay string. If we reached
7049 its end, and there is something on IT->stack, proceed
7050 with what is on the stack. This can be either another
7051 string, this time an overlay string, or a buffer. */
7052 if (IT_STRING_CHARPOS (*it) == SCHARS (it->string)
7053 && it->sp > 0)
7054 {
7055 pop_it (it);
7056 if (it->method == GET_FROM_STRING)
7057 goto consider_string_end;
7058 }
7059 }
7060 break;
7061
7062 case GET_FROM_IMAGE:
7063 case GET_FROM_STRETCH:
7064 /* The position etc with which we have to proceed are on
7065 the stack. The position may be at the end of a string,
7066 if the `display' property takes up the whole string. */
7067 xassert (it->sp > 0);
7068 pop_it (it);
7069 if (it->method == GET_FROM_STRING)
7070 goto consider_string_end;
7071 break;
7072
7073 default:
7074 /* There are no other methods defined, so this should be a bug. */
7075 abort ();
7076 }
7077
7078 xassert (it->method != GET_FROM_STRING
7079 || (STRINGP (it->string)
7080 && IT_STRING_CHARPOS (*it) >= 0));
7081 }
7082
7083 /* Load IT's display element fields with information about the next
7084 display element which comes from a display table entry or from the
7085 result of translating a control character to one of the forms `^C'
7086 or `\003'.
7087
7088 IT->dpvec holds the glyphs to return as characters.
7089 IT->saved_face_id holds the face id before the display vector--it
7090 is restored into IT->face_id in set_iterator_to_next. */
7091
7092 static int
7093 next_element_from_display_vector (struct it *it)
7094 {
7095 Lisp_Object gc;
7096
7097 /* Precondition. */
7098 xassert (it->dpvec && it->current.dpvec_index >= 0);
7099
7100 it->face_id = it->saved_face_id;
7101
7102 /* KFS: This code used to check ip->dpvec[0] instead of the current element.
7103 That seemed totally bogus - so I changed it... */
7104 gc = it->dpvec[it->current.dpvec_index];
7105
7106 if (GLYPH_CODE_P (gc))
7107 {
7108 it->c = GLYPH_CODE_CHAR (gc);
7109 it->len = CHAR_BYTES (it->c);
7110
7111 /* The entry may contain a face id to use. Such a face id is
7112 the id of a Lisp face, not a realized face. A face id of
7113 zero means no face is specified. */
7114 if (it->dpvec_face_id >= 0)
7115 it->face_id = it->dpvec_face_id;
7116 else
7117 {
7118 int lface_id = GLYPH_CODE_FACE (gc);
7119 if (lface_id > 0)
7120 it->face_id = merge_faces (it->f, Qt, lface_id,
7121 it->saved_face_id);
7122 }
7123 }
7124 else
7125 /* Display table entry is invalid. Return a space. */
7126 it->c = ' ', it->len = 1;
7127
7128 /* Don't change position and object of the iterator here. They are
7129 still the values of the character that had this display table
7130 entry or was translated, and that's what we want. */
7131 it->what = IT_CHARACTER;
7132 return 1;
7133 }
7134
7135 /* Get the first element of string/buffer in the visual order, after
7136 being reseated to a new position in a string or a buffer. */
7137 static void
7138 get_visually_first_element (struct it *it)
7139 {
7140 int string_p = STRINGP (it->string) || it->s;
7141 ptrdiff_t eob = (string_p ? it->bidi_it.string.schars : ZV);
7142 ptrdiff_t bob = (string_p ? 0 : BEGV);
7143
7144 if (STRINGP (it->string))
7145 {
7146 it->bidi_it.charpos = IT_STRING_CHARPOS (*it);
7147 it->bidi_it.bytepos = IT_STRING_BYTEPOS (*it);
7148 }
7149 else
7150 {
7151 it->bidi_it.charpos = IT_CHARPOS (*it);
7152 it->bidi_it.bytepos = IT_BYTEPOS (*it);
7153 }
7154
7155 if (it->bidi_it.charpos == eob)
7156 {
7157 /* Nothing to do, but reset the FIRST_ELT flag, like
7158 bidi_paragraph_init does, because we are not going to
7159 call it. */
7160 it->bidi_it.first_elt = 0;
7161 }
7162 else if (it->bidi_it.charpos == bob
7163 || (!string_p
7164 && (FETCH_CHAR (it->bidi_it.bytepos - 1) == '\n'
7165 || FETCH_CHAR (it->bidi_it.bytepos) == '\n')))
7166 {
7167 /* If we are at the beginning of a line/string, we can produce
7168 the next element right away. */
7169 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
7170 bidi_move_to_visually_next (&it->bidi_it);
7171 }
7172 else
7173 {
7174 ptrdiff_t orig_bytepos = it->bidi_it.bytepos;
7175
7176 /* We need to prime the bidi iterator starting at the line's or
7177 string's beginning, before we will be able to produce the
7178 next element. */
7179 if (string_p)
7180 it->bidi_it.charpos = it->bidi_it.bytepos = 0;
7181 else
7182 {
7183 it->bidi_it.charpos = find_next_newline_no_quit (IT_CHARPOS (*it),
7184 -1);
7185 it->bidi_it.bytepos = CHAR_TO_BYTE (it->bidi_it.charpos);
7186 }
7187 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
7188 do
7189 {
7190 /* Now return to buffer/string position where we were asked
7191 to get the next display element, and produce that. */
7192 bidi_move_to_visually_next (&it->bidi_it);
7193 }
7194 while (it->bidi_it.bytepos != orig_bytepos
7195 && it->bidi_it.charpos < eob);
7196 }
7197
7198 /* Adjust IT's position information to where we ended up. */
7199 if (STRINGP (it->string))
7200 {
7201 IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
7202 IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
7203 }
7204 else
7205 {
7206 IT_CHARPOS (*it) = it->bidi_it.charpos;
7207 IT_BYTEPOS (*it) = it->bidi_it.bytepos;
7208 }
7209
7210 if (STRINGP (it->string) || !it->s)
7211 {
7212 ptrdiff_t stop, charpos, bytepos;
7213
7214 if (STRINGP (it->string))
7215 {
7216 xassert (!it->s);
7217 stop = SCHARS (it->string);
7218 if (stop > it->end_charpos)
7219 stop = it->end_charpos;
7220 charpos = IT_STRING_CHARPOS (*it);
7221 bytepos = IT_STRING_BYTEPOS (*it);
7222 }
7223 else
7224 {
7225 stop = it->end_charpos;
7226 charpos = IT_CHARPOS (*it);
7227 bytepos = IT_BYTEPOS (*it);
7228 }
7229 if (it->bidi_it.scan_dir < 0)
7230 stop = -1;
7231 composition_compute_stop_pos (&it->cmp_it, charpos, bytepos, stop,
7232 it->string);
7233 }
7234 }
7235
7236 /* Load IT with the next display element from Lisp string IT->string.
7237 IT->current.string_pos is the current position within the string.
7238 If IT->current.overlay_string_index >= 0, the Lisp string is an
7239 overlay string. */
7240
7241 static int
7242 next_element_from_string (struct it *it)
7243 {
7244 struct text_pos position;
7245
7246 xassert (STRINGP (it->string));
7247 xassert (!it->bidi_p || EQ (it->string, it->bidi_it.string.lstring));
7248 xassert (IT_STRING_CHARPOS (*it) >= 0);
7249 position = it->current.string_pos;
7250
7251 /* With bidi reordering, the character to display might not be the
7252 character at IT_STRING_CHARPOS. BIDI_IT.FIRST_ELT non-zero means
7253 that we were reseat()ed to a new string, whose paragraph
7254 direction is not known. */
7255 if (it->bidi_p && it->bidi_it.first_elt)
7256 {
7257 get_visually_first_element (it);
7258 SET_TEXT_POS (position, IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it));
7259 }
7260
7261 /* Time to check for invisible text? */
7262 if (IT_STRING_CHARPOS (*it) < it->end_charpos)
7263 {
7264 if (IT_STRING_CHARPOS (*it) >= it->stop_charpos)
7265 {
7266 if (!(!it->bidi_p
7267 || BIDI_AT_BASE_LEVEL (it->bidi_it)
7268 || IT_STRING_CHARPOS (*it) == it->stop_charpos))
7269 {
7270 /* With bidi non-linear iteration, we could find
7271 ourselves far beyond the last computed stop_charpos,
7272 with several other stop positions in between that we
7273 missed. Scan them all now, in buffer's logical
7274 order, until we find and handle the last stop_charpos
7275 that precedes our current position. */
7276 handle_stop_backwards (it, it->stop_charpos);
7277 return GET_NEXT_DISPLAY_ELEMENT (it);
7278 }
7279 else
7280 {
7281 if (it->bidi_p)
7282 {
7283 /* Take note of the stop position we just moved
7284 across, for when we will move back across it. */
7285 it->prev_stop = it->stop_charpos;
7286 /* If we are at base paragraph embedding level, take
7287 note of the last stop position seen at this
7288 level. */
7289 if (BIDI_AT_BASE_LEVEL (it->bidi_it))
7290 it->base_level_stop = it->stop_charpos;
7291 }
7292 handle_stop (it);
7293
7294 /* Since a handler may have changed IT->method, we must
7295 recurse here. */
7296 return GET_NEXT_DISPLAY_ELEMENT (it);
7297 }
7298 }
7299 else if (it->bidi_p
7300 /* If we are before prev_stop, we may have overstepped
7301 on our way backwards a stop_pos, and if so, we need
7302 to handle that stop_pos. */
7303 && IT_STRING_CHARPOS (*it) < it->prev_stop
7304 /* We can sometimes back up for reasons that have nothing
7305 to do with bidi reordering. E.g., compositions. The
7306 code below is only needed when we are above the base
7307 embedding level, so test for that explicitly. */
7308 && !BIDI_AT_BASE_LEVEL (it->bidi_it))
7309 {
7310 /* If we lost track of base_level_stop, we have no better
7311 place for handle_stop_backwards to start from than string
7312 beginning. This happens, e.g., when we were reseated to
7313 the previous screenful of text by vertical-motion. */
7314 if (it->base_level_stop <= 0
7315 || IT_STRING_CHARPOS (*it) < it->base_level_stop)
7316 it->base_level_stop = 0;
7317 handle_stop_backwards (it, it->base_level_stop);
7318 return GET_NEXT_DISPLAY_ELEMENT (it);
7319 }
7320 }
7321
7322 if (it->current.overlay_string_index >= 0)
7323 {
7324 /* Get the next character from an overlay string. In overlay
7325 strings, There is no field width or padding with spaces to
7326 do. */
7327 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
7328 {
7329 it->what = IT_EOB;
7330 return 0;
7331 }
7332 else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
7333 IT_STRING_BYTEPOS (*it),
7334 it->bidi_it.scan_dir < 0
7335 ? -1
7336 : SCHARS (it->string))
7337 && next_element_from_composition (it))
7338 {
7339 return 1;
7340 }
7341 else if (STRING_MULTIBYTE (it->string))
7342 {
7343 const unsigned char *s = (SDATA (it->string)
7344 + IT_STRING_BYTEPOS (*it));
7345 it->c = string_char_and_length (s, &it->len);
7346 }
7347 else
7348 {
7349 it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
7350 it->len = 1;
7351 }
7352 }
7353 else
7354 {
7355 /* Get the next character from a Lisp string that is not an
7356 overlay string. Such strings come from the mode line, for
7357 example. We may have to pad with spaces, or truncate the
7358 string. See also next_element_from_c_string. */
7359 if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
7360 {
7361 it->what = IT_EOB;
7362 return 0;
7363 }
7364 else if (IT_STRING_CHARPOS (*it) >= it->string_nchars)
7365 {
7366 /* Pad with spaces. */
7367 it->c = ' ', it->len = 1;
7368 CHARPOS (position) = BYTEPOS (position) = -1;
7369 }
7370 else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
7371 IT_STRING_BYTEPOS (*it),
7372 it->bidi_it.scan_dir < 0
7373 ? -1
7374 : it->string_nchars)
7375 && next_element_from_composition (it))
7376 {
7377 return 1;
7378 }
7379 else if (STRING_MULTIBYTE (it->string))
7380 {
7381 const unsigned char *s = (SDATA (it->string)
7382 + IT_STRING_BYTEPOS (*it));
7383 it->c = string_char_and_length (s, &it->len);
7384 }
7385 else
7386 {
7387 it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
7388 it->len = 1;
7389 }
7390 }
7391
7392 /* Record what we have and where it came from. */
7393 it->what = IT_CHARACTER;
7394 it->object = it->string;
7395 it->position = position;
7396 return 1;
7397 }
7398
7399
7400 /* Load IT with next display element from C string IT->s.
7401 IT->string_nchars is the maximum number of characters to return
7402 from the string. IT->end_charpos may be greater than
7403 IT->string_nchars when this function is called, in which case we
7404 may have to return padding spaces. Value is zero if end of string
7405 reached, including padding spaces. */
7406
7407 static int
7408 next_element_from_c_string (struct it *it)
7409 {
7410 int success_p = 1;
7411
7412 xassert (it->s);
7413 xassert (!it->bidi_p || it->s == it->bidi_it.string.s);
7414 it->what = IT_CHARACTER;
7415 BYTEPOS (it->position) = CHARPOS (it->position) = 0;
7416 it->object = Qnil;
7417
7418 /* With bidi reordering, the character to display might not be the
7419 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7420 we were reseated to a new string, whose paragraph direction is
7421 not known. */
7422 if (it->bidi_p && it->bidi_it.first_elt)
7423 get_visually_first_element (it);
7424
7425 /* IT's position can be greater than IT->string_nchars in case a
7426 field width or precision has been specified when the iterator was
7427 initialized. */
7428 if (IT_CHARPOS (*it) >= it->end_charpos)
7429 {
7430 /* End of the game. */
7431 it->what = IT_EOB;
7432 success_p = 0;
7433 }
7434 else if (IT_CHARPOS (*it) >= it->string_nchars)
7435 {
7436 /* Pad with spaces. */
7437 it->c = ' ', it->len = 1;
7438 BYTEPOS (it->position) = CHARPOS (it->position) = -1;
7439 }
7440 else if (it->multibyte_p)
7441 it->c = string_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
7442 else
7443 it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
7444
7445 return success_p;
7446 }
7447
7448
7449 /* Set up IT to return characters from an ellipsis, if appropriate.
7450 The definition of the ellipsis glyphs may come from a display table
7451 entry. This function fills IT with the first glyph from the
7452 ellipsis if an ellipsis is to be displayed. */
7453
7454 static int
7455 next_element_from_ellipsis (struct it *it)
7456 {
7457 if (it->selective_display_ellipsis_p)
7458 setup_for_ellipsis (it, it->len);
7459 else
7460 {
7461 /* The face at the current position may be different from the
7462 face we find after the invisible text. Remember what it
7463 was in IT->saved_face_id, and signal that it's there by
7464 setting face_before_selective_p. */
7465 it->saved_face_id = it->face_id;
7466 it->method = GET_FROM_BUFFER;
7467 it->object = it->w->buffer;
7468 reseat_at_next_visible_line_start (it, 1);
7469 it->face_before_selective_p = 1;
7470 }
7471
7472 return GET_NEXT_DISPLAY_ELEMENT (it);
7473 }
7474
7475
7476 /* Deliver an image display element. The iterator IT is already
7477 filled with image information (done in handle_display_prop). Value
7478 is always 1. */
7479
7480
7481 static int
7482 next_element_from_image (struct it *it)
7483 {
7484 it->what = IT_IMAGE;
7485 it->ignore_overlay_strings_at_pos_p = 0;
7486 return 1;
7487 }
7488
7489
7490 /* Fill iterator IT with next display element from a stretch glyph
7491 property. IT->object is the value of the text property. Value is
7492 always 1. */
7493
7494 static int
7495 next_element_from_stretch (struct it *it)
7496 {
7497 it->what = IT_STRETCH;
7498 return 1;
7499 }
7500
7501 /* Scan backwards from IT's current position until we find a stop
7502 position, or until BEGV. This is called when we find ourself
7503 before both the last known prev_stop and base_level_stop while
7504 reordering bidirectional text. */
7505
7506 static void
7507 compute_stop_pos_backwards (struct it *it)
7508 {
7509 const int SCAN_BACK_LIMIT = 1000;
7510 struct text_pos pos;
7511 struct display_pos save_current = it->current;
7512 struct text_pos save_position = it->position;
7513 ptrdiff_t charpos = IT_CHARPOS (*it);
7514 ptrdiff_t where_we_are = charpos;
7515 ptrdiff_t save_stop_pos = it->stop_charpos;
7516 ptrdiff_t save_end_pos = it->end_charpos;
7517
7518 xassert (NILP (it->string) && !it->s);
7519 xassert (it->bidi_p);
7520 it->bidi_p = 0;
7521 do
7522 {
7523 it->end_charpos = min (charpos + 1, ZV);
7524 charpos = max (charpos - SCAN_BACK_LIMIT, BEGV);
7525 SET_TEXT_POS (pos, charpos, BYTE_TO_CHAR (charpos));
7526 reseat_1 (it, pos, 0);
7527 compute_stop_pos (it);
7528 /* We must advance forward, right? */
7529 if (it->stop_charpos <= charpos)
7530 abort ();
7531 }
7532 while (charpos > BEGV && it->stop_charpos >= it->end_charpos);
7533
7534 if (it->stop_charpos <= where_we_are)
7535 it->prev_stop = it->stop_charpos;
7536 else
7537 it->prev_stop = BEGV;
7538 it->bidi_p = 1;
7539 it->current = save_current;
7540 it->position = save_position;
7541 it->stop_charpos = save_stop_pos;
7542 it->end_charpos = save_end_pos;
7543 }
7544
7545 /* Scan forward from CHARPOS in the current buffer/string, until we
7546 find a stop position > current IT's position. Then handle the stop
7547 position before that. This is called when we bump into a stop
7548 position while reordering bidirectional text. CHARPOS should be
7549 the last previously processed stop_pos (or BEGV/0, if none were
7550 processed yet) whose position is less that IT's current
7551 position. */
7552
7553 static void
7554 handle_stop_backwards (struct it *it, ptrdiff_t charpos)
7555 {
7556 int bufp = !STRINGP (it->string);
7557 ptrdiff_t where_we_are = (bufp ? IT_CHARPOS (*it) : IT_STRING_CHARPOS (*it));
7558 struct display_pos save_current = it->current;
7559 struct text_pos save_position = it->position;
7560 struct text_pos pos1;
7561 ptrdiff_t next_stop;
7562
7563 /* Scan in strict logical order. */
7564 xassert (it->bidi_p);
7565 it->bidi_p = 0;
7566 do
7567 {
7568 it->prev_stop = charpos;
7569 if (bufp)
7570 {
7571 SET_TEXT_POS (pos1, charpos, CHAR_TO_BYTE (charpos));
7572 reseat_1 (it, pos1, 0);
7573 }
7574 else
7575 it->current.string_pos = string_pos (charpos, it->string);
7576 compute_stop_pos (it);
7577 /* We must advance forward, right? */
7578 if (it->stop_charpos <= it->prev_stop)
7579 abort ();
7580 charpos = it->stop_charpos;
7581 }
7582 while (charpos <= where_we_are);
7583
7584 it->bidi_p = 1;
7585 it->current = save_current;
7586 it->position = save_position;
7587 next_stop = it->stop_charpos;
7588 it->stop_charpos = it->prev_stop;
7589 handle_stop (it);
7590 it->stop_charpos = next_stop;
7591 }
7592
7593 /* Load IT with the next display element from current_buffer. Value
7594 is zero if end of buffer reached. IT->stop_charpos is the next
7595 position at which to stop and check for text properties or buffer
7596 end. */
7597
7598 static int
7599 next_element_from_buffer (struct it *it)
7600 {
7601 int success_p = 1;
7602
7603 xassert (IT_CHARPOS (*it) >= BEGV);
7604 xassert (NILP (it->string) && !it->s);
7605 xassert (!it->bidi_p
7606 || (EQ (it->bidi_it.string.lstring, Qnil)
7607 && it->bidi_it.string.s == NULL));
7608
7609 /* With bidi reordering, the character to display might not be the
7610 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7611 we were reseat()ed to a new buffer position, which is potentially
7612 a different paragraph. */
7613 if (it->bidi_p && it->bidi_it.first_elt)
7614 {
7615 get_visually_first_element (it);
7616 SET_TEXT_POS (it->position, IT_CHARPOS (*it), IT_BYTEPOS (*it));
7617 }
7618
7619 if (IT_CHARPOS (*it) >= it->stop_charpos)
7620 {
7621 if (IT_CHARPOS (*it) >= it->end_charpos)
7622 {
7623 int overlay_strings_follow_p;
7624
7625 /* End of the game, except when overlay strings follow that
7626 haven't been returned yet. */
7627 if (it->overlay_strings_at_end_processed_p)
7628 overlay_strings_follow_p = 0;
7629 else
7630 {
7631 it->overlay_strings_at_end_processed_p = 1;
7632 overlay_strings_follow_p = get_overlay_strings (it, 0);
7633 }
7634
7635 if (overlay_strings_follow_p)
7636 success_p = GET_NEXT_DISPLAY_ELEMENT (it);
7637 else
7638 {
7639 it->what = IT_EOB;
7640 it->position = it->current.pos;
7641 success_p = 0;
7642 }
7643 }
7644 else if (!(!it->bidi_p
7645 || BIDI_AT_BASE_LEVEL (it->bidi_it)
7646 || IT_CHARPOS (*it) == it->stop_charpos))
7647 {
7648 /* With bidi non-linear iteration, we could find ourselves
7649 far beyond the last computed stop_charpos, with several
7650 other stop positions in between that we missed. Scan
7651 them all now, in buffer's logical order, until we find
7652 and handle the last stop_charpos that precedes our
7653 current position. */
7654 handle_stop_backwards (it, it->stop_charpos);
7655 return GET_NEXT_DISPLAY_ELEMENT (it);
7656 }
7657 else
7658 {
7659 if (it->bidi_p)
7660 {
7661 /* Take note of the stop position we just moved across,
7662 for when we will move back across it. */
7663 it->prev_stop = it->stop_charpos;
7664 /* If we are at base paragraph embedding level, take
7665 note of the last stop position seen at this
7666 level. */
7667 if (BIDI_AT_BASE_LEVEL (it->bidi_it))
7668 it->base_level_stop = it->stop_charpos;
7669 }
7670 handle_stop (it);
7671 return GET_NEXT_DISPLAY_ELEMENT (it);
7672 }
7673 }
7674 else if (it->bidi_p
7675 /* If we are before prev_stop, we may have overstepped on
7676 our way backwards a stop_pos, and if so, we need to
7677 handle that stop_pos. */
7678 && IT_CHARPOS (*it) < it->prev_stop
7679 /* We can sometimes back up for reasons that have nothing
7680 to do with bidi reordering. E.g., compositions. The
7681 code below is only needed when we are above the base
7682 embedding level, so test for that explicitly. */
7683 && !BIDI_AT_BASE_LEVEL (it->bidi_it))
7684 {
7685 if (it->base_level_stop <= 0
7686 || IT_CHARPOS (*it) < it->base_level_stop)
7687 {
7688 /* If we lost track of base_level_stop, we need to find
7689 prev_stop by looking backwards. This happens, e.g., when
7690 we were reseated to the previous screenful of text by
7691 vertical-motion. */
7692 it->base_level_stop = BEGV;
7693 compute_stop_pos_backwards (it);
7694 handle_stop_backwards (it, it->prev_stop);
7695 }
7696 else
7697 handle_stop_backwards (it, it->base_level_stop);
7698 return GET_NEXT_DISPLAY_ELEMENT (it);
7699 }
7700 else
7701 {
7702 /* No face changes, overlays etc. in sight, so just return a
7703 character from current_buffer. */
7704 unsigned char *p;
7705 ptrdiff_t stop;
7706
7707 /* Maybe run the redisplay end trigger hook. Performance note:
7708 This doesn't seem to cost measurable time. */
7709 if (it->redisplay_end_trigger_charpos
7710 && it->glyph_row
7711 && IT_CHARPOS (*it) >= it->redisplay_end_trigger_charpos)
7712 run_redisplay_end_trigger_hook (it);
7713
7714 stop = it->bidi_it.scan_dir < 0 ? -1 : it->end_charpos;
7715 if (CHAR_COMPOSED_P (it, IT_CHARPOS (*it), IT_BYTEPOS (*it),
7716 stop)
7717 && next_element_from_composition (it))
7718 {
7719 return 1;
7720 }
7721
7722 /* Get the next character, maybe multibyte. */
7723 p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
7724 if (it->multibyte_p && !ASCII_BYTE_P (*p))
7725 it->c = STRING_CHAR_AND_LENGTH (p, it->len);
7726 else
7727 it->c = *p, it->len = 1;
7728
7729 /* Record what we have and where it came from. */
7730 it->what = IT_CHARACTER;
7731 it->object = it->w->buffer;
7732 it->position = it->current.pos;
7733
7734 /* Normally we return the character found above, except when we
7735 really want to return an ellipsis for selective display. */
7736 if (it->selective)
7737 {
7738 if (it->c == '\n')
7739 {
7740 /* A value of selective > 0 means hide lines indented more
7741 than that number of columns. */
7742 if (it->selective > 0
7743 && IT_CHARPOS (*it) + 1 < ZV
7744 && indented_beyond_p (IT_CHARPOS (*it) + 1,
7745 IT_BYTEPOS (*it) + 1,
7746 it->selective))
7747 {
7748 success_p = next_element_from_ellipsis (it);
7749 it->dpvec_char_len = -1;
7750 }
7751 }
7752 else if (it->c == '\r' && it->selective == -1)
7753 {
7754 /* A value of selective == -1 means that everything from the
7755 CR to the end of the line is invisible, with maybe an
7756 ellipsis displayed for it. */
7757 success_p = next_element_from_ellipsis (it);
7758 it->dpvec_char_len = -1;
7759 }
7760 }
7761 }
7762
7763 /* Value is zero if end of buffer reached. */
7764 xassert (!success_p || it->what != IT_CHARACTER || it->len > 0);
7765 return success_p;
7766 }
7767
7768
7769 /* Run the redisplay end trigger hook for IT. */
7770
7771 static void
7772 run_redisplay_end_trigger_hook (struct it *it)
7773 {
7774 Lisp_Object args[3];
7775
7776 /* IT->glyph_row should be non-null, i.e. we should be actually
7777 displaying something, or otherwise we should not run the hook. */
7778 xassert (it->glyph_row);
7779
7780 /* Set up hook arguments. */
7781 args[0] = Qredisplay_end_trigger_functions;
7782 args[1] = it->window;
7783 XSETINT (args[2], it->redisplay_end_trigger_charpos);
7784 it->redisplay_end_trigger_charpos = 0;
7785
7786 /* Since we are *trying* to run these functions, don't try to run
7787 them again, even if they get an error. */
7788 it->w->redisplay_end_trigger = Qnil;
7789 Frun_hook_with_args (3, args);
7790
7791 /* Notice if it changed the face of the character we are on. */
7792 handle_face_prop (it);
7793 }
7794
7795
7796 /* Deliver a composition display element. Unlike the other
7797 next_element_from_XXX, this function is not registered in the array
7798 get_next_element[]. It is called from next_element_from_buffer and
7799 next_element_from_string when necessary. */
7800
7801 static int
7802 next_element_from_composition (struct it *it)
7803 {
7804 it->what = IT_COMPOSITION;
7805 it->len = it->cmp_it.nbytes;
7806 if (STRINGP (it->string))
7807 {
7808 if (it->c < 0)
7809 {
7810 IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
7811 IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
7812 return 0;
7813 }
7814 it->position = it->current.string_pos;
7815 it->object = it->string;
7816 it->c = composition_update_it (&it->cmp_it, IT_STRING_CHARPOS (*it),
7817 IT_STRING_BYTEPOS (*it), it->string);
7818 }
7819 else
7820 {
7821 if (it->c < 0)
7822 {
7823 IT_CHARPOS (*it) += it->cmp_it.nchars;
7824 IT_BYTEPOS (*it) += it->cmp_it.nbytes;
7825 if (it->bidi_p)
7826 {
7827 if (it->bidi_it.new_paragraph)
7828 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 0);
7829 /* Resync the bidi iterator with IT's new position.
7830 FIXME: this doesn't support bidirectional text. */
7831 while (it->bidi_it.charpos < IT_CHARPOS (*it))
7832 bidi_move_to_visually_next (&it->bidi_it);
7833 }
7834 return 0;
7835 }
7836 it->position = it->current.pos;
7837 it->object = it->w->buffer;
7838 it->c = composition_update_it (&it->cmp_it, IT_CHARPOS (*it),
7839 IT_BYTEPOS (*it), Qnil);
7840 }
7841 return 1;
7842 }
7843
7844
7845 \f
7846 /***********************************************************************
7847 Moving an iterator without producing glyphs
7848 ***********************************************************************/
7849
7850 /* Check if iterator is at a position corresponding to a valid buffer
7851 position after some move_it_ call. */
7852
7853 #define IT_POS_VALID_AFTER_MOVE_P(it) \
7854 ((it)->method == GET_FROM_STRING \
7855 ? IT_STRING_CHARPOS (*it) == 0 \
7856 : 1)
7857
7858
7859 /* Move iterator IT to a specified buffer or X position within one
7860 line on the display without producing glyphs.
7861
7862 OP should be a bit mask including some or all of these bits:
7863 MOVE_TO_X: Stop upon reaching x-position TO_X.
7864 MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
7865 Regardless of OP's value, stop upon reaching the end of the display line.
7866
7867 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
7868 This means, in particular, that TO_X includes window's horizontal
7869 scroll amount.
7870
7871 The return value has several possible values that
7872 say what condition caused the scan to stop:
7873
7874 MOVE_POS_MATCH_OR_ZV
7875 - when TO_POS or ZV was reached.
7876
7877 MOVE_X_REACHED
7878 -when TO_X was reached before TO_POS or ZV were reached.
7879
7880 MOVE_LINE_CONTINUED
7881 - when we reached the end of the display area and the line must
7882 be continued.
7883
7884 MOVE_LINE_TRUNCATED
7885 - when we reached the end of the display area and the line is
7886 truncated.
7887
7888 MOVE_NEWLINE_OR_CR
7889 - when we stopped at a line end, i.e. a newline or a CR and selective
7890 display is on. */
7891
7892 static enum move_it_result
7893 move_it_in_display_line_to (struct it *it,
7894 ptrdiff_t to_charpos, int to_x,
7895 enum move_operation_enum op)
7896 {
7897 enum move_it_result result = MOVE_UNDEFINED;
7898 struct glyph_row *saved_glyph_row;
7899 struct it wrap_it, atpos_it, atx_it, ppos_it;
7900 void *wrap_data = NULL, *atpos_data = NULL, *atx_data = NULL;
7901 void *ppos_data = NULL;
7902 int may_wrap = 0;
7903 enum it_method prev_method = it->method;
7904 ptrdiff_t prev_pos = IT_CHARPOS (*it);
7905 int saw_smaller_pos = prev_pos < to_charpos;
7906
7907 /* Don't produce glyphs in produce_glyphs. */
7908 saved_glyph_row = it->glyph_row;
7909 it->glyph_row = NULL;
7910
7911 /* Use wrap_it to save a copy of IT wherever a word wrap could
7912 occur. Use atpos_it to save a copy of IT at the desired buffer
7913 position, if found, so that we can scan ahead and check if the
7914 word later overshoots the window edge. Use atx_it similarly, for
7915 pixel positions. */
7916 wrap_it.sp = -1;
7917 atpos_it.sp = -1;
7918 atx_it.sp = -1;
7919
7920 /* Use ppos_it under bidi reordering to save a copy of IT for the
7921 position > CHARPOS that is the closest to CHARPOS. We restore
7922 that position in IT when we have scanned the entire display line
7923 without finding a match for CHARPOS and all the character
7924 positions are greater than CHARPOS. */
7925 if (it->bidi_p)
7926 {
7927 SAVE_IT (ppos_it, *it, ppos_data);
7928 SET_TEXT_POS (ppos_it.current.pos, ZV, ZV_BYTE);
7929 if ((op & MOVE_TO_POS) && IT_CHARPOS (*it) >= to_charpos)
7930 SAVE_IT (ppos_it, *it, ppos_data);
7931 }
7932
7933 #define BUFFER_POS_REACHED_P() \
7934 ((op & MOVE_TO_POS) != 0 \
7935 && BUFFERP (it->object) \
7936 && (IT_CHARPOS (*it) == to_charpos \
7937 || ((!it->bidi_p \
7938 || BIDI_AT_BASE_LEVEL (it->bidi_it)) \
7939 && IT_CHARPOS (*it) > to_charpos) \
7940 || (it->what == IT_COMPOSITION \
7941 && ((IT_CHARPOS (*it) > to_charpos \
7942 && to_charpos >= it->cmp_it.charpos) \
7943 || (IT_CHARPOS (*it) < to_charpos \
7944 && to_charpos <= it->cmp_it.charpos)))) \
7945 && (it->method == GET_FROM_BUFFER \
7946 || (it->method == GET_FROM_DISPLAY_VECTOR \
7947 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
7948
7949 /* If there's a line-/wrap-prefix, handle it. */
7950 if (it->hpos == 0 && it->method == GET_FROM_BUFFER
7951 && it->current_y < it->last_visible_y)
7952 handle_line_prefix (it);
7953
7954 if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
7955 SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
7956
7957 while (1)
7958 {
7959 int x, i, ascent = 0, descent = 0;
7960
7961 /* Utility macro to reset an iterator with x, ascent, and descent. */
7962 #define IT_RESET_X_ASCENT_DESCENT(IT) \
7963 ((IT)->current_x = x, (IT)->max_ascent = ascent, \
7964 (IT)->max_descent = descent)
7965
7966 /* Stop if we move beyond TO_CHARPOS (after an image or a
7967 display string or stretch glyph). */
7968 if ((op & MOVE_TO_POS) != 0
7969 && BUFFERP (it->object)
7970 && it->method == GET_FROM_BUFFER
7971 && (((!it->bidi_p
7972 /* When the iterator is at base embedding level, we
7973 are guaranteed that characters are delivered for
7974 display in strictly increasing order of their
7975 buffer positions. */
7976 || BIDI_AT_BASE_LEVEL (it->bidi_it))
7977 && IT_CHARPOS (*it) > to_charpos)
7978 || (it->bidi_p
7979 && (prev_method == GET_FROM_IMAGE
7980 || prev_method == GET_FROM_STRETCH
7981 || prev_method == GET_FROM_STRING)
7982 /* Passed TO_CHARPOS from left to right. */
7983 && ((prev_pos < to_charpos
7984 && IT_CHARPOS (*it) > to_charpos)
7985 /* Passed TO_CHARPOS from right to left. */
7986 || (prev_pos > to_charpos
7987 && IT_CHARPOS (*it) < to_charpos)))))
7988 {
7989 if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
7990 {
7991 result = MOVE_POS_MATCH_OR_ZV;
7992 break;
7993 }
7994 else if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
7995 /* If wrap_it is valid, the current position might be in a
7996 word that is wrapped. So, save the iterator in
7997 atpos_it and continue to see if wrapping happens. */
7998 SAVE_IT (atpos_it, *it, atpos_data);
7999 }
8000
8001 /* Stop when ZV reached.
8002 We used to stop here when TO_CHARPOS reached as well, but that is
8003 too soon if this glyph does not fit on this line. So we handle it
8004 explicitly below. */
8005 if (!get_next_display_element (it))
8006 {
8007 result = MOVE_POS_MATCH_OR_ZV;
8008 break;
8009 }
8010
8011 if (it->line_wrap == TRUNCATE)
8012 {
8013 if (BUFFER_POS_REACHED_P ())
8014 {
8015 result = MOVE_POS_MATCH_OR_ZV;
8016 break;
8017 }
8018 }
8019 else
8020 {
8021 if (it->line_wrap == WORD_WRAP)
8022 {
8023 if (IT_DISPLAYING_WHITESPACE (it))
8024 may_wrap = 1;
8025 else if (may_wrap)
8026 {
8027 /* We have reached a glyph that follows one or more
8028 whitespace characters. If the position is
8029 already found, we are done. */
8030 if (atpos_it.sp >= 0)
8031 {
8032 RESTORE_IT (it, &atpos_it, atpos_data);
8033 result = MOVE_POS_MATCH_OR_ZV;
8034 goto done;
8035 }
8036 if (atx_it.sp >= 0)
8037 {
8038 RESTORE_IT (it, &atx_it, atx_data);
8039 result = MOVE_X_REACHED;
8040 goto done;
8041 }
8042 /* Otherwise, we can wrap here. */
8043 SAVE_IT (wrap_it, *it, wrap_data);
8044 may_wrap = 0;
8045 }
8046 }
8047 }
8048
8049 /* Remember the line height for the current line, in case
8050 the next element doesn't fit on the line. */
8051 ascent = it->max_ascent;
8052 descent = it->max_descent;
8053
8054 /* The call to produce_glyphs will get the metrics of the
8055 display element IT is loaded with. Record the x-position
8056 before this display element, in case it doesn't fit on the
8057 line. */
8058 x = it->current_x;
8059
8060 PRODUCE_GLYPHS (it);
8061
8062 if (it->area != TEXT_AREA)
8063 {
8064 prev_method = it->method;
8065 if (it->method == GET_FROM_BUFFER)
8066 prev_pos = IT_CHARPOS (*it);
8067 set_iterator_to_next (it, 1);
8068 if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
8069 SET_TEXT_POS (this_line_min_pos,
8070 IT_CHARPOS (*it), IT_BYTEPOS (*it));
8071 if (it->bidi_p
8072 && (op & MOVE_TO_POS)
8073 && IT_CHARPOS (*it) > to_charpos
8074 && IT_CHARPOS (*it) < IT_CHARPOS (ppos_it))
8075 SAVE_IT (ppos_it, *it, ppos_data);
8076 continue;
8077 }
8078
8079 /* The number of glyphs we get back in IT->nglyphs will normally
8080 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
8081 character on a terminal frame, or (iii) a line end. For the
8082 second case, IT->nglyphs - 1 padding glyphs will be present.
8083 (On X frames, there is only one glyph produced for a
8084 composite character.)
8085
8086 The behavior implemented below means, for continuation lines,
8087 that as many spaces of a TAB as fit on the current line are
8088 displayed there. For terminal frames, as many glyphs of a
8089 multi-glyph character are displayed in the current line, too.
8090 This is what the old redisplay code did, and we keep it that
8091 way. Under X, the whole shape of a complex character must
8092 fit on the line or it will be completely displayed in the
8093 next line.
8094
8095 Note that both for tabs and padding glyphs, all glyphs have
8096 the same width. */
8097 if (it->nglyphs)
8098 {
8099 /* More than one glyph or glyph doesn't fit on line. All
8100 glyphs have the same width. */
8101 int single_glyph_width = it->pixel_width / it->nglyphs;
8102 int new_x;
8103 int x_before_this_char = x;
8104 int hpos_before_this_char = it->hpos;
8105
8106 for (i = 0; i < it->nglyphs; ++i, x = new_x)
8107 {
8108 new_x = x + single_glyph_width;
8109
8110 /* We want to leave anything reaching TO_X to the caller. */
8111 if ((op & MOVE_TO_X) && new_x > to_x)
8112 {
8113 if (BUFFER_POS_REACHED_P ())
8114 {
8115 if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
8116 goto buffer_pos_reached;
8117 if (atpos_it.sp < 0)
8118 {
8119 SAVE_IT (atpos_it, *it, atpos_data);
8120 IT_RESET_X_ASCENT_DESCENT (&atpos_it);
8121 }
8122 }
8123 else
8124 {
8125 if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
8126 {
8127 it->current_x = x;
8128 result = MOVE_X_REACHED;
8129 break;
8130 }
8131 if (atx_it.sp < 0)
8132 {
8133 SAVE_IT (atx_it, *it, atx_data);
8134 IT_RESET_X_ASCENT_DESCENT (&atx_it);
8135 }
8136 }
8137 }
8138
8139 if (/* Lines are continued. */
8140 it->line_wrap != TRUNCATE
8141 && (/* And glyph doesn't fit on the line. */
8142 new_x > it->last_visible_x
8143 /* Or it fits exactly and we're on a window
8144 system frame. */
8145 || (new_x == it->last_visible_x
8146 && FRAME_WINDOW_P (it->f))))
8147 {
8148 if (/* IT->hpos == 0 means the very first glyph
8149 doesn't fit on the line, e.g. a wide image. */
8150 it->hpos == 0
8151 || (new_x == it->last_visible_x
8152 && FRAME_WINDOW_P (it->f)))
8153 {
8154 ++it->hpos;
8155 it->current_x = new_x;
8156
8157 /* The character's last glyph just barely fits
8158 in this row. */
8159 if (i == it->nglyphs - 1)
8160 {
8161 /* If this is the destination position,
8162 return a position *before* it in this row,
8163 now that we know it fits in this row. */
8164 if (BUFFER_POS_REACHED_P ())
8165 {
8166 if (it->line_wrap != WORD_WRAP
8167 || wrap_it.sp < 0)
8168 {
8169 it->hpos = hpos_before_this_char;
8170 it->current_x = x_before_this_char;
8171 result = MOVE_POS_MATCH_OR_ZV;
8172 break;
8173 }
8174 if (it->line_wrap == WORD_WRAP
8175 && atpos_it.sp < 0)
8176 {
8177 SAVE_IT (atpos_it, *it, atpos_data);
8178 atpos_it.current_x = x_before_this_char;
8179 atpos_it.hpos = hpos_before_this_char;
8180 }
8181 }
8182
8183 prev_method = it->method;
8184 if (it->method == GET_FROM_BUFFER)
8185 prev_pos = IT_CHARPOS (*it);
8186 set_iterator_to_next (it, 1);
8187 if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
8188 SET_TEXT_POS (this_line_min_pos,
8189 IT_CHARPOS (*it), IT_BYTEPOS (*it));
8190 /* On graphical terminals, newlines may
8191 "overflow" into the fringe if
8192 overflow-newline-into-fringe is non-nil.
8193 On text-only terminals, newlines may
8194 overflow into the last glyph on the
8195 display line.*/
8196 if (!FRAME_WINDOW_P (it->f)
8197 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
8198 {
8199 if (!get_next_display_element (it))
8200 {
8201 result = MOVE_POS_MATCH_OR_ZV;
8202 break;
8203 }
8204 if (BUFFER_POS_REACHED_P ())
8205 {
8206 if (ITERATOR_AT_END_OF_LINE_P (it))
8207 result = MOVE_POS_MATCH_OR_ZV;
8208 else
8209 result = MOVE_LINE_CONTINUED;
8210 break;
8211 }
8212 if (ITERATOR_AT_END_OF_LINE_P (it))
8213 {
8214 result = MOVE_NEWLINE_OR_CR;
8215 break;
8216 }
8217 }
8218 }
8219 }
8220 else
8221 IT_RESET_X_ASCENT_DESCENT (it);
8222
8223 if (wrap_it.sp >= 0)
8224 {
8225 RESTORE_IT (it, &wrap_it, wrap_data);
8226 atpos_it.sp = -1;
8227 atx_it.sp = -1;
8228 }
8229
8230 TRACE_MOVE ((stderr, "move_it_in: continued at %d\n",
8231 IT_CHARPOS (*it)));
8232 result = MOVE_LINE_CONTINUED;
8233 break;
8234 }
8235
8236 if (BUFFER_POS_REACHED_P ())
8237 {
8238 if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
8239 goto buffer_pos_reached;
8240 if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
8241 {
8242 SAVE_IT (atpos_it, *it, atpos_data);
8243 IT_RESET_X_ASCENT_DESCENT (&atpos_it);
8244 }
8245 }
8246
8247 if (new_x > it->first_visible_x)
8248 {
8249 /* Glyph is visible. Increment number of glyphs that
8250 would be displayed. */
8251 ++it->hpos;
8252 }
8253 }
8254
8255 if (result != MOVE_UNDEFINED)
8256 break;
8257 }
8258 else if (BUFFER_POS_REACHED_P ())
8259 {
8260 buffer_pos_reached:
8261 IT_RESET_X_ASCENT_DESCENT (it);
8262 result = MOVE_POS_MATCH_OR_ZV;
8263 break;
8264 }
8265 else if ((op & MOVE_TO_X) && it->current_x >= to_x)
8266 {
8267 /* Stop when TO_X specified and reached. This check is
8268 necessary here because of lines consisting of a line end,
8269 only. The line end will not produce any glyphs and we
8270 would never get MOVE_X_REACHED. */
8271 xassert (it->nglyphs == 0);
8272 result = MOVE_X_REACHED;
8273 break;
8274 }
8275
8276 /* Is this a line end? If yes, we're done. */
8277 if (ITERATOR_AT_END_OF_LINE_P (it))
8278 {
8279 /* If we are past TO_CHARPOS, but never saw any character
8280 positions smaller than TO_CHARPOS, return
8281 MOVE_POS_MATCH_OR_ZV, like the unidirectional display
8282 did. */
8283 if (it->bidi_p && (op & MOVE_TO_POS) != 0)
8284 {
8285 if (!saw_smaller_pos && IT_CHARPOS (*it) > to_charpos)
8286 {
8287 if (IT_CHARPOS (ppos_it) < ZV)
8288 {
8289 RESTORE_IT (it, &ppos_it, ppos_data);
8290 result = MOVE_POS_MATCH_OR_ZV;
8291 }
8292 else
8293 goto buffer_pos_reached;
8294 }
8295 else if (it->line_wrap == WORD_WRAP && atpos_it.sp >= 0
8296 && IT_CHARPOS (*it) > to_charpos)
8297 goto buffer_pos_reached;
8298 else
8299 result = MOVE_NEWLINE_OR_CR;
8300 }
8301 else
8302 result = MOVE_NEWLINE_OR_CR;
8303 break;
8304 }
8305
8306 prev_method = it->method;
8307 if (it->method == GET_FROM_BUFFER)
8308 prev_pos = IT_CHARPOS (*it);
8309 /* The current display element has been consumed. Advance
8310 to the next. */
8311 set_iterator_to_next (it, 1);
8312 if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
8313 SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
8314 if (IT_CHARPOS (*it) < to_charpos)
8315 saw_smaller_pos = 1;
8316 if (it->bidi_p
8317 && (op & MOVE_TO_POS)
8318 && IT_CHARPOS (*it) >= to_charpos
8319 && IT_CHARPOS (*it) < IT_CHARPOS (ppos_it))
8320 SAVE_IT (ppos_it, *it, ppos_data);
8321
8322 /* Stop if lines are truncated and IT's current x-position is
8323 past the right edge of the window now. */
8324 if (it->line_wrap == TRUNCATE
8325 && it->current_x >= it->last_visible_x)
8326 {
8327 if (!FRAME_WINDOW_P (it->f)
8328 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
8329 {
8330 int at_eob_p = 0;
8331
8332 if ((at_eob_p = !get_next_display_element (it))
8333 || BUFFER_POS_REACHED_P ()
8334 /* If we are past TO_CHARPOS, but never saw any
8335 character positions smaller than TO_CHARPOS,
8336 return MOVE_POS_MATCH_OR_ZV, like the
8337 unidirectional display did. */
8338 || (it->bidi_p && (op & MOVE_TO_POS) != 0
8339 && !saw_smaller_pos
8340 && IT_CHARPOS (*it) > to_charpos))
8341 {
8342 if (it->bidi_p
8343 && !at_eob_p && IT_CHARPOS (ppos_it) < ZV)
8344 RESTORE_IT (it, &ppos_it, ppos_data);
8345 result = MOVE_POS_MATCH_OR_ZV;
8346 break;
8347 }
8348 if (ITERATOR_AT_END_OF_LINE_P (it))
8349 {
8350 result = MOVE_NEWLINE_OR_CR;
8351 break;
8352 }
8353 }
8354 else if (it->bidi_p && (op & MOVE_TO_POS) != 0
8355 && !saw_smaller_pos
8356 && IT_CHARPOS (*it) > to_charpos)
8357 {
8358 if (IT_CHARPOS (ppos_it) < ZV)
8359 RESTORE_IT (it, &ppos_it, ppos_data);
8360 result = MOVE_POS_MATCH_OR_ZV;
8361 break;
8362 }
8363 result = MOVE_LINE_TRUNCATED;
8364 break;
8365 }
8366 #undef IT_RESET_X_ASCENT_DESCENT
8367 }
8368
8369 #undef BUFFER_POS_REACHED_P
8370
8371 /* If we scanned beyond to_pos and didn't find a point to wrap at,
8372 restore the saved iterator. */
8373 if (atpos_it.sp >= 0)
8374 RESTORE_IT (it, &atpos_it, atpos_data);
8375 else if (atx_it.sp >= 0)
8376 RESTORE_IT (it, &atx_it, atx_data);
8377
8378 done:
8379
8380 if (atpos_data)
8381 bidi_unshelve_cache (atpos_data, 1);
8382 if (atx_data)
8383 bidi_unshelve_cache (atx_data, 1);
8384 if (wrap_data)
8385 bidi_unshelve_cache (wrap_data, 1);
8386 if (ppos_data)
8387 bidi_unshelve_cache (ppos_data, 1);
8388
8389 /* Restore the iterator settings altered at the beginning of this
8390 function. */
8391 it->glyph_row = saved_glyph_row;
8392 return result;
8393 }
8394
8395 /* For external use. */
8396 void
8397 move_it_in_display_line (struct it *it,
8398 ptrdiff_t to_charpos, int to_x,
8399 enum move_operation_enum op)
8400 {
8401 if (it->line_wrap == WORD_WRAP
8402 && (op & MOVE_TO_X))
8403 {
8404 struct it save_it;
8405 void *save_data = NULL;
8406 int skip;
8407
8408 SAVE_IT (save_it, *it, save_data);
8409 skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
8410 /* When word-wrap is on, TO_X may lie past the end
8411 of a wrapped line. Then it->current is the
8412 character on the next line, so backtrack to the
8413 space before the wrap point. */
8414 if (skip == MOVE_LINE_CONTINUED)
8415 {
8416 int prev_x = max (it->current_x - 1, 0);
8417 RESTORE_IT (it, &save_it, save_data);
8418 move_it_in_display_line_to
8419 (it, -1, prev_x, MOVE_TO_X);
8420 }
8421 else
8422 bidi_unshelve_cache (save_data, 1);
8423 }
8424 else
8425 move_it_in_display_line_to (it, to_charpos, to_x, op);
8426 }
8427
8428
8429 /* Move IT forward until it satisfies one or more of the criteria in
8430 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
8431
8432 OP is a bit-mask that specifies where to stop, and in particular,
8433 which of those four position arguments makes a difference. See the
8434 description of enum move_operation_enum.
8435
8436 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
8437 screen line, this function will set IT to the next position that is
8438 displayed to the right of TO_CHARPOS on the screen. */
8439
8440 void
8441 move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos, int op)
8442 {
8443 enum move_it_result skip, skip2 = MOVE_X_REACHED;
8444 int line_height, line_start_x = 0, reached = 0;
8445 void *backup_data = NULL;
8446
8447 for (;;)
8448 {
8449 if (op & MOVE_TO_VPOS)
8450 {
8451 /* If no TO_CHARPOS and no TO_X specified, stop at the
8452 start of the line TO_VPOS. */
8453 if ((op & (MOVE_TO_X | MOVE_TO_POS)) == 0)
8454 {
8455 if (it->vpos == to_vpos)
8456 {
8457 reached = 1;
8458 break;
8459 }
8460 else
8461 skip = move_it_in_display_line_to (it, -1, -1, 0);
8462 }
8463 else
8464 {
8465 /* TO_VPOS >= 0 means stop at TO_X in the line at
8466 TO_VPOS, or at TO_POS, whichever comes first. */
8467 if (it->vpos == to_vpos)
8468 {
8469 reached = 2;
8470 break;
8471 }
8472
8473 skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
8474
8475 if (skip == MOVE_POS_MATCH_OR_ZV || it->vpos == to_vpos)
8476 {
8477 reached = 3;
8478 break;
8479 }
8480 else if (skip == MOVE_X_REACHED && it->vpos != to_vpos)
8481 {
8482 /* We have reached TO_X but not in the line we want. */
8483 skip = move_it_in_display_line_to (it, to_charpos,
8484 -1, MOVE_TO_POS);
8485 if (skip == MOVE_POS_MATCH_OR_ZV)
8486 {
8487 reached = 4;
8488 break;
8489 }
8490 }
8491 }
8492 }
8493 else if (op & MOVE_TO_Y)
8494 {
8495 struct it it_backup;
8496
8497 if (it->line_wrap == WORD_WRAP)
8498 SAVE_IT (it_backup, *it, backup_data);
8499
8500 /* TO_Y specified means stop at TO_X in the line containing
8501 TO_Y---or at TO_CHARPOS if this is reached first. The
8502 problem is that we can't really tell whether the line
8503 contains TO_Y before we have completely scanned it, and
8504 this may skip past TO_X. What we do is to first scan to
8505 TO_X.
8506
8507 If TO_X is not specified, use a TO_X of zero. The reason
8508 is to make the outcome of this function more predictable.
8509 If we didn't use TO_X == 0, we would stop at the end of
8510 the line which is probably not what a caller would expect
8511 to happen. */
8512 skip = move_it_in_display_line_to
8513 (it, to_charpos, ((op & MOVE_TO_X) ? to_x : 0),
8514 (MOVE_TO_X | (op & MOVE_TO_POS)));
8515
8516 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
8517 if (skip == MOVE_POS_MATCH_OR_ZV)
8518 reached = 5;
8519 else if (skip == MOVE_X_REACHED)
8520 {
8521 /* If TO_X was reached, we want to know whether TO_Y is
8522 in the line. We know this is the case if the already
8523 scanned glyphs make the line tall enough. Otherwise,
8524 we must check by scanning the rest of the line. */
8525 line_height = it->max_ascent + it->max_descent;
8526 if (to_y >= it->current_y
8527 && to_y < it->current_y + line_height)
8528 {
8529 reached = 6;
8530 break;
8531 }
8532 SAVE_IT (it_backup, *it, backup_data);
8533 TRACE_MOVE ((stderr, "move_it: from %d\n", IT_CHARPOS (*it)));
8534 skip2 = move_it_in_display_line_to (it, to_charpos, -1,
8535 op & MOVE_TO_POS);
8536 TRACE_MOVE ((stderr, "move_it: to %d\n", IT_CHARPOS (*it)));
8537 line_height = it->max_ascent + it->max_descent;
8538 TRACE_MOVE ((stderr, "move_it: line_height = %d\n", line_height));
8539
8540 if (to_y >= it->current_y
8541 && to_y < it->current_y + line_height)
8542 {
8543 /* If TO_Y is in this line and TO_X was reached
8544 above, we scanned too far. We have to restore
8545 IT's settings to the ones before skipping. */
8546 RESTORE_IT (it, &it_backup, backup_data);
8547 reached = 6;
8548 }
8549 else
8550 {
8551 skip = skip2;
8552 if (skip == MOVE_POS_MATCH_OR_ZV)
8553 reached = 7;
8554 }
8555 }
8556 else
8557 {
8558 /* Check whether TO_Y is in this line. */
8559 line_height = it->max_ascent + it->max_descent;
8560 TRACE_MOVE ((stderr, "move_it: line_height = %d\n", line_height));
8561
8562 if (to_y >= it->current_y
8563 && to_y < it->current_y + line_height)
8564 {
8565 /* When word-wrap is on, TO_X may lie past the end
8566 of a wrapped line. Then it->current is the
8567 character on the next line, so backtrack to the
8568 space before the wrap point. */
8569 if (skip == MOVE_LINE_CONTINUED
8570 && it->line_wrap == WORD_WRAP)
8571 {
8572 int prev_x = max (it->current_x - 1, 0);
8573 RESTORE_IT (it, &it_backup, backup_data);
8574 skip = move_it_in_display_line_to
8575 (it, -1, prev_x, MOVE_TO_X);
8576 }
8577 reached = 6;
8578 }
8579 }
8580
8581 if (reached)
8582 break;
8583 }
8584 else if (BUFFERP (it->object)
8585 && (it->method == GET_FROM_BUFFER
8586 || it->method == GET_FROM_STRETCH)
8587 && IT_CHARPOS (*it) >= to_charpos
8588 /* Under bidi iteration, a call to set_iterator_to_next
8589 can scan far beyond to_charpos if the initial
8590 portion of the next line needs to be reordered. In
8591 that case, give move_it_in_display_line_to another
8592 chance below. */
8593 && !(it->bidi_p
8594 && it->bidi_it.scan_dir == -1))
8595 skip = MOVE_POS_MATCH_OR_ZV;
8596 else
8597 skip = move_it_in_display_line_to (it, to_charpos, -1, MOVE_TO_POS);
8598
8599 switch (skip)
8600 {
8601 case MOVE_POS_MATCH_OR_ZV:
8602 reached = 8;
8603 goto out;
8604
8605 case MOVE_NEWLINE_OR_CR:
8606 set_iterator_to_next (it, 1);
8607 it->continuation_lines_width = 0;
8608 break;
8609
8610 case MOVE_LINE_TRUNCATED:
8611 it->continuation_lines_width = 0;
8612 reseat_at_next_visible_line_start (it, 0);
8613 if ((op & MOVE_TO_POS) != 0
8614 && IT_CHARPOS (*it) > to_charpos)
8615 {
8616 reached = 9;
8617 goto out;
8618 }
8619 break;
8620
8621 case MOVE_LINE_CONTINUED:
8622 /* For continued lines ending in a tab, some of the glyphs
8623 associated with the tab are displayed on the current
8624 line. Since it->current_x does not include these glyphs,
8625 we use it->last_visible_x instead. */
8626 if (it->c == '\t')
8627 {
8628 it->continuation_lines_width += it->last_visible_x;
8629 /* When moving by vpos, ensure that the iterator really
8630 advances to the next line (bug#847, bug#969). Fixme:
8631 do we need to do this in other circumstances? */
8632 if (it->current_x != it->last_visible_x
8633 && (op & MOVE_TO_VPOS)
8634 && !(op & (MOVE_TO_X | MOVE_TO_POS)))
8635 {
8636 line_start_x = it->current_x + it->pixel_width
8637 - it->last_visible_x;
8638 set_iterator_to_next (it, 0);
8639 }
8640 }
8641 else
8642 it->continuation_lines_width += it->current_x;
8643 break;
8644
8645 default:
8646 abort ();
8647 }
8648
8649 /* Reset/increment for the next run. */
8650 recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
8651 it->current_x = line_start_x;
8652 line_start_x = 0;
8653 it->hpos = 0;
8654 it->current_y += it->max_ascent + it->max_descent;
8655 ++it->vpos;
8656 last_height = it->max_ascent + it->max_descent;
8657 last_max_ascent = it->max_ascent;
8658 it->max_ascent = it->max_descent = 0;
8659 }
8660
8661 out:
8662
8663 /* On text terminals, we may stop at the end of a line in the middle
8664 of a multi-character glyph. If the glyph itself is continued,
8665 i.e. it is actually displayed on the next line, don't treat this
8666 stopping point as valid; move to the next line instead (unless
8667 that brings us offscreen). */
8668 if (!FRAME_WINDOW_P (it->f)
8669 && op & MOVE_TO_POS
8670 && IT_CHARPOS (*it) == to_charpos
8671 && it->what == IT_CHARACTER
8672 && it->nglyphs > 1
8673 && it->line_wrap == WINDOW_WRAP
8674 && it->current_x == it->last_visible_x - 1
8675 && it->c != '\n'
8676 && it->c != '\t'
8677 && it->vpos < XFASTINT (it->w->window_end_vpos))
8678 {
8679 it->continuation_lines_width += it->current_x;
8680 it->current_x = it->hpos = it->max_ascent = it->max_descent = 0;
8681 it->current_y += it->max_ascent + it->max_descent;
8682 ++it->vpos;
8683 last_height = it->max_ascent + it->max_descent;
8684 last_max_ascent = it->max_ascent;
8685 }
8686
8687 if (backup_data)
8688 bidi_unshelve_cache (backup_data, 1);
8689
8690 TRACE_MOVE ((stderr, "move_it_to: reached %d\n", reached));
8691 }
8692
8693
8694 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
8695
8696 If DY > 0, move IT backward at least that many pixels. DY = 0
8697 means move IT backward to the preceding line start or BEGV. This
8698 function may move over more than DY pixels if IT->current_y - DY
8699 ends up in the middle of a line; in this case IT->current_y will be
8700 set to the top of the line moved to. */
8701
8702 void
8703 move_it_vertically_backward (struct it *it, int dy)
8704 {
8705 int nlines, h;
8706 struct it it2, it3;
8707 void *it2data = NULL, *it3data = NULL;
8708 ptrdiff_t start_pos;
8709
8710 move_further_back:
8711 xassert (dy >= 0);
8712
8713 start_pos = IT_CHARPOS (*it);
8714
8715 /* Estimate how many newlines we must move back. */
8716 nlines = max (1, dy / FRAME_LINE_HEIGHT (it->f));
8717
8718 /* Set the iterator's position that many lines back. */
8719 while (nlines-- && IT_CHARPOS (*it) > BEGV)
8720 back_to_previous_visible_line_start (it);
8721
8722 /* Reseat the iterator here. When moving backward, we don't want
8723 reseat to skip forward over invisible text, set up the iterator
8724 to deliver from overlay strings at the new position etc. So,
8725 use reseat_1 here. */
8726 reseat_1 (it, it->current.pos, 1);
8727
8728 /* We are now surely at a line start. */
8729 it->current_x = it->hpos = 0; /* FIXME: this is incorrect when bidi
8730 reordering is in effect. */
8731 it->continuation_lines_width = 0;
8732
8733 /* Move forward and see what y-distance we moved. First move to the
8734 start of the next line so that we get its height. We need this
8735 height to be able to tell whether we reached the specified
8736 y-distance. */
8737 SAVE_IT (it2, *it, it2data);
8738 it2.max_ascent = it2.max_descent = 0;
8739 do
8740 {
8741 move_it_to (&it2, start_pos, -1, -1, it2.vpos + 1,
8742 MOVE_TO_POS | MOVE_TO_VPOS);
8743 }
8744 while (!(IT_POS_VALID_AFTER_MOVE_P (&it2)
8745 /* If we are in a display string which starts at START_POS,
8746 and that display string includes a newline, and we are
8747 right after that newline (i.e. at the beginning of a
8748 display line), exit the loop, because otherwise we will
8749 infloop, since move_it_to will see that it is already at
8750 START_POS and will not move. */
8751 || (it2.method == GET_FROM_STRING
8752 && IT_CHARPOS (it2) == start_pos
8753 && SREF (it2.string, IT_STRING_BYTEPOS (it2) - 1) == '\n')));
8754 xassert (IT_CHARPOS (*it) >= BEGV);
8755 SAVE_IT (it3, it2, it3data);
8756
8757 move_it_to (&it2, start_pos, -1, -1, -1, MOVE_TO_POS);
8758 xassert (IT_CHARPOS (*it) >= BEGV);
8759 /* H is the actual vertical distance from the position in *IT
8760 and the starting position. */
8761 h = it2.current_y - it->current_y;
8762 /* NLINES is the distance in number of lines. */
8763 nlines = it2.vpos - it->vpos;
8764
8765 /* Correct IT's y and vpos position
8766 so that they are relative to the starting point. */
8767 it->vpos -= nlines;
8768 it->current_y -= h;
8769
8770 if (dy == 0)
8771 {
8772 /* DY == 0 means move to the start of the screen line. The
8773 value of nlines is > 0 if continuation lines were involved,
8774 or if the original IT position was at start of a line. */
8775 RESTORE_IT (it, it, it2data);
8776 if (nlines > 0)
8777 move_it_by_lines (it, nlines);
8778 /* The above code moves us to some position NLINES down,
8779 usually to its first glyph (leftmost in an L2R line), but
8780 that's not necessarily the start of the line, under bidi
8781 reordering. We want to get to the character position
8782 that is immediately after the newline of the previous
8783 line. */
8784 if (it->bidi_p
8785 && !it->continuation_lines_width
8786 && !STRINGP (it->string)
8787 && IT_CHARPOS (*it) > BEGV
8788 && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
8789 {
8790 ptrdiff_t nl_pos =
8791 find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1);
8792
8793 move_it_to (it, nl_pos, -1, -1, -1, MOVE_TO_POS);
8794 }
8795 bidi_unshelve_cache (it3data, 1);
8796 }
8797 else
8798 {
8799 /* The y-position we try to reach, relative to *IT.
8800 Note that H has been subtracted in front of the if-statement. */
8801 int target_y = it->current_y + h - dy;
8802 int y0 = it3.current_y;
8803 int y1;
8804 int line_height;
8805
8806 RESTORE_IT (&it3, &it3, it3data);
8807 y1 = line_bottom_y (&it3);
8808 line_height = y1 - y0;
8809 RESTORE_IT (it, it, it2data);
8810 /* If we did not reach target_y, try to move further backward if
8811 we can. If we moved too far backward, try to move forward. */
8812 if (target_y < it->current_y
8813 /* This is heuristic. In a window that's 3 lines high, with
8814 a line height of 13 pixels each, recentering with point
8815 on the bottom line will try to move -39/2 = 19 pixels
8816 backward. Try to avoid moving into the first line. */
8817 && (it->current_y - target_y
8818 > min (window_box_height (it->w), line_height * 2 / 3))
8819 && IT_CHARPOS (*it) > BEGV)
8820 {
8821 TRACE_MOVE ((stderr, " not far enough -> move_vert %d\n",
8822 target_y - it->current_y));
8823 dy = it->current_y - target_y;
8824 goto move_further_back;
8825 }
8826 else if (target_y >= it->current_y + line_height
8827 && IT_CHARPOS (*it) < ZV)
8828 {
8829 /* Should move forward by at least one line, maybe more.
8830
8831 Note: Calling move_it_by_lines can be expensive on
8832 terminal frames, where compute_motion is used (via
8833 vmotion) to do the job, when there are very long lines
8834 and truncate-lines is nil. That's the reason for
8835 treating terminal frames specially here. */
8836
8837 if (!FRAME_WINDOW_P (it->f))
8838 move_it_vertically (it, target_y - (it->current_y + line_height));
8839 else
8840 {
8841 do
8842 {
8843 move_it_by_lines (it, 1);
8844 }
8845 while (target_y >= line_bottom_y (it) && IT_CHARPOS (*it) < ZV);
8846 }
8847 }
8848 }
8849 }
8850
8851
8852 /* Move IT by a specified amount of pixel lines DY. DY negative means
8853 move backwards. DY = 0 means move to start of screen line. At the
8854 end, IT will be on the start of a screen line. */
8855
8856 void
8857 move_it_vertically (struct it *it, int dy)
8858 {
8859 if (dy <= 0)
8860 move_it_vertically_backward (it, -dy);
8861 else
8862 {
8863 TRACE_MOVE ((stderr, "move_it_v: from %d, %d\n", IT_CHARPOS (*it), dy));
8864 move_it_to (it, ZV, -1, it->current_y + dy, -1,
8865 MOVE_TO_POS | MOVE_TO_Y);
8866 TRACE_MOVE ((stderr, "move_it_v: to %d\n", IT_CHARPOS (*it)));
8867
8868 /* If buffer ends in ZV without a newline, move to the start of
8869 the line to satisfy the post-condition. */
8870 if (IT_CHARPOS (*it) == ZV
8871 && ZV > BEGV
8872 && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
8873 move_it_by_lines (it, 0);
8874 }
8875 }
8876
8877
8878 /* Move iterator IT past the end of the text line it is in. */
8879
8880 void
8881 move_it_past_eol (struct it *it)
8882 {
8883 enum move_it_result rc;
8884
8885 rc = move_it_in_display_line_to (it, Z, 0, MOVE_TO_POS);
8886 if (rc == MOVE_NEWLINE_OR_CR)
8887 set_iterator_to_next (it, 0);
8888 }
8889
8890
8891 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
8892 negative means move up. DVPOS == 0 means move to the start of the
8893 screen line.
8894
8895 Optimization idea: If we would know that IT->f doesn't use
8896 a face with proportional font, we could be faster for
8897 truncate-lines nil. */
8898
8899 void
8900 move_it_by_lines (struct it *it, ptrdiff_t dvpos)
8901 {
8902
8903 /* The commented-out optimization uses vmotion on terminals. This
8904 gives bad results, because elements like it->what, on which
8905 callers such as pos_visible_p rely, aren't updated. */
8906 /* struct position pos;
8907 if (!FRAME_WINDOW_P (it->f))
8908 {
8909 struct text_pos textpos;
8910
8911 pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
8912 SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
8913 reseat (it, textpos, 1);
8914 it->vpos += pos.vpos;
8915 it->current_y += pos.vpos;
8916 }
8917 else */
8918
8919 if (dvpos == 0)
8920 {
8921 /* DVPOS == 0 means move to the start of the screen line. */
8922 move_it_vertically_backward (it, 0);
8923 xassert (it->current_x == 0 && it->hpos == 0);
8924 /* Let next call to line_bottom_y calculate real line height */
8925 last_height = 0;
8926 }
8927 else if (dvpos > 0)
8928 {
8929 move_it_to (it, -1, -1, -1, it->vpos + dvpos, MOVE_TO_VPOS);
8930 if (!IT_POS_VALID_AFTER_MOVE_P (it))
8931 move_it_to (it, IT_CHARPOS (*it) + 1, -1, -1, -1, MOVE_TO_POS);
8932 }
8933 else
8934 {
8935 struct it it2;
8936 void *it2data = NULL;
8937 ptrdiff_t start_charpos, i;
8938
8939 /* Start at the beginning of the screen line containing IT's
8940 position. This may actually move vertically backwards,
8941 in case of overlays, so adjust dvpos accordingly. */
8942 dvpos += it->vpos;
8943 move_it_vertically_backward (it, 0);
8944 dvpos -= it->vpos;
8945
8946 /* Go back -DVPOS visible lines and reseat the iterator there. */
8947 start_charpos = IT_CHARPOS (*it);
8948 for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > BEGV; --i)
8949 back_to_previous_visible_line_start (it);
8950 reseat (it, it->current.pos, 1);
8951
8952 /* Move further back if we end up in a string or an image. */
8953 while (!IT_POS_VALID_AFTER_MOVE_P (it))
8954 {
8955 /* First try to move to start of display line. */
8956 dvpos += it->vpos;
8957 move_it_vertically_backward (it, 0);
8958 dvpos -= it->vpos;
8959 if (IT_POS_VALID_AFTER_MOVE_P (it))
8960 break;
8961 /* If start of line is still in string or image,
8962 move further back. */
8963 back_to_previous_visible_line_start (it);
8964 reseat (it, it->current.pos, 1);
8965 dvpos--;
8966 }
8967
8968 it->current_x = it->hpos = 0;
8969
8970 /* Above call may have moved too far if continuation lines
8971 are involved. Scan forward and see if it did. */
8972 SAVE_IT (it2, *it, it2data);
8973 it2.vpos = it2.current_y = 0;
8974 move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
8975 it->vpos -= it2.vpos;
8976 it->current_y -= it2.current_y;
8977 it->current_x = it->hpos = 0;
8978
8979 /* If we moved too far back, move IT some lines forward. */
8980 if (it2.vpos > -dvpos)
8981 {
8982 int delta = it2.vpos + dvpos;
8983
8984 RESTORE_IT (&it2, &it2, it2data);
8985 SAVE_IT (it2, *it, it2data);
8986 move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
8987 /* Move back again if we got too far ahead. */
8988 if (IT_CHARPOS (*it) >= start_charpos)
8989 RESTORE_IT (it, &it2, it2data);
8990 else
8991 bidi_unshelve_cache (it2data, 1);
8992 }
8993 else
8994 RESTORE_IT (it, it, it2data);
8995 }
8996 }
8997
8998 /* Return 1 if IT points into the middle of a display vector. */
8999
9000 int
9001 in_display_vector_p (struct it *it)
9002 {
9003 return (it->method == GET_FROM_DISPLAY_VECTOR
9004 && it->current.dpvec_index > 0
9005 && it->dpvec + it->current.dpvec_index != it->dpend);
9006 }
9007
9008 \f
9009 /***********************************************************************
9010 Messages
9011 ***********************************************************************/
9012
9013
9014 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
9015 to *Messages*. */
9016
9017 void
9018 add_to_log (const char *format, Lisp_Object arg1, Lisp_Object arg2)
9019 {
9020 Lisp_Object args[3];
9021 Lisp_Object msg, fmt;
9022 char *buffer;
9023 ptrdiff_t len;
9024 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
9025 USE_SAFE_ALLOCA;
9026
9027 /* Do nothing if called asynchronously. Inserting text into
9028 a buffer may call after-change-functions and alike and
9029 that would means running Lisp asynchronously. */
9030 if (handling_signal)
9031 return;
9032
9033 fmt = msg = Qnil;
9034 GCPRO4 (fmt, msg, arg1, arg2);
9035
9036 args[0] = fmt = build_string (format);
9037 args[1] = arg1;
9038 args[2] = arg2;
9039 msg = Fformat (3, args);
9040
9041 len = SBYTES (msg) + 1;
9042 SAFE_ALLOCA (buffer, char *, len);
9043 memcpy (buffer, SDATA (msg), len);
9044
9045 message_dolog (buffer, len - 1, 1, 0);
9046 SAFE_FREE ();
9047
9048 UNGCPRO;
9049 }
9050
9051
9052 /* Output a newline in the *Messages* buffer if "needs" one. */
9053
9054 void
9055 message_log_maybe_newline (void)
9056 {
9057 if (message_log_need_newline)
9058 message_dolog ("", 0, 1, 0);
9059 }
9060
9061
9062 /* Add a string M of length NBYTES to the message log, optionally
9063 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
9064 nonzero, means interpret the contents of M as multibyte. This
9065 function calls low-level routines in order to bypass text property
9066 hooks, etc. which might not be safe to run.
9067
9068 This may GC (insert may run before/after change hooks),
9069 so the buffer M must NOT point to a Lisp string. */
9070
9071 void
9072 message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
9073 {
9074 const unsigned char *msg = (const unsigned char *) m;
9075
9076 if (!NILP (Vmemory_full))
9077 return;
9078
9079 if (!NILP (Vmessage_log_max))
9080 {
9081 struct buffer *oldbuf;
9082 Lisp_Object oldpoint, oldbegv, oldzv;
9083 int old_windows_or_buffers_changed = windows_or_buffers_changed;
9084 ptrdiff_t point_at_end = 0;
9085 ptrdiff_t zv_at_end = 0;
9086 Lisp_Object old_deactivate_mark, tem;
9087 struct gcpro gcpro1;
9088
9089 old_deactivate_mark = Vdeactivate_mark;
9090 oldbuf = current_buffer;
9091 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name));
9092 BVAR (current_buffer, undo_list) = Qt;
9093
9094 oldpoint = message_dolog_marker1;
9095 set_marker_restricted (oldpoint, make_number (PT), Qnil);
9096 oldbegv = message_dolog_marker2;
9097 set_marker_restricted (oldbegv, make_number (BEGV), Qnil);
9098 oldzv = message_dolog_marker3;
9099 set_marker_restricted (oldzv, make_number (ZV), Qnil);
9100 GCPRO1 (old_deactivate_mark);
9101
9102 if (PT == Z)
9103 point_at_end = 1;
9104 if (ZV == Z)
9105 zv_at_end = 1;
9106
9107 BEGV = BEG;
9108 BEGV_BYTE = BEG_BYTE;
9109 ZV = Z;
9110 ZV_BYTE = Z_BYTE;
9111 TEMP_SET_PT_BOTH (Z, Z_BYTE);
9112
9113 /* Insert the string--maybe converting multibyte to single byte
9114 or vice versa, so that all the text fits the buffer. */
9115 if (multibyte
9116 && NILP (BVAR (current_buffer, enable_multibyte_characters)))
9117 {
9118 ptrdiff_t i;
9119 int c, char_bytes;
9120 char work[1];
9121
9122 /* Convert a multibyte string to single-byte
9123 for the *Message* buffer. */
9124 for (i = 0; i < nbytes; i += char_bytes)
9125 {
9126 c = string_char_and_length (msg + i, &char_bytes);
9127 work[0] = (ASCII_CHAR_P (c)
9128 ? c
9129 : multibyte_char_to_unibyte (c));
9130 insert_1_both (work, 1, 1, 1, 0, 0);
9131 }
9132 }
9133 else if (! multibyte
9134 && ! NILP (BVAR (current_buffer, enable_multibyte_characters)))
9135 {
9136 ptrdiff_t i;
9137 int c, char_bytes;
9138 unsigned char str[MAX_MULTIBYTE_LENGTH];
9139 /* Convert a single-byte string to multibyte
9140 for the *Message* buffer. */
9141 for (i = 0; i < nbytes; i++)
9142 {
9143 c = msg[i];
9144 MAKE_CHAR_MULTIBYTE (c);
9145 char_bytes = CHAR_STRING (c, str);
9146 insert_1_both ((char *) str, 1, char_bytes, 1, 0, 0);
9147 }
9148 }
9149 else if (nbytes)
9150 insert_1 (m, nbytes, 1, 0, 0);
9151
9152 if (nlflag)
9153 {
9154 ptrdiff_t this_bol, this_bol_byte, prev_bol, prev_bol_byte;
9155 printmax_t dups;
9156 insert_1 ("\n", 1, 1, 0, 0);
9157
9158 scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, 0);
9159 this_bol = PT;
9160 this_bol_byte = PT_BYTE;
9161
9162 /* See if this line duplicates the previous one.
9163 If so, combine duplicates. */
9164 if (this_bol > BEG)
9165 {
9166 scan_newline (PT, PT_BYTE, BEG, BEG_BYTE, -2, 0);
9167 prev_bol = PT;
9168 prev_bol_byte = PT_BYTE;
9169
9170 dups = message_log_check_duplicate (prev_bol_byte,
9171 this_bol_byte);
9172 if (dups)
9173 {
9174 del_range_both (prev_bol, prev_bol_byte,
9175 this_bol, this_bol_byte, 0);
9176 if (dups > 1)
9177 {
9178 char dupstr[sizeof " [ times]"
9179 + INT_STRLEN_BOUND (printmax_t)];
9180 int duplen;
9181
9182 /* If you change this format, don't forget to also
9183 change message_log_check_duplicate. */
9184 sprintf (dupstr, " [%"pMd" times]", dups);
9185 duplen = strlen (dupstr);
9186 TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
9187 insert_1 (dupstr, duplen, 1, 0, 1);
9188 }
9189 }
9190 }
9191
9192 /* If we have more than the desired maximum number of lines
9193 in the *Messages* buffer now, delete the oldest ones.
9194 This is safe because we don't have undo in this buffer. */
9195
9196 if (NATNUMP (Vmessage_log_max))
9197 {
9198 scan_newline (Z, Z_BYTE, BEG, BEG_BYTE,
9199 -XFASTINT (Vmessage_log_max) - 1, 0);
9200 del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, 0);
9201 }
9202 }
9203 BEGV = XMARKER (oldbegv)->charpos;
9204 BEGV_BYTE = marker_byte_position (oldbegv);
9205
9206 if (zv_at_end)
9207 {
9208 ZV = Z;
9209 ZV_BYTE = Z_BYTE;
9210 }
9211 else
9212 {
9213 ZV = XMARKER (oldzv)->charpos;
9214 ZV_BYTE = marker_byte_position (oldzv);
9215 }
9216
9217 if (point_at_end)
9218 TEMP_SET_PT_BOTH (Z, Z_BYTE);
9219 else
9220 /* We can't do Fgoto_char (oldpoint) because it will run some
9221 Lisp code. */
9222 TEMP_SET_PT_BOTH (XMARKER (oldpoint)->charpos,
9223 XMARKER (oldpoint)->bytepos);
9224
9225 UNGCPRO;
9226 unchain_marker (XMARKER (oldpoint));
9227 unchain_marker (XMARKER (oldbegv));
9228 unchain_marker (XMARKER (oldzv));
9229
9230 tem = Fget_buffer_window (Fcurrent_buffer (), Qt);
9231 set_buffer_internal (oldbuf);
9232 if (NILP (tem))
9233 windows_or_buffers_changed = old_windows_or_buffers_changed;
9234 message_log_need_newline = !nlflag;
9235 Vdeactivate_mark = old_deactivate_mark;
9236 }
9237 }
9238
9239
9240 /* We are at the end of the buffer after just having inserted a newline.
9241 (Note: We depend on the fact we won't be crossing the gap.)
9242 Check to see if the most recent message looks a lot like the previous one.
9243 Return 0 if different, 1 if the new one should just replace it, or a
9244 value N > 1 if we should also append " [N times]". */
9245
9246 static intmax_t
9247 message_log_check_duplicate (ptrdiff_t prev_bol_byte, ptrdiff_t this_bol_byte)
9248 {
9249 ptrdiff_t i;
9250 ptrdiff_t len = Z_BYTE - 1 - this_bol_byte;
9251 int seen_dots = 0;
9252 unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte);
9253 unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte);
9254
9255 for (i = 0; i < len; i++)
9256 {
9257 if (i >= 3 && p1[i-3] == '.' && p1[i-2] == '.' && p1[i-1] == '.')
9258 seen_dots = 1;
9259 if (p1[i] != p2[i])
9260 return seen_dots;
9261 }
9262 p1 += len;
9263 if (*p1 == '\n')
9264 return 2;
9265 if (*p1++ == ' ' && *p1++ == '[')
9266 {
9267 char *pend;
9268 intmax_t n = strtoimax ((char *) p1, &pend, 10);
9269 if (0 < n && n < INTMAX_MAX && strncmp (pend, " times]\n", 8) == 0)
9270 return n+1;
9271 }
9272 return 0;
9273 }
9274 \f
9275
9276 /* Display an echo area message M with a specified length of NBYTES
9277 bytes. The string may include null characters. If M is 0, clear
9278 out any existing message, and let the mini-buffer text show
9279 through.
9280
9281 This may GC, so the buffer M must NOT point to a Lisp string. */
9282
9283 void
9284 message2 (const char *m, ptrdiff_t nbytes, int multibyte)
9285 {
9286 /* First flush out any partial line written with print. */
9287 message_log_maybe_newline ();
9288 if (m)
9289 message_dolog (m, nbytes, 1, multibyte);
9290 message2_nolog (m, nbytes, multibyte);
9291 }
9292
9293
9294 /* The non-logging counterpart of message2. */
9295
9296 void
9297 message2_nolog (const char *m, ptrdiff_t nbytes, int multibyte)
9298 {
9299 struct frame *sf = SELECTED_FRAME ();
9300 message_enable_multibyte = multibyte;
9301
9302 if (FRAME_INITIAL_P (sf))
9303 {
9304 if (noninteractive_need_newline)
9305 putc ('\n', stderr);
9306 noninteractive_need_newline = 0;
9307 if (m)
9308 fwrite (m, nbytes, 1, stderr);
9309 if (cursor_in_echo_area == 0)
9310 fprintf (stderr, "\n");
9311 fflush (stderr);
9312 }
9313 /* A null message buffer means that the frame hasn't really been
9314 initialized yet. Error messages get reported properly by
9315 cmd_error, so this must be just an informative message; toss it. */
9316 else if (INTERACTIVE
9317 && sf->glyphs_initialized_p
9318 && FRAME_MESSAGE_BUF (sf))
9319 {
9320 Lisp_Object mini_window;
9321 struct frame *f;
9322
9323 /* Get the frame containing the mini-buffer
9324 that the selected frame is using. */
9325 mini_window = FRAME_MINIBUF_WINDOW (sf);
9326 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
9327
9328 FRAME_SAMPLE_VISIBILITY (f);
9329 if (FRAME_VISIBLE_P (sf)
9330 && ! FRAME_VISIBLE_P (f))
9331 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window)));
9332
9333 if (m)
9334 {
9335 set_message (m, Qnil, nbytes, multibyte);
9336 if (minibuffer_auto_raise)
9337 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
9338 }
9339 else
9340 clear_message (1, 1);
9341
9342 do_pending_window_change (0);
9343 echo_area_display (1);
9344 do_pending_window_change (0);
9345 if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
9346 (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
9347 }
9348 }
9349
9350
9351 /* Display an echo area message M with a specified length of NBYTES
9352 bytes. The string may include null characters. If M is not a
9353 string, clear out any existing message, and let the mini-buffer
9354 text show through.
9355
9356 This function cancels echoing. */
9357
9358 void
9359 message3 (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
9360 {
9361 struct gcpro gcpro1;
9362
9363 GCPRO1 (m);
9364 clear_message (1,1);
9365 cancel_echoing ();
9366
9367 /* First flush out any partial line written with print. */
9368 message_log_maybe_newline ();
9369 if (STRINGP (m))
9370 {
9371 char *buffer;
9372 USE_SAFE_ALLOCA;
9373
9374 SAFE_ALLOCA (buffer, char *, nbytes);
9375 memcpy (buffer, SDATA (m), nbytes);
9376 message_dolog (buffer, nbytes, 1, multibyte);
9377 SAFE_FREE ();
9378 }
9379 message3_nolog (m, nbytes, multibyte);
9380
9381 UNGCPRO;
9382 }
9383
9384
9385 /* The non-logging version of message3.
9386 This does not cancel echoing, because it is used for echoing.
9387 Perhaps we need to make a separate function for echoing
9388 and make this cancel echoing. */
9389
9390 void
9391 message3_nolog (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
9392 {
9393 struct frame *sf = SELECTED_FRAME ();
9394 message_enable_multibyte = multibyte;
9395
9396 if (FRAME_INITIAL_P (sf))
9397 {
9398 if (noninteractive_need_newline)
9399 putc ('\n', stderr);
9400 noninteractive_need_newline = 0;
9401 if (STRINGP (m))
9402 fwrite (SDATA (m), nbytes, 1, stderr);
9403 if (cursor_in_echo_area == 0)
9404 fprintf (stderr, "\n");
9405 fflush (stderr);
9406 }
9407 /* A null message buffer means that the frame hasn't really been
9408 initialized yet. Error messages get reported properly by
9409 cmd_error, so this must be just an informative message; toss it. */
9410 else if (INTERACTIVE
9411 && sf->glyphs_initialized_p
9412 && FRAME_MESSAGE_BUF (sf))
9413 {
9414 Lisp_Object mini_window;
9415 Lisp_Object frame;
9416 struct frame *f;
9417
9418 /* Get the frame containing the mini-buffer
9419 that the selected frame is using. */
9420 mini_window = FRAME_MINIBUF_WINDOW (sf);
9421 frame = XWINDOW (mini_window)->frame;
9422 f = XFRAME (frame);
9423
9424 FRAME_SAMPLE_VISIBILITY (f);
9425 if (FRAME_VISIBLE_P (sf)
9426 && !FRAME_VISIBLE_P (f))
9427 Fmake_frame_visible (frame);
9428
9429 if (STRINGP (m) && SCHARS (m) > 0)
9430 {
9431 set_message (NULL, m, nbytes, multibyte);
9432 if (minibuffer_auto_raise)
9433 Fraise_frame (frame);
9434 /* Assume we are not echoing.
9435 (If we are, echo_now will override this.) */
9436 echo_message_buffer = Qnil;
9437 }
9438 else
9439 clear_message (1, 1);
9440
9441 do_pending_window_change (0);
9442 echo_area_display (1);
9443 do_pending_window_change (0);
9444 if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
9445 (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
9446 }
9447 }
9448
9449
9450 /* Display a null-terminated echo area message M. If M is 0, clear
9451 out any existing message, and let the mini-buffer text show through.
9452
9453 The buffer M must continue to exist until after the echo area gets
9454 cleared or some other message gets displayed there. Do not pass
9455 text that is stored in a Lisp string. Do not pass text in a buffer
9456 that was alloca'd. */
9457
9458 void
9459 message1 (const char *m)
9460 {
9461 message2 (m, (m ? strlen (m) : 0), 0);
9462 }
9463
9464
9465 /* The non-logging counterpart of message1. */
9466
9467 void
9468 message1_nolog (const char *m)
9469 {
9470 message2_nolog (m, (m ? strlen (m) : 0), 0);
9471 }
9472
9473 /* Display a message M which contains a single %s
9474 which gets replaced with STRING. */
9475
9476 void
9477 message_with_string (const char *m, Lisp_Object string, int log)
9478 {
9479 CHECK_STRING (string);
9480
9481 if (noninteractive)
9482 {
9483 if (m)
9484 {
9485 if (noninteractive_need_newline)
9486 putc ('\n', stderr);
9487 noninteractive_need_newline = 0;
9488 fprintf (stderr, m, SDATA (string));
9489 if (!cursor_in_echo_area)
9490 fprintf (stderr, "\n");
9491 fflush (stderr);
9492 }
9493 }
9494 else if (INTERACTIVE)
9495 {
9496 /* The frame whose minibuffer we're going to display the message on.
9497 It may be larger than the selected frame, so we need
9498 to use its buffer, not the selected frame's buffer. */
9499 Lisp_Object mini_window;
9500 struct frame *f, *sf = SELECTED_FRAME ();
9501
9502 /* Get the frame containing the minibuffer
9503 that the selected frame is using. */
9504 mini_window = FRAME_MINIBUF_WINDOW (sf);
9505 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
9506
9507 /* A null message buffer means that the frame hasn't really been
9508 initialized yet. Error messages get reported properly by
9509 cmd_error, so this must be just an informative message; toss it. */
9510 if (FRAME_MESSAGE_BUF (f))
9511 {
9512 Lisp_Object args[2], msg;
9513 struct gcpro gcpro1, gcpro2;
9514
9515 args[0] = build_string (m);
9516 args[1] = msg = string;
9517 GCPRO2 (args[0], msg);
9518 gcpro1.nvars = 2;
9519
9520 msg = Fformat (2, args);
9521
9522 if (log)
9523 message3 (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
9524 else
9525 message3_nolog (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
9526
9527 UNGCPRO;
9528
9529 /* Print should start at the beginning of the message
9530 buffer next time. */
9531 message_buf_print = 0;
9532 }
9533 }
9534 }
9535
9536
9537 /* Dump an informative message to the minibuf. If M is 0, clear out
9538 any existing message, and let the mini-buffer text show through. */
9539
9540 static void
9541 vmessage (const char *m, va_list ap)
9542 {
9543 if (noninteractive)
9544 {
9545 if (m)
9546 {
9547 if (noninteractive_need_newline)
9548 putc ('\n', stderr);
9549 noninteractive_need_newline = 0;
9550 vfprintf (stderr, m, ap);
9551 if (cursor_in_echo_area == 0)
9552 fprintf (stderr, "\n");
9553 fflush (stderr);
9554 }
9555 }
9556 else if (INTERACTIVE)
9557 {
9558 /* The frame whose mini-buffer we're going to display the message
9559 on. It may be larger than the selected frame, so we need to
9560 use its buffer, not the selected frame's buffer. */
9561 Lisp_Object mini_window;
9562 struct frame *f, *sf = SELECTED_FRAME ();
9563
9564 /* Get the frame containing the mini-buffer
9565 that the selected frame is using. */
9566 mini_window = FRAME_MINIBUF_WINDOW (sf);
9567 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
9568
9569 /* A null message buffer means that the frame hasn't really been
9570 initialized yet. Error messages get reported properly by
9571 cmd_error, so this must be just an informative message; toss
9572 it. */
9573 if (FRAME_MESSAGE_BUF (f))
9574 {
9575 if (m)
9576 {
9577 ptrdiff_t len;
9578
9579 len = doprnt (FRAME_MESSAGE_BUF (f),
9580 FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, ap);
9581
9582 message2 (FRAME_MESSAGE_BUF (f), len, 0);
9583 }
9584 else
9585 message1 (0);
9586
9587 /* Print should start at the beginning of the message
9588 buffer next time. */
9589 message_buf_print = 0;
9590 }
9591 }
9592 }
9593
9594 void
9595 message (const char *m, ...)
9596 {
9597 va_list ap;
9598 va_start (ap, m);
9599 vmessage (m, ap);
9600 va_end (ap);
9601 }
9602
9603
9604 #if 0
9605 /* The non-logging version of message. */
9606
9607 void
9608 message_nolog (const char *m, ...)
9609 {
9610 Lisp_Object old_log_max;
9611 va_list ap;
9612 va_start (ap, m);
9613 old_log_max = Vmessage_log_max;
9614 Vmessage_log_max = Qnil;
9615 vmessage (m, ap);
9616 Vmessage_log_max = old_log_max;
9617 va_end (ap);
9618 }
9619 #endif
9620
9621
9622 /* Display the current message in the current mini-buffer. This is
9623 only called from error handlers in process.c, and is not time
9624 critical. */
9625
9626 void
9627 update_echo_area (void)
9628 {
9629 if (!NILP (echo_area_buffer[0]))
9630 {
9631 Lisp_Object string;
9632 string = Fcurrent_message ();
9633 message3 (string, SBYTES (string),
9634 !NILP (BVAR (current_buffer, enable_multibyte_characters)));
9635 }
9636 }
9637
9638
9639 /* Make sure echo area buffers in `echo_buffers' are live.
9640 If they aren't, make new ones. */
9641
9642 static void
9643 ensure_echo_area_buffers (void)
9644 {
9645 int i;
9646
9647 for (i = 0; i < 2; ++i)
9648 if (!BUFFERP (echo_buffer[i])
9649 || NILP (BVAR (XBUFFER (echo_buffer[i]), name)))
9650 {
9651 char name[30];
9652 Lisp_Object old_buffer;
9653 int j;
9654
9655 old_buffer = echo_buffer[i];
9656 sprintf (name, " *Echo Area %d*", i);
9657 echo_buffer[i] = Fget_buffer_create (build_string (name));
9658 BVAR (XBUFFER (echo_buffer[i]), truncate_lines) = Qnil;
9659 /* to force word wrap in echo area -
9660 it was decided to postpone this*/
9661 /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
9662
9663 for (j = 0; j < 2; ++j)
9664 if (EQ (old_buffer, echo_area_buffer[j]))
9665 echo_area_buffer[j] = echo_buffer[i];
9666 }
9667 }
9668
9669
9670 /* Call FN with args A1..A4 with either the current or last displayed
9671 echo_area_buffer as current buffer.
9672
9673 WHICH zero means use the current message buffer
9674 echo_area_buffer[0]. If that is nil, choose a suitable buffer
9675 from echo_buffer[] and clear it.
9676
9677 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
9678 suitable buffer from echo_buffer[] and clear it.
9679
9680 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
9681 that the current message becomes the last displayed one, make
9682 choose a suitable buffer for echo_area_buffer[0], and clear it.
9683
9684 Value is what FN returns. */
9685
9686 static int
9687 with_echo_area_buffer (struct window *w, int which,
9688 int (*fn) (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t),
9689 ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4)
9690 {
9691 Lisp_Object buffer;
9692 int this_one, the_other, clear_buffer_p, rc;
9693 ptrdiff_t count = SPECPDL_INDEX ();
9694
9695 /* If buffers aren't live, make new ones. */
9696 ensure_echo_area_buffers ();
9697
9698 clear_buffer_p = 0;
9699
9700 if (which == 0)
9701 this_one = 0, the_other = 1;
9702 else if (which > 0)
9703 this_one = 1, the_other = 0;
9704 else
9705 {
9706 this_one = 0, the_other = 1;
9707 clear_buffer_p = 1;
9708
9709 /* We need a fresh one in case the current echo buffer equals
9710 the one containing the last displayed echo area message. */
9711 if (!NILP (echo_area_buffer[this_one])
9712 && EQ (echo_area_buffer[this_one], echo_area_buffer[the_other]))
9713 echo_area_buffer[this_one] = Qnil;
9714 }
9715
9716 /* Choose a suitable buffer from echo_buffer[] is we don't
9717 have one. */
9718 if (NILP (echo_area_buffer[this_one]))
9719 {
9720 echo_area_buffer[this_one]
9721 = (EQ (echo_area_buffer[the_other], echo_buffer[this_one])
9722 ? echo_buffer[the_other]
9723 : echo_buffer[this_one]);
9724 clear_buffer_p = 1;
9725 }
9726
9727 buffer = echo_area_buffer[this_one];
9728
9729 /* Don't get confused by reusing the buffer used for echoing
9730 for a different purpose. */
9731 if (echo_kboard == NULL && EQ (buffer, echo_message_buffer))
9732 cancel_echoing ();
9733
9734 record_unwind_protect (unwind_with_echo_area_buffer,
9735 with_echo_area_buffer_unwind_data (w));
9736
9737 /* Make the echo area buffer current. Note that for display
9738 purposes, it is not necessary that the displayed window's buffer
9739 == current_buffer, except for text property lookup. So, let's
9740 only set that buffer temporarily here without doing a full
9741 Fset_window_buffer. We must also change w->pointm, though,
9742 because otherwise an assertions in unshow_buffer fails, and Emacs
9743 aborts. */
9744 set_buffer_internal_1 (XBUFFER (buffer));
9745 if (w)
9746 {
9747 w->buffer = buffer;
9748 set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
9749 }
9750
9751 BVAR (current_buffer, undo_list) = Qt;
9752 BVAR (current_buffer, read_only) = Qnil;
9753 specbind (Qinhibit_read_only, Qt);
9754 specbind (Qinhibit_modification_hooks, Qt);
9755
9756 if (clear_buffer_p && Z > BEG)
9757 del_range (BEG, Z);
9758
9759 xassert (BEGV >= BEG);
9760 xassert (ZV <= Z && ZV >= BEGV);
9761
9762 rc = fn (a1, a2, a3, a4);
9763
9764 xassert (BEGV >= BEG);
9765 xassert (ZV <= Z && ZV >= BEGV);
9766
9767 unbind_to (count, Qnil);
9768 return rc;
9769 }
9770
9771
9772 /* Save state that should be preserved around the call to the function
9773 FN called in with_echo_area_buffer. */
9774
9775 static Lisp_Object
9776 with_echo_area_buffer_unwind_data (struct window *w)
9777 {
9778 int i = 0;
9779 Lisp_Object vector, tmp;
9780
9781 /* Reduce consing by keeping one vector in
9782 Vwith_echo_area_save_vector. */
9783 vector = Vwith_echo_area_save_vector;
9784 Vwith_echo_area_save_vector = Qnil;
9785
9786 if (NILP (vector))
9787 vector = Fmake_vector (make_number (7), Qnil);
9788
9789 XSETBUFFER (tmp, current_buffer); ASET (vector, i, tmp); ++i;
9790 ASET (vector, i, Vdeactivate_mark); ++i;
9791 ASET (vector, i, make_number (windows_or_buffers_changed)); ++i;
9792
9793 if (w)
9794 {
9795 XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
9796 ASET (vector, i, w->buffer); ++i;
9797 ASET (vector, i, make_number (XMARKER (w->pointm)->charpos)); ++i;
9798 ASET (vector, i, make_number (XMARKER (w->pointm)->bytepos)); ++i;
9799 }
9800 else
9801 {
9802 int end = i + 4;
9803 for (; i < end; ++i)
9804 ASET (vector, i, Qnil);
9805 }
9806
9807 xassert (i == ASIZE (vector));
9808 return vector;
9809 }
9810
9811
9812 /* Restore global state from VECTOR which was created by
9813 with_echo_area_buffer_unwind_data. */
9814
9815 static Lisp_Object
9816 unwind_with_echo_area_buffer (Lisp_Object vector)
9817 {
9818 set_buffer_internal_1 (XBUFFER (AREF (vector, 0)));
9819 Vdeactivate_mark = AREF (vector, 1);
9820 windows_or_buffers_changed = XFASTINT (AREF (vector, 2));
9821
9822 if (WINDOWP (AREF (vector, 3)))
9823 {
9824 struct window *w;
9825 Lisp_Object buffer, charpos, bytepos;
9826
9827 w = XWINDOW (AREF (vector, 3));
9828 buffer = AREF (vector, 4);
9829 charpos = AREF (vector, 5);
9830 bytepos = AREF (vector, 6);
9831
9832 w->buffer = buffer;
9833 set_marker_both (w->pointm, buffer,
9834 XFASTINT (charpos), XFASTINT (bytepos));
9835 }
9836
9837 Vwith_echo_area_save_vector = vector;
9838 return Qnil;
9839 }
9840
9841
9842 /* Set up the echo area for use by print functions. MULTIBYTE_P
9843 non-zero means we will print multibyte. */
9844
9845 void
9846 setup_echo_area_for_printing (int multibyte_p)
9847 {
9848 /* If we can't find an echo area any more, exit. */
9849 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
9850 Fkill_emacs (Qnil);
9851
9852 ensure_echo_area_buffers ();
9853
9854 if (!message_buf_print)
9855 {
9856 /* A message has been output since the last time we printed.
9857 Choose a fresh echo area buffer. */
9858 if (EQ (echo_area_buffer[1], echo_buffer[0]))
9859 echo_area_buffer[0] = echo_buffer[1];
9860 else
9861 echo_area_buffer[0] = echo_buffer[0];
9862
9863 /* Switch to that buffer and clear it. */
9864 set_buffer_internal (XBUFFER (echo_area_buffer[0]));
9865 BVAR (current_buffer, truncate_lines) = Qnil;
9866
9867 if (Z > BEG)
9868 {
9869 ptrdiff_t count = SPECPDL_INDEX ();
9870 specbind (Qinhibit_read_only, Qt);
9871 /* Note that undo recording is always disabled. */
9872 del_range (BEG, Z);
9873 unbind_to (count, Qnil);
9874 }
9875 TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
9876
9877 /* Set up the buffer for the multibyteness we need. */
9878 if (multibyte_p
9879 != !NILP (BVAR (current_buffer, enable_multibyte_characters)))
9880 Fset_buffer_multibyte (multibyte_p ? Qt : Qnil);
9881
9882 /* Raise the frame containing the echo area. */
9883 if (minibuffer_auto_raise)
9884 {
9885 struct frame *sf = SELECTED_FRAME ();
9886 Lisp_Object mini_window;
9887 mini_window = FRAME_MINIBUF_WINDOW (sf);
9888 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
9889 }
9890
9891 message_log_maybe_newline ();
9892 message_buf_print = 1;
9893 }
9894 else
9895 {
9896 if (NILP (echo_area_buffer[0]))
9897 {
9898 if (EQ (echo_area_buffer[1], echo_buffer[0]))
9899 echo_area_buffer[0] = echo_buffer[1];
9900 else
9901 echo_area_buffer[0] = echo_buffer[0];
9902 }
9903
9904 if (current_buffer != XBUFFER (echo_area_buffer[0]))
9905 {
9906 /* Someone switched buffers between print requests. */
9907 set_buffer_internal (XBUFFER (echo_area_buffer[0]));
9908 BVAR (current_buffer, truncate_lines) = Qnil;
9909 }
9910 }
9911 }
9912
9913
9914 /* Display an echo area message in window W. Value is non-zero if W's
9915 height is changed. If display_last_displayed_message_p is
9916 non-zero, display the message that was last displayed, otherwise
9917 display the current message. */
9918
9919 static int
9920 display_echo_area (struct window *w)
9921 {
9922 int i, no_message_p, window_height_changed_p;
9923
9924 /* Temporarily disable garbage collections while displaying the echo
9925 area. This is done because a GC can print a message itself.
9926 That message would modify the echo area buffer's contents while a
9927 redisplay of the buffer is going on, and seriously confuse
9928 redisplay. */
9929 ptrdiff_t count = inhibit_garbage_collection ();
9930
9931 /* If there is no message, we must call display_echo_area_1
9932 nevertheless because it resizes the window. But we will have to
9933 reset the echo_area_buffer in question to nil at the end because
9934 with_echo_area_buffer will sets it to an empty buffer. */
9935 i = display_last_displayed_message_p ? 1 : 0;
9936 no_message_p = NILP (echo_area_buffer[i]);
9937
9938 window_height_changed_p
9939 = with_echo_area_buffer (w, display_last_displayed_message_p,
9940 display_echo_area_1,
9941 (intptr_t) w, Qnil, 0, 0);
9942
9943 if (no_message_p)
9944 echo_area_buffer[i] = Qnil;
9945
9946 unbind_to (count, Qnil);
9947 return window_height_changed_p;
9948 }
9949
9950
9951 /* Helper for display_echo_area. Display the current buffer which
9952 contains the current echo area message in window W, a mini-window,
9953 a pointer to which is passed in A1. A2..A4 are currently not used.
9954 Change the height of W so that all of the message is displayed.
9955 Value is non-zero if height of W was changed. */
9956
9957 static int
9958 display_echo_area_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4)
9959 {
9960 intptr_t i1 = a1;
9961 struct window *w = (struct window *) i1;
9962 Lisp_Object window;
9963 struct text_pos start;
9964 int window_height_changed_p = 0;
9965
9966 /* Do this before displaying, so that we have a large enough glyph
9967 matrix for the display. If we can't get enough space for the
9968 whole text, display the last N lines. That works by setting w->start. */
9969 window_height_changed_p = resize_mini_window (w, 0);
9970
9971 /* Use the starting position chosen by resize_mini_window. */
9972 SET_TEXT_POS_FROM_MARKER (start, w->start);
9973
9974 /* Display. */
9975 clear_glyph_matrix (w->desired_matrix);
9976 XSETWINDOW (window, w);
9977 try_window (window, start, 0);
9978
9979 return window_height_changed_p;
9980 }
9981
9982
9983 /* Resize the echo area window to exactly the size needed for the
9984 currently displayed message, if there is one. If a mini-buffer
9985 is active, don't shrink it. */
9986
9987 void
9988 resize_echo_area_exactly (void)
9989 {
9990 if (BUFFERP (echo_area_buffer[0])
9991 && WINDOWP (echo_area_window))
9992 {
9993 struct window *w = XWINDOW (echo_area_window);
9994 int resized_p;
9995 Lisp_Object resize_exactly;
9996
9997 if (minibuf_level == 0)
9998 resize_exactly = Qt;
9999 else
10000 resize_exactly = Qnil;
10001
10002 resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
10003 (intptr_t) w, resize_exactly,
10004 0, 0);
10005 if (resized_p)
10006 {
10007 ++windows_or_buffers_changed;
10008 ++update_mode_lines;
10009 redisplay_internal ();
10010 }
10011 }
10012 }
10013
10014
10015 /* Callback function for with_echo_area_buffer, when used from
10016 resize_echo_area_exactly. A1 contains a pointer to the window to
10017 resize, EXACTLY non-nil means resize the mini-window exactly to the
10018 size of the text displayed. A3 and A4 are not used. Value is what
10019 resize_mini_window returns. */
10020
10021 static int
10022 resize_mini_window_1 (ptrdiff_t a1, Lisp_Object exactly, ptrdiff_t a3, ptrdiff_t a4)
10023 {
10024 intptr_t i1 = a1;
10025 return resize_mini_window ((struct window *) i1, !NILP (exactly));
10026 }
10027
10028
10029 /* Resize mini-window W to fit the size of its contents. EXACT_P
10030 means size the window exactly to the size needed. Otherwise, it's
10031 only enlarged until W's buffer is empty.
10032
10033 Set W->start to the right place to begin display. If the whole
10034 contents fit, start at the beginning. Otherwise, start so as
10035 to make the end of the contents appear. This is particularly
10036 important for y-or-n-p, but seems desirable generally.
10037
10038 Value is non-zero if the window height has been changed. */
10039
10040 int
10041 resize_mini_window (struct window *w, int exact_p)
10042 {
10043 struct frame *f = XFRAME (w->frame);
10044 int window_height_changed_p = 0;
10045
10046 xassert (MINI_WINDOW_P (w));
10047
10048 /* By default, start display at the beginning. */
10049 set_marker_both (w->start, w->buffer,
10050 BUF_BEGV (XBUFFER (w->buffer)),
10051 BUF_BEGV_BYTE (XBUFFER (w->buffer)));
10052
10053 /* Don't resize windows while redisplaying a window; it would
10054 confuse redisplay functions when the size of the window they are
10055 displaying changes from under them. Such a resizing can happen,
10056 for instance, when which-func prints a long message while
10057 we are running fontification-functions. We're running these
10058 functions with safe_call which binds inhibit-redisplay to t. */
10059 if (!NILP (Vinhibit_redisplay))
10060 return 0;
10061
10062 /* Nil means don't try to resize. */
10063 if (NILP (Vresize_mini_windows)
10064 || (FRAME_X_P (f) && FRAME_X_OUTPUT (f) == NULL))
10065 return 0;
10066
10067 if (!FRAME_MINIBUF_ONLY_P (f))
10068 {
10069 struct it it;
10070 struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
10071 int total_height = WINDOW_TOTAL_LINES (root) + WINDOW_TOTAL_LINES (w);
10072 int height;
10073 EMACS_INT max_height;
10074 int unit = FRAME_LINE_HEIGHT (f);
10075 struct text_pos start;
10076 struct buffer *old_current_buffer = NULL;
10077
10078 if (current_buffer != XBUFFER (w->buffer))
10079 {
10080 old_current_buffer = current_buffer;
10081 set_buffer_internal (XBUFFER (w->buffer));
10082 }
10083
10084 init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
10085
10086 /* Compute the max. number of lines specified by the user. */
10087 if (FLOATP (Vmax_mini_window_height))
10088 max_height = XFLOATINT (Vmax_mini_window_height) * FRAME_LINES (f);
10089 else if (INTEGERP (Vmax_mini_window_height))
10090 max_height = XINT (Vmax_mini_window_height);
10091 else
10092 max_height = total_height / 4;
10093
10094 /* Correct that max. height if it's bogus. */
10095 max_height = max (1, max_height);
10096 max_height = min (total_height, max_height);
10097
10098 /* Find out the height of the text in the window. */
10099 if (it.line_wrap == TRUNCATE)
10100 height = 1;
10101 else
10102 {
10103 last_height = 0;
10104 move_it_to (&it, ZV, -1, -1, -1, MOVE_TO_POS);
10105 if (it.max_ascent == 0 && it.max_descent == 0)
10106 height = it.current_y + last_height;
10107 else
10108 height = it.current_y + it.max_ascent + it.max_descent;
10109 height -= min (it.extra_line_spacing, it.max_extra_line_spacing);
10110 height = (height + unit - 1) / unit;
10111 }
10112
10113 /* Compute a suitable window start. */
10114 if (height > max_height)
10115 {
10116 height = max_height;
10117 init_iterator (&it, w, ZV, ZV_BYTE, NULL, DEFAULT_FACE_ID);
10118 move_it_vertically_backward (&it, (height - 1) * unit);
10119 start = it.current.pos;
10120 }
10121 else
10122 SET_TEXT_POS (start, BEGV, BEGV_BYTE);
10123 SET_MARKER_FROM_TEXT_POS (w->start, start);
10124
10125 if (EQ (Vresize_mini_windows, Qgrow_only))
10126 {
10127 /* Let it grow only, until we display an empty message, in which
10128 case the window shrinks again. */
10129 if (height > WINDOW_TOTAL_LINES (w))
10130 {
10131 int old_height = WINDOW_TOTAL_LINES (w);
10132 freeze_window_starts (f, 1);
10133 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
10134 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
10135 }
10136 else if (height < WINDOW_TOTAL_LINES (w)
10137 && (exact_p || BEGV == ZV))
10138 {
10139 int old_height = WINDOW_TOTAL_LINES (w);
10140 freeze_window_starts (f, 0);
10141 shrink_mini_window (w);
10142 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
10143 }
10144 }
10145 else
10146 {
10147 /* Always resize to exact size needed. */
10148 if (height > WINDOW_TOTAL_LINES (w))
10149 {
10150 int old_height = WINDOW_TOTAL_LINES (w);
10151 freeze_window_starts (f, 1);
10152 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
10153 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
10154 }
10155 else if (height < WINDOW_TOTAL_LINES (w))
10156 {
10157 int old_height = WINDOW_TOTAL_LINES (w);
10158 freeze_window_starts (f, 0);
10159 shrink_mini_window (w);
10160
10161 if (height)
10162 {
10163 freeze_window_starts (f, 1);
10164 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
10165 }
10166
10167 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
10168 }
10169 }
10170
10171 if (old_current_buffer)
10172 set_buffer_internal (old_current_buffer);
10173 }
10174
10175 return window_height_changed_p;
10176 }
10177
10178
10179 /* Value is the current message, a string, or nil if there is no
10180 current message. */
10181
10182 Lisp_Object
10183 current_message (void)
10184 {
10185 Lisp_Object msg;
10186
10187 if (!BUFFERP (echo_area_buffer[0]))
10188 msg = Qnil;
10189 else
10190 {
10191 with_echo_area_buffer (0, 0, current_message_1,
10192 (intptr_t) &msg, Qnil, 0, 0);
10193 if (NILP (msg))
10194 echo_area_buffer[0] = Qnil;
10195 }
10196
10197 return msg;
10198 }
10199
10200
10201 static int
10202 current_message_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4)
10203 {
10204 intptr_t i1 = a1;
10205 Lisp_Object *msg = (Lisp_Object *) i1;
10206
10207 if (Z > BEG)
10208 *msg = make_buffer_string (BEG, Z, 1);
10209 else
10210 *msg = Qnil;
10211 return 0;
10212 }
10213
10214
10215 /* Push the current message on Vmessage_stack for later restauration
10216 by restore_message. Value is non-zero if the current message isn't
10217 empty. This is a relatively infrequent operation, so it's not
10218 worth optimizing. */
10219
10220 int
10221 push_message (void)
10222 {
10223 Lisp_Object msg;
10224 msg = current_message ();
10225 Vmessage_stack = Fcons (msg, Vmessage_stack);
10226 return STRINGP (msg);
10227 }
10228
10229
10230 /* Restore message display from the top of Vmessage_stack. */
10231
10232 void
10233 restore_message (void)
10234 {
10235 Lisp_Object msg;
10236
10237 xassert (CONSP (Vmessage_stack));
10238 msg = XCAR (Vmessage_stack);
10239 if (STRINGP (msg))
10240 message3_nolog (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
10241 else
10242 message3_nolog (msg, 0, 0);
10243 }
10244
10245
10246 /* Handler for record_unwind_protect calling pop_message. */
10247
10248 Lisp_Object
10249 pop_message_unwind (Lisp_Object dummy)
10250 {
10251 pop_message ();
10252 return Qnil;
10253 }
10254
10255 /* Pop the top-most entry off Vmessage_stack. */
10256
10257 static void
10258 pop_message (void)
10259 {
10260 xassert (CONSP (Vmessage_stack));
10261 Vmessage_stack = XCDR (Vmessage_stack);
10262 }
10263
10264
10265 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
10266 exits. If the stack is not empty, we have a missing pop_message
10267 somewhere. */
10268
10269 void
10270 check_message_stack (void)
10271 {
10272 if (!NILP (Vmessage_stack))
10273 abort ();
10274 }
10275
10276
10277 /* Truncate to NCHARS what will be displayed in the echo area the next
10278 time we display it---but don't redisplay it now. */
10279
10280 void
10281 truncate_echo_area (ptrdiff_t nchars)
10282 {
10283 if (nchars == 0)
10284 echo_area_buffer[0] = Qnil;
10285 /* A null message buffer means that the frame hasn't really been
10286 initialized yet. Error messages get reported properly by
10287 cmd_error, so this must be just an informative message; toss it. */
10288 else if (!noninteractive
10289 && INTERACTIVE
10290 && !NILP (echo_area_buffer[0]))
10291 {
10292 struct frame *sf = SELECTED_FRAME ();
10293 if (FRAME_MESSAGE_BUF (sf))
10294 with_echo_area_buffer (0, 0, truncate_message_1, nchars, Qnil, 0, 0);
10295 }
10296 }
10297
10298
10299 /* Helper function for truncate_echo_area. Truncate the current
10300 message to at most NCHARS characters. */
10301
10302 static int
10303 truncate_message_1 (ptrdiff_t nchars, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4)
10304 {
10305 if (BEG + nchars < Z)
10306 del_range (BEG + nchars, Z);
10307 if (Z == BEG)
10308 echo_area_buffer[0] = Qnil;
10309 return 0;
10310 }
10311
10312
10313 /* Set the current message to a substring of S or STRING.
10314
10315 If STRING is a Lisp string, set the message to the first NBYTES
10316 bytes from STRING. NBYTES zero means use the whole string. If
10317 STRING is multibyte, the message will be displayed multibyte.
10318
10319 If S is not null, set the message to the first LEN bytes of S. LEN
10320 zero means use the whole string. MULTIBYTE_P non-zero means S is
10321 multibyte. Display the message multibyte in that case.
10322
10323 Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
10324 to t before calling set_message_1 (which calls insert).
10325 */
10326
10327 static void
10328 set_message (const char *s, Lisp_Object string,
10329 ptrdiff_t nbytes, int multibyte_p)
10330 {
10331 message_enable_multibyte
10332 = ((s && multibyte_p)
10333 || (STRINGP (string) && STRING_MULTIBYTE (string)));
10334
10335 with_echo_area_buffer (0, -1, set_message_1,
10336 (intptr_t) s, string, nbytes, multibyte_p);
10337 message_buf_print = 0;
10338 help_echo_showing_p = 0;
10339 }
10340
10341
10342 /* Helper function for set_message. Arguments have the same meaning
10343 as there, with A1 corresponding to S and A2 corresponding to STRING
10344 This function is called with the echo area buffer being
10345 current. */
10346
10347 static int
10348 set_message_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t nbytes, ptrdiff_t multibyte_p)
10349 {
10350 intptr_t i1 = a1;
10351 const char *s = (const char *) i1;
10352 const unsigned char *msg = (const unsigned char *) s;
10353 Lisp_Object string = a2;
10354
10355 /* Change multibyteness of the echo buffer appropriately. */
10356 if (message_enable_multibyte
10357 != !NILP (BVAR (current_buffer, enable_multibyte_characters)))
10358 Fset_buffer_multibyte (message_enable_multibyte ? Qt : Qnil);
10359
10360 BVAR (current_buffer, truncate_lines) = message_truncate_lines ? Qt : Qnil;
10361 if (!NILP (BVAR (current_buffer, bidi_display_reordering)))
10362 BVAR (current_buffer, bidi_paragraph_direction) = Qleft_to_right;
10363
10364 /* Insert new message at BEG. */
10365 TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
10366
10367 if (STRINGP (string))
10368 {
10369 ptrdiff_t nchars;
10370
10371 if (nbytes == 0)
10372 nbytes = SBYTES (string);
10373 nchars = string_byte_to_char (string, nbytes);
10374
10375 /* This function takes care of single/multibyte conversion. We
10376 just have to ensure that the echo area buffer has the right
10377 setting of enable_multibyte_characters. */
10378 insert_from_string (string, 0, 0, nchars, nbytes, 1);
10379 }
10380 else if (s)
10381 {
10382 if (nbytes == 0)
10383 nbytes = strlen (s);
10384
10385 if (multibyte_p && NILP (BVAR (current_buffer, enable_multibyte_characters)))
10386 {
10387 /* Convert from multi-byte to single-byte. */
10388 ptrdiff_t i;
10389 int c, n;
10390 char work[1];
10391
10392 /* Convert a multibyte string to single-byte. */
10393 for (i = 0; i < nbytes; i += n)
10394 {
10395 c = string_char_and_length (msg + i, &n);
10396 work[0] = (ASCII_CHAR_P (c)
10397 ? c
10398 : multibyte_char_to_unibyte (c));
10399 insert_1_both (work, 1, 1, 1, 0, 0);
10400 }
10401 }
10402 else if (!multibyte_p
10403 && !NILP (BVAR (current_buffer, enable_multibyte_characters)))
10404 {
10405 /* Convert from single-byte to multi-byte. */
10406 ptrdiff_t i;
10407 int c, n;
10408 unsigned char str[MAX_MULTIBYTE_LENGTH];
10409
10410 /* Convert a single-byte string to multibyte. */
10411 for (i = 0; i < nbytes; i++)
10412 {
10413 c = msg[i];
10414 MAKE_CHAR_MULTIBYTE (c);
10415 n = CHAR_STRING (c, str);
10416 insert_1_both ((char *) str, 1, n, 1, 0, 0);
10417 }
10418 }
10419 else
10420 insert_1 (s, nbytes, 1, 0, 0);
10421 }
10422
10423 return 0;
10424 }
10425
10426
10427 /* Clear messages. CURRENT_P non-zero means clear the current
10428 message. LAST_DISPLAYED_P non-zero means clear the message
10429 last displayed. */
10430
10431 void
10432 clear_message (int current_p, int last_displayed_p)
10433 {
10434 if (current_p)
10435 {
10436 echo_area_buffer[0] = Qnil;
10437 message_cleared_p = 1;
10438 }
10439
10440 if (last_displayed_p)
10441 echo_area_buffer[1] = Qnil;
10442
10443 message_buf_print = 0;
10444 }
10445
10446 /* Clear garbaged frames.
10447
10448 This function is used where the old redisplay called
10449 redraw_garbaged_frames which in turn called redraw_frame which in
10450 turn called clear_frame. The call to clear_frame was a source of
10451 flickering. I believe a clear_frame is not necessary. It should
10452 suffice in the new redisplay to invalidate all current matrices,
10453 and ensure a complete redisplay of all windows. */
10454
10455 static void
10456 clear_garbaged_frames (void)
10457 {
10458 if (frame_garbaged)
10459 {
10460 Lisp_Object tail, frame;
10461 int changed_count = 0;
10462
10463 FOR_EACH_FRAME (tail, frame)
10464 {
10465 struct frame *f = XFRAME (frame);
10466
10467 if (FRAME_VISIBLE_P (f) && FRAME_GARBAGED_P (f))
10468 {
10469 if (f->resized_p)
10470 {
10471 Fredraw_frame (frame);
10472 f->force_flush_display_p = 1;
10473 }
10474 clear_current_matrices (f);
10475 changed_count++;
10476 f->garbaged = 0;
10477 f->resized_p = 0;
10478 }
10479 }
10480
10481 frame_garbaged = 0;
10482 if (changed_count)
10483 ++windows_or_buffers_changed;
10484 }
10485 }
10486
10487
10488 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
10489 is non-zero update selected_frame. Value is non-zero if the
10490 mini-windows height has been changed. */
10491
10492 static int
10493 echo_area_display (int update_frame_p)
10494 {
10495 Lisp_Object mini_window;
10496 struct window *w;
10497 struct frame *f;
10498 int window_height_changed_p = 0;
10499 struct frame *sf = SELECTED_FRAME ();
10500
10501 mini_window = FRAME_MINIBUF_WINDOW (sf);
10502 w = XWINDOW (mini_window);
10503 f = XFRAME (WINDOW_FRAME (w));
10504
10505 /* Don't display if frame is invisible or not yet initialized. */
10506 if (!FRAME_VISIBLE_P (f) || !f->glyphs_initialized_p)
10507 return 0;
10508
10509 #ifdef HAVE_WINDOW_SYSTEM
10510 /* When Emacs starts, selected_frame may be the initial terminal
10511 frame. If we let this through, a message would be displayed on
10512 the terminal. */
10513 if (FRAME_INITIAL_P (XFRAME (selected_frame)))
10514 return 0;
10515 #endif /* HAVE_WINDOW_SYSTEM */
10516
10517 /* Redraw garbaged frames. */
10518 if (frame_garbaged)
10519 clear_garbaged_frames ();
10520
10521 if (!NILP (echo_area_buffer[0]) || minibuf_level == 0)
10522 {
10523 echo_area_window = mini_window;
10524 window_height_changed_p = display_echo_area (w);
10525 w->must_be_updated_p = 1;
10526
10527 /* Update the display, unless called from redisplay_internal.
10528 Also don't update the screen during redisplay itself. The
10529 update will happen at the end of redisplay, and an update
10530 here could cause confusion. */
10531 if (update_frame_p && !redisplaying_p)
10532 {
10533 int n = 0;
10534
10535 /* If the display update has been interrupted by pending
10536 input, update mode lines in the frame. Due to the
10537 pending input, it might have been that redisplay hasn't
10538 been called, so that mode lines above the echo area are
10539 garbaged. This looks odd, so we prevent it here. */
10540 if (!display_completed)
10541 n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), 0);
10542
10543 if (window_height_changed_p
10544 /* Don't do this if Emacs is shutting down. Redisplay
10545 needs to run hooks. */
10546 && !NILP (Vrun_hooks))
10547 {
10548 /* Must update other windows. Likewise as in other
10549 cases, don't let this update be interrupted by
10550 pending input. */
10551 ptrdiff_t count = SPECPDL_INDEX ();
10552 specbind (Qredisplay_dont_pause, Qt);
10553 windows_or_buffers_changed = 1;
10554 redisplay_internal ();
10555 unbind_to (count, Qnil);
10556 }
10557 else if (FRAME_WINDOW_P (f) && n == 0)
10558 {
10559 /* Window configuration is the same as before.
10560 Can do with a display update of the echo area,
10561 unless we displayed some mode lines. */
10562 update_single_window (w, 1);
10563 FRAME_RIF (f)->flush_display (f);
10564 }
10565 else
10566 update_frame (f, 1, 1);
10567
10568 /* If cursor is in the echo area, make sure that the next
10569 redisplay displays the minibuffer, so that the cursor will
10570 be replaced with what the minibuffer wants. */
10571 if (cursor_in_echo_area)
10572 ++windows_or_buffers_changed;
10573 }
10574 }
10575 else if (!EQ (mini_window, selected_window))
10576 windows_or_buffers_changed++;
10577
10578 /* Last displayed message is now the current message. */
10579 echo_area_buffer[1] = echo_area_buffer[0];
10580 /* Inform read_char that we're not echoing. */
10581 echo_message_buffer = Qnil;
10582
10583 /* Prevent redisplay optimization in redisplay_internal by resetting
10584 this_line_start_pos. This is done because the mini-buffer now
10585 displays the message instead of its buffer text. */
10586 if (EQ (mini_window, selected_window))
10587 CHARPOS (this_line_start_pos) = 0;
10588
10589 return window_height_changed_p;
10590 }
10591
10592
10593 \f
10594 /***********************************************************************
10595 Mode Lines and Frame Titles
10596 ***********************************************************************/
10597
10598 /* A buffer for constructing non-propertized mode-line strings and
10599 frame titles in it; allocated from the heap in init_xdisp and
10600 resized as needed in store_mode_line_noprop_char. */
10601
10602 static char *mode_line_noprop_buf;
10603
10604 /* The buffer's end, and a current output position in it. */
10605
10606 static char *mode_line_noprop_buf_end;
10607 static char *mode_line_noprop_ptr;
10608
10609 #define MODE_LINE_NOPROP_LEN(start) \
10610 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
10611
10612 static enum {
10613 MODE_LINE_DISPLAY = 0,
10614 MODE_LINE_TITLE,
10615 MODE_LINE_NOPROP,
10616 MODE_LINE_STRING
10617 } mode_line_target;
10618
10619 /* Alist that caches the results of :propertize.
10620 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
10621 static Lisp_Object mode_line_proptrans_alist;
10622
10623 /* List of strings making up the mode-line. */
10624 static Lisp_Object mode_line_string_list;
10625
10626 /* Base face property when building propertized mode line string. */
10627 static Lisp_Object mode_line_string_face;
10628 static Lisp_Object mode_line_string_face_prop;
10629
10630
10631 /* Unwind data for mode line strings */
10632
10633 static Lisp_Object Vmode_line_unwind_vector;
10634
10635 static Lisp_Object
10636 format_mode_line_unwind_data (struct buffer *obuf,
10637 Lisp_Object owin,
10638 int save_proptrans)
10639 {
10640 Lisp_Object vector, tmp;
10641
10642 /* Reduce consing by keeping one vector in
10643 Vwith_echo_area_save_vector. */
10644 vector = Vmode_line_unwind_vector;
10645 Vmode_line_unwind_vector = Qnil;
10646
10647 if (NILP (vector))
10648 vector = Fmake_vector (make_number (8), Qnil);
10649
10650 ASET (vector, 0, make_number (mode_line_target));
10651 ASET (vector, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
10652 ASET (vector, 2, mode_line_string_list);
10653 ASET (vector, 3, save_proptrans ? mode_line_proptrans_alist : Qt);
10654 ASET (vector, 4, mode_line_string_face);
10655 ASET (vector, 5, mode_line_string_face_prop);
10656
10657 if (obuf)
10658 XSETBUFFER (tmp, obuf);
10659 else
10660 tmp = Qnil;
10661 ASET (vector, 6, tmp);
10662 ASET (vector, 7, owin);
10663
10664 return vector;
10665 }
10666
10667 static Lisp_Object
10668 unwind_format_mode_line (Lisp_Object vector)
10669 {
10670 mode_line_target = XINT (AREF (vector, 0));
10671 mode_line_noprop_ptr = mode_line_noprop_buf + XINT (AREF (vector, 1));
10672 mode_line_string_list = AREF (vector, 2);
10673 if (! EQ (AREF (vector, 3), Qt))
10674 mode_line_proptrans_alist = AREF (vector, 3);
10675 mode_line_string_face = AREF (vector, 4);
10676 mode_line_string_face_prop = AREF (vector, 5);
10677
10678 if (!NILP (AREF (vector, 7)))
10679 /* Select window before buffer, since it may change the buffer. */
10680 Fselect_window (AREF (vector, 7), Qt);
10681
10682 if (!NILP (AREF (vector, 6)))
10683 {
10684 set_buffer_internal_1 (XBUFFER (AREF (vector, 6)));
10685 ASET (vector, 6, Qnil);
10686 }
10687
10688 Vmode_line_unwind_vector = vector;
10689 return Qnil;
10690 }
10691
10692
10693 /* Store a single character C for the frame title in mode_line_noprop_buf.
10694 Re-allocate mode_line_noprop_buf if necessary. */
10695
10696 static void
10697 store_mode_line_noprop_char (char c)
10698 {
10699 /* If output position has reached the end of the allocated buffer,
10700 increase the buffer's size. */
10701 if (mode_line_noprop_ptr == mode_line_noprop_buf_end)
10702 {
10703 ptrdiff_t len = MODE_LINE_NOPROP_LEN (0);
10704 ptrdiff_t size = len;
10705 mode_line_noprop_buf =
10706 xpalloc (mode_line_noprop_buf, &size, 1, STRING_BYTES_BOUND, 1);
10707 mode_line_noprop_buf_end = mode_line_noprop_buf + size;
10708 mode_line_noprop_ptr = mode_line_noprop_buf + len;
10709 }
10710
10711 *mode_line_noprop_ptr++ = c;
10712 }
10713
10714
10715 /* Store part of a frame title in mode_line_noprop_buf, beginning at
10716 mode_line_noprop_ptr. STRING is the string to store. Do not copy
10717 characters that yield more columns than PRECISION; PRECISION <= 0
10718 means copy the whole string. Pad with spaces until FIELD_WIDTH
10719 number of characters have been copied; FIELD_WIDTH <= 0 means don't
10720 pad. Called from display_mode_element when it is used to build a
10721 frame title. */
10722
10723 static int
10724 store_mode_line_noprop (const char *string, int field_width, int precision)
10725 {
10726 const unsigned char *str = (const unsigned char *) string;
10727 int n = 0;
10728 ptrdiff_t dummy, nbytes;
10729
10730 /* Copy at most PRECISION chars from STR. */
10731 nbytes = strlen (string);
10732 n += c_string_width (str, nbytes, precision, &dummy, &nbytes);
10733 while (nbytes--)
10734 store_mode_line_noprop_char (*str++);
10735
10736 /* Fill up with spaces until FIELD_WIDTH reached. */
10737 while (field_width > 0
10738 && n < field_width)
10739 {
10740 store_mode_line_noprop_char (' ');
10741 ++n;
10742 }
10743
10744 return n;
10745 }
10746
10747 /***********************************************************************
10748 Frame Titles
10749 ***********************************************************************/
10750
10751 #ifdef HAVE_WINDOW_SYSTEM
10752
10753 /* Set the title of FRAME, if it has changed. The title format is
10754 Vicon_title_format if FRAME is iconified, otherwise it is
10755 frame_title_format. */
10756
10757 static void
10758 x_consider_frame_title (Lisp_Object frame)
10759 {
10760 struct frame *f = XFRAME (frame);
10761
10762 if (FRAME_WINDOW_P (f)
10763 || FRAME_MINIBUF_ONLY_P (f)
10764 || f->explicit_name)
10765 {
10766 /* Do we have more than one visible frame on this X display? */
10767 Lisp_Object tail;
10768 Lisp_Object fmt;
10769 ptrdiff_t title_start;
10770 char *title;
10771 ptrdiff_t len;
10772 struct it it;
10773 ptrdiff_t count = SPECPDL_INDEX ();
10774
10775 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
10776 {
10777 Lisp_Object other_frame = XCAR (tail);
10778 struct frame *tf = XFRAME (other_frame);
10779
10780 if (tf != f
10781 && FRAME_KBOARD (tf) == FRAME_KBOARD (f)
10782 && !FRAME_MINIBUF_ONLY_P (tf)
10783 && !EQ (other_frame, tip_frame)
10784 && (FRAME_VISIBLE_P (tf) || FRAME_ICONIFIED_P (tf)))
10785 break;
10786 }
10787
10788 /* Set global variable indicating that multiple frames exist. */
10789 multiple_frames = CONSP (tail);
10790
10791 /* Switch to the buffer of selected window of the frame. Set up
10792 mode_line_target so that display_mode_element will output into
10793 mode_line_noprop_buf; then display the title. */
10794 record_unwind_protect (unwind_format_mode_line,
10795 format_mode_line_unwind_data
10796 (current_buffer, selected_window, 0));
10797
10798 Fselect_window (f->selected_window, Qt);
10799 set_buffer_internal_1 (XBUFFER (XWINDOW (f->selected_window)->buffer));
10800 fmt = FRAME_ICONIFIED_P (f) ? Vicon_title_format : Vframe_title_format;
10801
10802 mode_line_target = MODE_LINE_TITLE;
10803 title_start = MODE_LINE_NOPROP_LEN (0);
10804 init_iterator (&it, XWINDOW (f->selected_window), -1, -1,
10805 NULL, DEFAULT_FACE_ID);
10806 display_mode_element (&it, 0, -1, -1, fmt, Qnil, 0);
10807 len = MODE_LINE_NOPROP_LEN (title_start);
10808 title = mode_line_noprop_buf + title_start;
10809 unbind_to (count, Qnil);
10810
10811 /* Set the title only if it's changed. This avoids consing in
10812 the common case where it hasn't. (If it turns out that we've
10813 already wasted too much time by walking through the list with
10814 display_mode_element, then we might need to optimize at a
10815 higher level than this.) */
10816 if (! STRINGP (f->name)
10817 || SBYTES (f->name) != len
10818 || memcmp (title, SDATA (f->name), len) != 0)
10819 x_implicitly_set_name (f, make_string (title, len), Qnil);
10820 }
10821 }
10822
10823 #endif /* not HAVE_WINDOW_SYSTEM */
10824
10825
10826
10827 \f
10828 /***********************************************************************
10829 Menu Bars
10830 ***********************************************************************/
10831
10832
10833 /* Prepare for redisplay by updating menu-bar item lists when
10834 appropriate. This can call eval. */
10835
10836 void
10837 prepare_menu_bars (void)
10838 {
10839 int all_windows;
10840 struct gcpro gcpro1, gcpro2;
10841 struct frame *f;
10842 Lisp_Object tooltip_frame;
10843
10844 #ifdef HAVE_WINDOW_SYSTEM
10845 tooltip_frame = tip_frame;
10846 #else
10847 tooltip_frame = Qnil;
10848 #endif
10849
10850 /* Update all frame titles based on their buffer names, etc. We do
10851 this before the menu bars so that the buffer-menu will show the
10852 up-to-date frame titles. */
10853 #ifdef HAVE_WINDOW_SYSTEM
10854 if (windows_or_buffers_changed || update_mode_lines)
10855 {
10856 Lisp_Object tail, frame;
10857
10858 FOR_EACH_FRAME (tail, frame)
10859 {
10860 f = XFRAME (frame);
10861 if (!EQ (frame, tooltip_frame)
10862 && (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)))
10863 x_consider_frame_title (frame);
10864 }
10865 }
10866 #endif /* HAVE_WINDOW_SYSTEM */
10867
10868 /* Update the menu bar item lists, if appropriate. This has to be
10869 done before any actual redisplay or generation of display lines. */
10870 all_windows = (update_mode_lines
10871 || buffer_shared > 1
10872 || windows_or_buffers_changed);
10873 if (all_windows)
10874 {
10875 Lisp_Object tail, frame;
10876 ptrdiff_t count = SPECPDL_INDEX ();
10877 /* 1 means that update_menu_bar has run its hooks
10878 so any further calls to update_menu_bar shouldn't do so again. */
10879 int menu_bar_hooks_run = 0;
10880
10881 record_unwind_save_match_data ();
10882
10883 FOR_EACH_FRAME (tail, frame)
10884 {
10885 f = XFRAME (frame);
10886
10887 /* Ignore tooltip frame. */
10888 if (EQ (frame, tooltip_frame))
10889 continue;
10890
10891 /* If a window on this frame changed size, report that to
10892 the user and clear the size-change flag. */
10893 if (FRAME_WINDOW_SIZES_CHANGED (f))
10894 {
10895 Lisp_Object functions;
10896
10897 /* Clear flag first in case we get an error below. */
10898 FRAME_WINDOW_SIZES_CHANGED (f) = 0;
10899 functions = Vwindow_size_change_functions;
10900 GCPRO2 (tail, functions);
10901
10902 while (CONSP (functions))
10903 {
10904 if (!EQ (XCAR (functions), Qt))
10905 call1 (XCAR (functions), frame);
10906 functions = XCDR (functions);
10907 }
10908 UNGCPRO;
10909 }
10910
10911 GCPRO1 (tail);
10912 menu_bar_hooks_run = update_menu_bar (f, 0, menu_bar_hooks_run);
10913 #ifdef HAVE_WINDOW_SYSTEM
10914 update_tool_bar (f, 0);
10915 #endif
10916 #ifdef HAVE_NS
10917 if (windows_or_buffers_changed
10918 && FRAME_NS_P (f))
10919 ns_set_doc_edited (f, Fbuffer_modified_p
10920 (XWINDOW (f->selected_window)->buffer));
10921 #endif
10922 UNGCPRO;
10923 }
10924
10925 unbind_to (count, Qnil);
10926 }
10927 else
10928 {
10929 struct frame *sf = SELECTED_FRAME ();
10930 update_menu_bar (sf, 1, 0);
10931 #ifdef HAVE_WINDOW_SYSTEM
10932 update_tool_bar (sf, 1);
10933 #endif
10934 }
10935 }
10936
10937
10938 /* Update the menu bar item list for frame F. This has to be done
10939 before we start to fill in any display lines, because it can call
10940 eval.
10941
10942 If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
10943
10944 If HOOKS_RUN is 1, that means a previous call to update_menu_bar
10945 already ran the menu bar hooks for this redisplay, so there
10946 is no need to run them again. The return value is the
10947 updated value of this flag, to pass to the next call. */
10948
10949 static int
10950 update_menu_bar (struct frame *f, int save_match_data, int hooks_run)
10951 {
10952 Lisp_Object window;
10953 register struct window *w;
10954
10955 /* If called recursively during a menu update, do nothing. This can
10956 happen when, for instance, an activate-menubar-hook causes a
10957 redisplay. */
10958 if (inhibit_menubar_update)
10959 return hooks_run;
10960
10961 window = FRAME_SELECTED_WINDOW (f);
10962 w = XWINDOW (window);
10963
10964 if (FRAME_WINDOW_P (f)
10965 ?
10966 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
10967 || defined (HAVE_NS) || defined (USE_GTK)
10968 FRAME_EXTERNAL_MENU_BAR (f)
10969 #else
10970 FRAME_MENU_BAR_LINES (f) > 0
10971 #endif
10972 : FRAME_MENU_BAR_LINES (f) > 0)
10973 {
10974 /* If the user has switched buffers or windows, we need to
10975 recompute to reflect the new bindings. But we'll
10976 recompute when update_mode_lines is set too; that means
10977 that people can use force-mode-line-update to request
10978 that the menu bar be recomputed. The adverse effect on
10979 the rest of the redisplay algorithm is about the same as
10980 windows_or_buffers_changed anyway. */
10981 if (windows_or_buffers_changed
10982 /* This used to test w->update_mode_line, but we believe
10983 there is no need to recompute the menu in that case. */
10984 || update_mode_lines
10985 || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
10986 < BUF_MODIFF (XBUFFER (w->buffer)))
10987 != !NILP (w->last_had_star))
10988 || ((!NILP (Vtransient_mark_mode)
10989 && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
10990 != !NILP (w->region_showing)))
10991 {
10992 struct buffer *prev = current_buffer;
10993 ptrdiff_t count = SPECPDL_INDEX ();
10994
10995 specbind (Qinhibit_menubar_update, Qt);
10996
10997 set_buffer_internal_1 (XBUFFER (w->buffer));
10998 if (save_match_data)
10999 record_unwind_save_match_data ();
11000 if (NILP (Voverriding_local_map_menu_flag))
11001 {
11002 specbind (Qoverriding_terminal_local_map, Qnil);
11003 specbind (Qoverriding_local_map, Qnil);
11004 }
11005
11006 if (!hooks_run)
11007 {
11008 /* Run the Lucid hook. */
11009 safe_run_hooks (Qactivate_menubar_hook);
11010
11011 /* If it has changed current-menubar from previous value,
11012 really recompute the menu-bar from the value. */
11013 if (! NILP (Vlucid_menu_bar_dirty_flag))
11014 call0 (Qrecompute_lucid_menubar);
11015
11016 safe_run_hooks (Qmenu_bar_update_hook);
11017
11018 hooks_run = 1;
11019 }
11020
11021 XSETFRAME (Vmenu_updating_frame, f);
11022 FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
11023
11024 /* Redisplay the menu bar in case we changed it. */
11025 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
11026 || defined (HAVE_NS) || defined (USE_GTK)
11027 if (FRAME_WINDOW_P (f))
11028 {
11029 #if defined (HAVE_NS)
11030 /* All frames on Mac OS share the same menubar. So only
11031 the selected frame should be allowed to set it. */
11032 if (f == SELECTED_FRAME ())
11033 #endif
11034 set_frame_menubar (f, 0, 0);
11035 }
11036 else
11037 /* On a terminal screen, the menu bar is an ordinary screen
11038 line, and this makes it get updated. */
11039 w->update_mode_line = Qt;
11040 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
11041 /* In the non-toolkit version, the menu bar is an ordinary screen
11042 line, and this makes it get updated. */
11043 w->update_mode_line = Qt;
11044 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
11045
11046 unbind_to (count, Qnil);
11047 set_buffer_internal_1 (prev);
11048 }
11049 }
11050
11051 return hooks_run;
11052 }
11053
11054
11055 \f
11056 /***********************************************************************
11057 Output Cursor
11058 ***********************************************************************/
11059
11060 #ifdef HAVE_WINDOW_SYSTEM
11061
11062 /* EXPORT:
11063 Nominal cursor position -- where to draw output.
11064 HPOS and VPOS are window relative glyph matrix coordinates.
11065 X and Y are window relative pixel coordinates. */
11066
11067 struct cursor_pos output_cursor;
11068
11069
11070 /* EXPORT:
11071 Set the global variable output_cursor to CURSOR. All cursor
11072 positions are relative to updated_window. */
11073
11074 void
11075 set_output_cursor (struct cursor_pos *cursor)
11076 {
11077 output_cursor.hpos = cursor->hpos;
11078 output_cursor.vpos = cursor->vpos;
11079 output_cursor.x = cursor->x;
11080 output_cursor.y = cursor->y;
11081 }
11082
11083
11084 /* EXPORT for RIF:
11085 Set a nominal cursor position.
11086
11087 HPOS and VPOS are column/row positions in a window glyph matrix. X
11088 and Y are window text area relative pixel positions.
11089
11090 If this is done during an update, updated_window will contain the
11091 window that is being updated and the position is the future output
11092 cursor position for that window. If updated_window is null, use
11093 selected_window and display the cursor at the given position. */
11094
11095 void
11096 x_cursor_to (int vpos, int hpos, int y, int x)
11097 {
11098 struct window *w;
11099
11100 /* If updated_window is not set, work on selected_window. */
11101 if (updated_window)
11102 w = updated_window;
11103 else
11104 w = XWINDOW (selected_window);
11105
11106 /* Set the output cursor. */
11107 output_cursor.hpos = hpos;
11108 output_cursor.vpos = vpos;
11109 output_cursor.x = x;
11110 output_cursor.y = y;
11111
11112 /* If not called as part of an update, really display the cursor.
11113 This will also set the cursor position of W. */
11114 if (updated_window == NULL)
11115 {
11116 BLOCK_INPUT;
11117 display_and_set_cursor (w, 1, hpos, vpos, x, y);
11118 if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
11119 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
11120 UNBLOCK_INPUT;
11121 }
11122 }
11123
11124 #endif /* HAVE_WINDOW_SYSTEM */
11125
11126 \f
11127 /***********************************************************************
11128 Tool-bars
11129 ***********************************************************************/
11130
11131 #ifdef HAVE_WINDOW_SYSTEM
11132
11133 /* Where the mouse was last time we reported a mouse event. */
11134
11135 FRAME_PTR last_mouse_frame;
11136
11137 /* Tool-bar item index of the item on which a mouse button was pressed
11138 or -1. */
11139
11140 int last_tool_bar_item;
11141
11142
11143 static Lisp_Object
11144 update_tool_bar_unwind (Lisp_Object frame)
11145 {
11146 selected_frame = frame;
11147 return Qnil;
11148 }
11149
11150 /* Update the tool-bar item list for frame F. This has to be done
11151 before we start to fill in any display lines. Called from
11152 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
11153 and restore it here. */
11154
11155 static void
11156 update_tool_bar (struct frame *f, int save_match_data)
11157 {
11158 #if defined (USE_GTK) || defined (HAVE_NS)
11159 int do_update = FRAME_EXTERNAL_TOOL_BAR (f);
11160 #else
11161 int do_update = WINDOWP (f->tool_bar_window)
11162 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0;
11163 #endif
11164
11165 if (do_update)
11166 {
11167 Lisp_Object window;
11168 struct window *w;
11169
11170 window = FRAME_SELECTED_WINDOW (f);
11171 w = XWINDOW (window);
11172
11173 /* If the user has switched buffers or windows, we need to
11174 recompute to reflect the new bindings. But we'll
11175 recompute when update_mode_lines is set too; that means
11176 that people can use force-mode-line-update to request
11177 that the menu bar be recomputed. The adverse effect on
11178 the rest of the redisplay algorithm is about the same as
11179 windows_or_buffers_changed anyway. */
11180 if (windows_or_buffers_changed
11181 || !NILP (w->update_mode_line)
11182 || update_mode_lines
11183 || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
11184 < BUF_MODIFF (XBUFFER (w->buffer)))
11185 != !NILP (w->last_had_star))
11186 || ((!NILP (Vtransient_mark_mode)
11187 && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
11188 != !NILP (w->region_showing)))
11189 {
11190 struct buffer *prev = current_buffer;
11191 ptrdiff_t count = SPECPDL_INDEX ();
11192 Lisp_Object frame, new_tool_bar;
11193 int new_n_tool_bar;
11194 struct gcpro gcpro1;
11195
11196 /* Set current_buffer to the buffer of the selected
11197 window of the frame, so that we get the right local
11198 keymaps. */
11199 set_buffer_internal_1 (XBUFFER (w->buffer));
11200
11201 /* Save match data, if we must. */
11202 if (save_match_data)
11203 record_unwind_save_match_data ();
11204
11205 /* Make sure that we don't accidentally use bogus keymaps. */
11206 if (NILP (Voverriding_local_map_menu_flag))
11207 {
11208 specbind (Qoverriding_terminal_local_map, Qnil);
11209 specbind (Qoverriding_local_map, Qnil);
11210 }
11211
11212 GCPRO1 (new_tool_bar);
11213
11214 /* We must temporarily set the selected frame to this frame
11215 before calling tool_bar_items, because the calculation of
11216 the tool-bar keymap uses the selected frame (see
11217 `tool-bar-make-keymap' in tool-bar.el). */
11218 record_unwind_protect (update_tool_bar_unwind, selected_frame);
11219 XSETFRAME (frame, f);
11220 selected_frame = frame;
11221
11222 /* Build desired tool-bar items from keymaps. */
11223 new_tool_bar = tool_bar_items (Fcopy_sequence (f->tool_bar_items),
11224 &new_n_tool_bar);
11225
11226 /* Redisplay the tool-bar if we changed it. */
11227 if (new_n_tool_bar != f->n_tool_bar_items
11228 || NILP (Fequal (new_tool_bar, f->tool_bar_items)))
11229 {
11230 /* Redisplay that happens asynchronously due to an expose event
11231 may access f->tool_bar_items. Make sure we update both
11232 variables within BLOCK_INPUT so no such event interrupts. */
11233 BLOCK_INPUT;
11234 f->tool_bar_items = new_tool_bar;
11235 f->n_tool_bar_items = new_n_tool_bar;
11236 w->update_mode_line = Qt;
11237 UNBLOCK_INPUT;
11238 }
11239
11240 UNGCPRO;
11241
11242 unbind_to (count, Qnil);
11243 set_buffer_internal_1 (prev);
11244 }
11245 }
11246 }
11247
11248
11249 /* Set F->desired_tool_bar_string to a Lisp string representing frame
11250 F's desired tool-bar contents. F->tool_bar_items must have
11251 been set up previously by calling prepare_menu_bars. */
11252
11253 static void
11254 build_desired_tool_bar_string (struct frame *f)
11255 {
11256 int i, size, size_needed;
11257 struct gcpro gcpro1, gcpro2, gcpro3;
11258 Lisp_Object image, plist, props;
11259
11260 image = plist = props = Qnil;
11261 GCPRO3 (image, plist, props);
11262
11263 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
11264 Otherwise, make a new string. */
11265
11266 /* The size of the string we might be able to reuse. */
11267 size = (STRINGP (f->desired_tool_bar_string)
11268 ? SCHARS (f->desired_tool_bar_string)
11269 : 0);
11270
11271 /* We need one space in the string for each image. */
11272 size_needed = f->n_tool_bar_items;
11273
11274 /* Reuse f->desired_tool_bar_string, if possible. */
11275 if (size < size_needed || NILP (f->desired_tool_bar_string))
11276 f->desired_tool_bar_string = Fmake_string (make_number (size_needed),
11277 make_number (' '));
11278 else
11279 {
11280 props = list4 (Qdisplay, Qnil, Qmenu_item, Qnil);
11281 Fremove_text_properties (make_number (0), make_number (size),
11282 props, f->desired_tool_bar_string);
11283 }
11284
11285 /* Put a `display' property on the string for the images to display,
11286 put a `menu_item' property on tool-bar items with a value that
11287 is the index of the item in F's tool-bar item vector. */
11288 for (i = 0; i < f->n_tool_bar_items; ++i)
11289 {
11290 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
11291
11292 int enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
11293 int selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
11294 int hmargin, vmargin, relief, idx, end;
11295
11296 /* If image is a vector, choose the image according to the
11297 button state. */
11298 image = PROP (TOOL_BAR_ITEM_IMAGES);
11299 if (VECTORP (image))
11300 {
11301 if (enabled_p)
11302 idx = (selected_p
11303 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
11304 : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
11305 else
11306 idx = (selected_p
11307 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
11308 : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
11309
11310 xassert (ASIZE (image) >= idx);
11311 image = AREF (image, idx);
11312 }
11313 else
11314 idx = -1;
11315
11316 /* Ignore invalid image specifications. */
11317 if (!valid_image_p (image))
11318 continue;
11319
11320 /* Display the tool-bar button pressed, or depressed. */
11321 plist = Fcopy_sequence (XCDR (image));
11322
11323 /* Compute margin and relief to draw. */
11324 relief = (tool_bar_button_relief >= 0
11325 ? tool_bar_button_relief
11326 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
11327 hmargin = vmargin = relief;
11328
11329 if (RANGED_INTEGERP (1, Vtool_bar_button_margin,
11330 INT_MAX - max (hmargin, vmargin)))
11331 {
11332 hmargin += XFASTINT (Vtool_bar_button_margin);
11333 vmargin += XFASTINT (Vtool_bar_button_margin);
11334 }
11335 else if (CONSP (Vtool_bar_button_margin))
11336 {
11337 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin),
11338 INT_MAX - hmargin))
11339 hmargin += XFASTINT (XCAR (Vtool_bar_button_margin));
11340
11341 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin),
11342 INT_MAX - vmargin))
11343 vmargin += XFASTINT (XCDR (Vtool_bar_button_margin));
11344 }
11345
11346 if (auto_raise_tool_bar_buttons_p)
11347 {
11348 /* Add a `:relief' property to the image spec if the item is
11349 selected. */
11350 if (selected_p)
11351 {
11352 plist = Fplist_put (plist, QCrelief, make_number (-relief));
11353 hmargin -= relief;
11354 vmargin -= relief;
11355 }
11356 }
11357 else
11358 {
11359 /* If image is selected, display it pressed, i.e. with a
11360 negative relief. If it's not selected, display it with a
11361 raised relief. */
11362 plist = Fplist_put (plist, QCrelief,
11363 (selected_p
11364 ? make_number (-relief)
11365 : make_number (relief)));
11366 hmargin -= relief;
11367 vmargin -= relief;
11368 }
11369
11370 /* Put a margin around the image. */
11371 if (hmargin || vmargin)
11372 {
11373 if (hmargin == vmargin)
11374 plist = Fplist_put (plist, QCmargin, make_number (hmargin));
11375 else
11376 plist = Fplist_put (plist, QCmargin,
11377 Fcons (make_number (hmargin),
11378 make_number (vmargin)));
11379 }
11380
11381 /* If button is not enabled, and we don't have special images
11382 for the disabled state, make the image appear disabled by
11383 applying an appropriate algorithm to it. */
11384 if (!enabled_p && idx < 0)
11385 plist = Fplist_put (plist, QCconversion, Qdisabled);
11386
11387 /* Put a `display' text property on the string for the image to
11388 display. Put a `menu-item' property on the string that gives
11389 the start of this item's properties in the tool-bar items
11390 vector. */
11391 image = Fcons (Qimage, plist);
11392 props = list4 (Qdisplay, image,
11393 Qmenu_item, make_number (i * TOOL_BAR_ITEM_NSLOTS));
11394
11395 /* Let the last image hide all remaining spaces in the tool bar
11396 string. The string can be longer than needed when we reuse a
11397 previous string. */
11398 if (i + 1 == f->n_tool_bar_items)
11399 end = SCHARS (f->desired_tool_bar_string);
11400 else
11401 end = i + 1;
11402 Fadd_text_properties (make_number (i), make_number (end),
11403 props, f->desired_tool_bar_string);
11404 #undef PROP
11405 }
11406
11407 UNGCPRO;
11408 }
11409
11410
11411 /* Display one line of the tool-bar of frame IT->f.
11412
11413 HEIGHT specifies the desired height of the tool-bar line.
11414 If the actual height of the glyph row is less than HEIGHT, the
11415 row's height is increased to HEIGHT, and the icons are centered
11416 vertically in the new height.
11417
11418 If HEIGHT is -1, we are counting needed tool-bar lines, so don't
11419 count a final empty row in case the tool-bar width exactly matches
11420 the window width.
11421 */
11422
11423 static void
11424 display_tool_bar_line (struct it *it, int height)
11425 {
11426 struct glyph_row *row = it->glyph_row;
11427 int max_x = it->last_visible_x;
11428 struct glyph *last;
11429
11430 prepare_desired_row (row);
11431 row->y = it->current_y;
11432
11433 /* Note that this isn't made use of if the face hasn't a box,
11434 so there's no need to check the face here. */
11435 it->start_of_box_run_p = 1;
11436
11437 while (it->current_x < max_x)
11438 {
11439 int x, n_glyphs_before, i, nglyphs;
11440 struct it it_before;
11441
11442 /* Get the next display element. */
11443 if (!get_next_display_element (it))
11444 {
11445 /* Don't count empty row if we are counting needed tool-bar lines. */
11446 if (height < 0 && !it->hpos)
11447 return;
11448 break;
11449 }
11450
11451 /* Produce glyphs. */
11452 n_glyphs_before = row->used[TEXT_AREA];
11453 it_before = *it;
11454
11455 PRODUCE_GLYPHS (it);
11456
11457 nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
11458 i = 0;
11459 x = it_before.current_x;
11460 while (i < nglyphs)
11461 {
11462 struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
11463
11464 if (x + glyph->pixel_width > max_x)
11465 {
11466 /* Glyph doesn't fit on line. Backtrack. */
11467 row->used[TEXT_AREA] = n_glyphs_before;
11468 *it = it_before;
11469 /* If this is the only glyph on this line, it will never fit on the
11470 tool-bar, so skip it. But ensure there is at least one glyph,
11471 so we don't accidentally disable the tool-bar. */
11472 if (n_glyphs_before == 0
11473 && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
11474 break;
11475 goto out;
11476 }
11477
11478 ++it->hpos;
11479 x += glyph->pixel_width;
11480 ++i;
11481 }
11482
11483 /* Stop at line end. */
11484 if (ITERATOR_AT_END_OF_LINE_P (it))
11485 break;
11486
11487 set_iterator_to_next (it, 1);
11488 }
11489
11490 out:;
11491
11492 row->displays_text_p = row->used[TEXT_AREA] != 0;
11493
11494 /* Use default face for the border below the tool bar.
11495
11496 FIXME: When auto-resize-tool-bars is grow-only, there is
11497 no additional border below the possibly empty tool-bar lines.
11498 So to make the extra empty lines look "normal", we have to
11499 use the tool-bar face for the border too. */
11500 if (!row->displays_text_p && !EQ (Vauto_resize_tool_bars, Qgrow_only))
11501 it->face_id = DEFAULT_FACE_ID;
11502
11503 extend_face_to_end_of_line (it);
11504 last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
11505 last->right_box_line_p = 1;
11506 if (last == row->glyphs[TEXT_AREA])
11507 last->left_box_line_p = 1;
11508
11509 /* Make line the desired height and center it vertically. */
11510 if ((height -= it->max_ascent + it->max_descent) > 0)
11511 {
11512 /* Don't add more than one line height. */
11513 height %= FRAME_LINE_HEIGHT (it->f);
11514 it->max_ascent += height / 2;
11515 it->max_descent += (height + 1) / 2;
11516 }
11517
11518 compute_line_metrics (it);
11519
11520 /* If line is empty, make it occupy the rest of the tool-bar. */
11521 if (!row->displays_text_p)
11522 {
11523 row->height = row->phys_height = it->last_visible_y - row->y;
11524 row->visible_height = row->height;
11525 row->ascent = row->phys_ascent = 0;
11526 row->extra_line_spacing = 0;
11527 }
11528
11529 row->full_width_p = 1;
11530 row->continued_p = 0;
11531 row->truncated_on_left_p = 0;
11532 row->truncated_on_right_p = 0;
11533
11534 it->current_x = it->hpos = 0;
11535 it->current_y += row->height;
11536 ++it->vpos;
11537 ++it->glyph_row;
11538 }
11539
11540
11541 /* Max tool-bar height. */
11542
11543 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
11544 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
11545
11546 /* Value is the number of screen lines needed to make all tool-bar
11547 items of frame F visible. The number of actual rows needed is
11548 returned in *N_ROWS if non-NULL. */
11549
11550 static int
11551 tool_bar_lines_needed (struct frame *f, int *n_rows)
11552 {
11553 struct window *w = XWINDOW (f->tool_bar_window);
11554 struct it it;
11555 /* tool_bar_lines_needed is called from redisplay_tool_bar after building
11556 the desired matrix, so use (unused) mode-line row as temporary row to
11557 avoid destroying the first tool-bar row. */
11558 struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
11559
11560 /* Initialize an iterator for iteration over
11561 F->desired_tool_bar_string in the tool-bar window of frame F. */
11562 init_iterator (&it, w, -1, -1, temp_row, TOOL_BAR_FACE_ID);
11563 it.first_visible_x = 0;
11564 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
11565 reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
11566 it.paragraph_embedding = L2R;
11567
11568 while (!ITERATOR_AT_END_P (&it))
11569 {
11570 clear_glyph_row (temp_row);
11571 it.glyph_row = temp_row;
11572 display_tool_bar_line (&it, -1);
11573 }
11574 clear_glyph_row (temp_row);
11575
11576 /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar. */
11577 if (n_rows)
11578 *n_rows = it.vpos > 0 ? it.vpos : -1;
11579
11580 return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
11581 }
11582
11583
11584 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed, Stool_bar_lines_needed,
11585 0, 1, 0,
11586 doc: /* Return the number of lines occupied by the tool bar of FRAME. */)
11587 (Lisp_Object frame)
11588 {
11589 struct frame *f;
11590 struct window *w;
11591 int nlines = 0;
11592
11593 if (NILP (frame))
11594 frame = selected_frame;
11595 else
11596 CHECK_FRAME (frame);
11597 f = XFRAME (frame);
11598
11599 if (WINDOWP (f->tool_bar_window)
11600 && (w = XWINDOW (f->tool_bar_window),
11601 WINDOW_TOTAL_LINES (w) > 0))
11602 {
11603 update_tool_bar (f, 1);
11604 if (f->n_tool_bar_items)
11605 {
11606 build_desired_tool_bar_string (f);
11607 nlines = tool_bar_lines_needed (f, NULL);
11608 }
11609 }
11610
11611 return make_number (nlines);
11612 }
11613
11614
11615 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
11616 height should be changed. */
11617
11618 static int
11619 redisplay_tool_bar (struct frame *f)
11620 {
11621 struct window *w;
11622 struct it it;
11623 struct glyph_row *row;
11624
11625 #if defined (USE_GTK) || defined (HAVE_NS)
11626 if (FRAME_EXTERNAL_TOOL_BAR (f))
11627 update_frame_tool_bar (f);
11628 return 0;
11629 #endif
11630
11631 /* If frame hasn't a tool-bar window or if it is zero-height, don't
11632 do anything. This means you must start with tool-bar-lines
11633 non-zero to get the auto-sizing effect. Or in other words, you
11634 can turn off tool-bars by specifying tool-bar-lines zero. */
11635 if (!WINDOWP (f->tool_bar_window)
11636 || (w = XWINDOW (f->tool_bar_window),
11637 WINDOW_TOTAL_LINES (w) == 0))
11638 return 0;
11639
11640 /* Set up an iterator for the tool-bar window. */
11641 init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
11642 it.first_visible_x = 0;
11643 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
11644 row = it.glyph_row;
11645
11646 /* Build a string that represents the contents of the tool-bar. */
11647 build_desired_tool_bar_string (f);
11648 reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
11649 /* FIXME: This should be controlled by a user option. But it
11650 doesn't make sense to have an R2L tool bar if the menu bar cannot
11651 be drawn also R2L, and making the menu bar R2L is tricky due
11652 toolkit-specific code that implements it. If an R2L tool bar is
11653 ever supported, display_tool_bar_line should also be augmented to
11654 call unproduce_glyphs like display_line and display_string
11655 do. */
11656 it.paragraph_embedding = L2R;
11657
11658 if (f->n_tool_bar_rows == 0)
11659 {
11660 int nlines;
11661
11662 if ((nlines = tool_bar_lines_needed (f, &f->n_tool_bar_rows),
11663 nlines != WINDOW_TOTAL_LINES (w)))
11664 {
11665 Lisp_Object frame;
11666 int old_height = WINDOW_TOTAL_LINES (w);
11667
11668 XSETFRAME (frame, f);
11669 Fmodify_frame_parameters (frame,
11670 Fcons (Fcons (Qtool_bar_lines,
11671 make_number (nlines)),
11672 Qnil));
11673 if (WINDOW_TOTAL_LINES (w) != old_height)
11674 {
11675 clear_glyph_matrix (w->desired_matrix);
11676 fonts_changed_p = 1;
11677 return 1;
11678 }
11679 }
11680 }
11681
11682 /* Display as many lines as needed to display all tool-bar items. */
11683
11684 if (f->n_tool_bar_rows > 0)
11685 {
11686 int border, rows, height, extra;
11687
11688 if (TYPE_RANGED_INTEGERP (int, Vtool_bar_border))
11689 border = XINT (Vtool_bar_border);
11690 else if (EQ (Vtool_bar_border, Qinternal_border_width))
11691 border = FRAME_INTERNAL_BORDER_WIDTH (f);
11692 else if (EQ (Vtool_bar_border, Qborder_width))
11693 border = f->border_width;
11694 else
11695 border = 0;
11696 if (border < 0)
11697 border = 0;
11698
11699 rows = f->n_tool_bar_rows;
11700 height = max (1, (it.last_visible_y - border) / rows);
11701 extra = it.last_visible_y - border - height * rows;
11702
11703 while (it.current_y < it.last_visible_y)
11704 {
11705 int h = 0;
11706 if (extra > 0 && rows-- > 0)
11707 {
11708 h = (extra + rows - 1) / rows;
11709 extra -= h;
11710 }
11711 display_tool_bar_line (&it, height + h);
11712 }
11713 }
11714 else
11715 {
11716 while (it.current_y < it.last_visible_y)
11717 display_tool_bar_line (&it, 0);
11718 }
11719
11720 /* It doesn't make much sense to try scrolling in the tool-bar
11721 window, so don't do it. */
11722 w->desired_matrix->no_scrolling_p = 1;
11723 w->must_be_updated_p = 1;
11724
11725 if (!NILP (Vauto_resize_tool_bars))
11726 {
11727 int max_tool_bar_height = MAX_FRAME_TOOL_BAR_HEIGHT (f);
11728 int change_height_p = 0;
11729
11730 /* If we couldn't display everything, change the tool-bar's
11731 height if there is room for more. */
11732 if (IT_STRING_CHARPOS (it) < it.end_charpos
11733 && it.current_y < max_tool_bar_height)
11734 change_height_p = 1;
11735
11736 row = it.glyph_row - 1;
11737
11738 /* If there are blank lines at the end, except for a partially
11739 visible blank line at the end that is smaller than
11740 FRAME_LINE_HEIGHT, change the tool-bar's height. */
11741 if (!row->displays_text_p
11742 && row->height >= FRAME_LINE_HEIGHT (f))
11743 change_height_p = 1;
11744
11745 /* If row displays tool-bar items, but is partially visible,
11746 change the tool-bar's height. */
11747 if (row->displays_text_p
11748 && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y
11749 && MATRIX_ROW_BOTTOM_Y (row) < max_tool_bar_height)
11750 change_height_p = 1;
11751
11752 /* Resize windows as needed by changing the `tool-bar-lines'
11753 frame parameter. */
11754 if (change_height_p)
11755 {
11756 Lisp_Object frame;
11757 int old_height = WINDOW_TOTAL_LINES (w);
11758 int nrows;
11759 int nlines = tool_bar_lines_needed (f, &nrows);
11760
11761 change_height_p = ((EQ (Vauto_resize_tool_bars, Qgrow_only)
11762 && !f->minimize_tool_bar_window_p)
11763 ? (nlines > old_height)
11764 : (nlines != old_height));
11765 f->minimize_tool_bar_window_p = 0;
11766
11767 if (change_height_p)
11768 {
11769 XSETFRAME (frame, f);
11770 Fmodify_frame_parameters (frame,
11771 Fcons (Fcons (Qtool_bar_lines,
11772 make_number (nlines)),
11773 Qnil));
11774 if (WINDOW_TOTAL_LINES (w) != old_height)
11775 {
11776 clear_glyph_matrix (w->desired_matrix);
11777 f->n_tool_bar_rows = nrows;
11778 fonts_changed_p = 1;
11779 return 1;
11780 }
11781 }
11782 }
11783 }
11784
11785 f->minimize_tool_bar_window_p = 0;
11786 return 0;
11787 }
11788
11789
11790 /* Get information about the tool-bar item which is displayed in GLYPH
11791 on frame F. Return in *PROP_IDX the index where tool-bar item
11792 properties start in F->tool_bar_items. Value is zero if
11793 GLYPH doesn't display a tool-bar item. */
11794
11795 static int
11796 tool_bar_item_info (struct frame *f, struct glyph *glyph, int *prop_idx)
11797 {
11798 Lisp_Object prop;
11799 int success_p;
11800 int charpos;
11801
11802 /* This function can be called asynchronously, which means we must
11803 exclude any possibility that Fget_text_property signals an
11804 error. */
11805 charpos = min (SCHARS (f->current_tool_bar_string), glyph->charpos);
11806 charpos = max (0, charpos);
11807
11808 /* Get the text property `menu-item' at pos. The value of that
11809 property is the start index of this item's properties in
11810 F->tool_bar_items. */
11811 prop = Fget_text_property (make_number (charpos),
11812 Qmenu_item, f->current_tool_bar_string);
11813 if (INTEGERP (prop))
11814 {
11815 *prop_idx = XINT (prop);
11816 success_p = 1;
11817 }
11818 else
11819 success_p = 0;
11820
11821 return success_p;
11822 }
11823
11824 \f
11825 /* Get information about the tool-bar item at position X/Y on frame F.
11826 Return in *GLYPH a pointer to the glyph of the tool-bar item in
11827 the current matrix of the tool-bar window of F, or NULL if not
11828 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
11829 item in F->tool_bar_items. Value is
11830
11831 -1 if X/Y is not on a tool-bar item
11832 0 if X/Y is on the same item that was highlighted before.
11833 1 otherwise. */
11834
11835 static int
11836 get_tool_bar_item (struct frame *f, int x, int y, struct glyph **glyph,
11837 int *hpos, int *vpos, int *prop_idx)
11838 {
11839 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
11840 struct window *w = XWINDOW (f->tool_bar_window);
11841 int area;
11842
11843 /* Find the glyph under X/Y. */
11844 *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
11845 if (*glyph == NULL)
11846 return -1;
11847
11848 /* Get the start of this tool-bar item's properties in
11849 f->tool_bar_items. */
11850 if (!tool_bar_item_info (f, *glyph, prop_idx))
11851 return -1;
11852
11853 /* Is mouse on the highlighted item? */
11854 if (EQ (f->tool_bar_window, hlinfo->mouse_face_window)
11855 && *vpos >= hlinfo->mouse_face_beg_row
11856 && *vpos <= hlinfo->mouse_face_end_row
11857 && (*vpos > hlinfo->mouse_face_beg_row
11858 || *hpos >= hlinfo->mouse_face_beg_col)
11859 && (*vpos < hlinfo->mouse_face_end_row
11860 || *hpos < hlinfo->mouse_face_end_col
11861 || hlinfo->mouse_face_past_end))
11862 return 0;
11863
11864 return 1;
11865 }
11866
11867
11868 /* EXPORT:
11869 Handle mouse button event on the tool-bar of frame F, at
11870 frame-relative coordinates X/Y. DOWN_P is 1 for a button press,
11871 0 for button release. MODIFIERS is event modifiers for button
11872 release. */
11873
11874 void
11875 handle_tool_bar_click (struct frame *f, int x, int y, int down_p,
11876 int modifiers)
11877 {
11878 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
11879 struct window *w = XWINDOW (f->tool_bar_window);
11880 int hpos, vpos, prop_idx;
11881 struct glyph *glyph;
11882 Lisp_Object enabled_p;
11883
11884 /* If not on the highlighted tool-bar item, return. */
11885 frame_to_window_pixel_xy (w, &x, &y);
11886 if (get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
11887 return;
11888
11889 /* If item is disabled, do nothing. */
11890 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
11891 if (NILP (enabled_p))
11892 return;
11893
11894 if (down_p)
11895 {
11896 /* Show item in pressed state. */
11897 show_mouse_face (hlinfo, DRAW_IMAGE_SUNKEN);
11898 hlinfo->mouse_face_image_state = DRAW_IMAGE_SUNKEN;
11899 last_tool_bar_item = prop_idx;
11900 }
11901 else
11902 {
11903 Lisp_Object key, frame;
11904 struct input_event event;
11905 EVENT_INIT (event);
11906
11907 /* Show item in released state. */
11908 show_mouse_face (hlinfo, DRAW_IMAGE_RAISED);
11909 hlinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
11910
11911 key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
11912
11913 XSETFRAME (frame, f);
11914 event.kind = TOOL_BAR_EVENT;
11915 event.frame_or_window = frame;
11916 event.arg = frame;
11917 kbd_buffer_store_event (&event);
11918
11919 event.kind = TOOL_BAR_EVENT;
11920 event.frame_or_window = frame;
11921 event.arg = key;
11922 event.modifiers = modifiers;
11923 kbd_buffer_store_event (&event);
11924 last_tool_bar_item = -1;
11925 }
11926 }
11927
11928
11929 /* Possibly highlight a tool-bar item on frame F when mouse moves to
11930 tool-bar window-relative coordinates X/Y. Called from
11931 note_mouse_highlight. */
11932
11933 static void
11934 note_tool_bar_highlight (struct frame *f, int x, int y)
11935 {
11936 Lisp_Object window = f->tool_bar_window;
11937 struct window *w = XWINDOW (window);
11938 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
11939 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
11940 int hpos, vpos;
11941 struct glyph *glyph;
11942 struct glyph_row *row;
11943 int i;
11944 Lisp_Object enabled_p;
11945 int prop_idx;
11946 enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
11947 int mouse_down_p, rc;
11948
11949 /* Function note_mouse_highlight is called with negative X/Y
11950 values when mouse moves outside of the frame. */
11951 if (x <= 0 || y <= 0)
11952 {
11953 clear_mouse_face (hlinfo);
11954 return;
11955 }
11956
11957 rc = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
11958 if (rc < 0)
11959 {
11960 /* Not on tool-bar item. */
11961 clear_mouse_face (hlinfo);
11962 return;
11963 }
11964 else if (rc == 0)
11965 /* On same tool-bar item as before. */
11966 goto set_help_echo;
11967
11968 clear_mouse_face (hlinfo);
11969
11970 /* Mouse is down, but on different tool-bar item? */
11971 mouse_down_p = (dpyinfo->grabbed
11972 && f == last_mouse_frame
11973 && FRAME_LIVE_P (f));
11974 if (mouse_down_p
11975 && last_tool_bar_item != prop_idx)
11976 return;
11977
11978 hlinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
11979 draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
11980
11981 /* If tool-bar item is not enabled, don't highlight it. */
11982 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
11983 if (!NILP (enabled_p))
11984 {
11985 /* Compute the x-position of the glyph. In front and past the
11986 image is a space. We include this in the highlighted area. */
11987 row = MATRIX_ROW (w->current_matrix, vpos);
11988 for (i = x = 0; i < hpos; ++i)
11989 x += row->glyphs[TEXT_AREA][i].pixel_width;
11990
11991 /* Record this as the current active region. */
11992 hlinfo->mouse_face_beg_col = hpos;
11993 hlinfo->mouse_face_beg_row = vpos;
11994 hlinfo->mouse_face_beg_x = x;
11995 hlinfo->mouse_face_beg_y = row->y;
11996 hlinfo->mouse_face_past_end = 0;
11997
11998 hlinfo->mouse_face_end_col = hpos + 1;
11999 hlinfo->mouse_face_end_row = vpos;
12000 hlinfo->mouse_face_end_x = x + glyph->pixel_width;
12001 hlinfo->mouse_face_end_y = row->y;
12002 hlinfo->mouse_face_window = window;
12003 hlinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
12004
12005 /* Display it as active. */
12006 show_mouse_face (hlinfo, draw);
12007 hlinfo->mouse_face_image_state = draw;
12008 }
12009
12010 set_help_echo:
12011
12012 /* Set help_echo_string to a help string to display for this tool-bar item.
12013 XTread_socket does the rest. */
12014 help_echo_object = help_echo_window = Qnil;
12015 help_echo_pos = -1;
12016 help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
12017 if (NILP (help_echo_string))
12018 help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
12019 }
12020
12021 #endif /* HAVE_WINDOW_SYSTEM */
12022
12023
12024 \f
12025 /************************************************************************
12026 Horizontal scrolling
12027 ************************************************************************/
12028
12029 static int hscroll_window_tree (Lisp_Object);
12030 static int hscroll_windows (Lisp_Object);
12031
12032 /* For all leaf windows in the window tree rooted at WINDOW, set their
12033 hscroll value so that PT is (i) visible in the window, and (ii) so
12034 that it is not within a certain margin at the window's left and
12035 right border. Value is non-zero if any window's hscroll has been
12036 changed. */
12037
12038 static int
12039 hscroll_window_tree (Lisp_Object window)
12040 {
12041 int hscrolled_p = 0;
12042 int hscroll_relative_p = FLOATP (Vhscroll_step);
12043 int hscroll_step_abs = 0;
12044 double hscroll_step_rel = 0;
12045
12046 if (hscroll_relative_p)
12047 {
12048 hscroll_step_rel = XFLOAT_DATA (Vhscroll_step);
12049 if (hscroll_step_rel < 0)
12050 {
12051 hscroll_relative_p = 0;
12052 hscroll_step_abs = 0;
12053 }
12054 }
12055 else if (TYPE_RANGED_INTEGERP (int, Vhscroll_step))
12056 {
12057 hscroll_step_abs = XINT (Vhscroll_step);
12058 if (hscroll_step_abs < 0)
12059 hscroll_step_abs = 0;
12060 }
12061 else
12062 hscroll_step_abs = 0;
12063
12064 while (WINDOWP (window))
12065 {
12066 struct window *w = XWINDOW (window);
12067
12068 if (WINDOWP (w->hchild))
12069 hscrolled_p |= hscroll_window_tree (w->hchild);
12070 else if (WINDOWP (w->vchild))
12071 hscrolled_p |= hscroll_window_tree (w->vchild);
12072 else if (w->cursor.vpos >= 0)
12073 {
12074 int h_margin;
12075 int text_area_width;
12076 struct glyph_row *current_cursor_row
12077 = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
12078 struct glyph_row *desired_cursor_row
12079 = MATRIX_ROW (w->desired_matrix, w->cursor.vpos);
12080 struct glyph_row *cursor_row
12081 = (desired_cursor_row->enabled_p
12082 ? desired_cursor_row
12083 : current_cursor_row);
12084 int row_r2l_p = cursor_row->reversed_p;
12085
12086 text_area_width = window_box_width (w, TEXT_AREA);
12087
12088 /* Scroll when cursor is inside this scroll margin. */
12089 h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
12090
12091 if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->buffer))
12092 /* For left-to-right rows, hscroll when cursor is either
12093 (i) inside the right hscroll margin, or (ii) if it is
12094 inside the left margin and the window is already
12095 hscrolled. */
12096 && ((!row_r2l_p
12097 && ((XFASTINT (w->hscroll)
12098 && w->cursor.x <= h_margin)
12099 || (cursor_row->enabled_p
12100 && cursor_row->truncated_on_right_p
12101 && (w->cursor.x >= text_area_width - h_margin))))
12102 /* For right-to-left rows, the logic is similar,
12103 except that rules for scrolling to left and right
12104 are reversed. E.g., if cursor.x <= h_margin, we
12105 need to hscroll "to the right" unconditionally,
12106 and that will scroll the screen to the left so as
12107 to reveal the next portion of the row. */
12108 || (row_r2l_p
12109 && ((cursor_row->enabled_p
12110 /* FIXME: It is confusing to set the
12111 truncated_on_right_p flag when R2L rows
12112 are actually truncated on the left. */
12113 && cursor_row->truncated_on_right_p
12114 && w->cursor.x <= h_margin)
12115 || (XFASTINT (w->hscroll)
12116 && (w->cursor.x >= text_area_width - h_margin))))))
12117 {
12118 struct it it;
12119 ptrdiff_t hscroll;
12120 struct buffer *saved_current_buffer;
12121 ptrdiff_t pt;
12122 int wanted_x;
12123
12124 /* Find point in a display of infinite width. */
12125 saved_current_buffer = current_buffer;
12126 current_buffer = XBUFFER (w->buffer);
12127
12128 if (w == XWINDOW (selected_window))
12129 pt = PT;
12130 else
12131 {
12132 pt = marker_position (w->pointm);
12133 pt = max (BEGV, pt);
12134 pt = min (ZV, pt);
12135 }
12136
12137 /* Move iterator to pt starting at cursor_row->start in
12138 a line with infinite width. */
12139 init_to_row_start (&it, w, cursor_row);
12140 it.last_visible_x = INFINITY;
12141 move_it_in_display_line_to (&it, pt, -1, MOVE_TO_POS);
12142 current_buffer = saved_current_buffer;
12143
12144 /* Position cursor in window. */
12145 if (!hscroll_relative_p && hscroll_step_abs == 0)
12146 hscroll = max (0, (it.current_x
12147 - (ITERATOR_AT_END_OF_LINE_P (&it)
12148 ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
12149 : (text_area_width / 2))))
12150 / FRAME_COLUMN_WIDTH (it.f);
12151 else if ((!row_r2l_p
12152 && w->cursor.x >= text_area_width - h_margin)
12153 || (row_r2l_p && w->cursor.x <= h_margin))
12154 {
12155 if (hscroll_relative_p)
12156 wanted_x = text_area_width * (1 - hscroll_step_rel)
12157 - h_margin;
12158 else
12159 wanted_x = text_area_width
12160 - hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
12161 - h_margin;
12162 hscroll
12163 = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
12164 }
12165 else
12166 {
12167 if (hscroll_relative_p)
12168 wanted_x = text_area_width * hscroll_step_rel
12169 + h_margin;
12170 else
12171 wanted_x = hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
12172 + h_margin;
12173 hscroll
12174 = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
12175 }
12176 hscroll = max (hscroll, XFASTINT (w->min_hscroll));
12177
12178 /* Don't prevent redisplay optimizations if hscroll
12179 hasn't changed, as it will unnecessarily slow down
12180 redisplay. */
12181 if (XFASTINT (w->hscroll) != hscroll)
12182 {
12183 XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
12184 w->hscroll = make_number (hscroll);
12185 hscrolled_p = 1;
12186 }
12187 }
12188 }
12189
12190 window = w->next;
12191 }
12192
12193 /* Value is non-zero if hscroll of any leaf window has been changed. */
12194 return hscrolled_p;
12195 }
12196
12197
12198 /* Set hscroll so that cursor is visible and not inside horizontal
12199 scroll margins for all windows in the tree rooted at WINDOW. See
12200 also hscroll_window_tree above. Value is non-zero if any window's
12201 hscroll has been changed. If it has, desired matrices on the frame
12202 of WINDOW are cleared. */
12203
12204 static int
12205 hscroll_windows (Lisp_Object window)
12206 {
12207 int hscrolled_p = hscroll_window_tree (window);
12208 if (hscrolled_p)
12209 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window))));
12210 return hscrolled_p;
12211 }
12212
12213
12214 \f
12215 /************************************************************************
12216 Redisplay
12217 ************************************************************************/
12218
12219 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
12220 to a non-zero value. This is sometimes handy to have in a debugger
12221 session. */
12222
12223 #if GLYPH_DEBUG
12224
12225 /* First and last unchanged row for try_window_id. */
12226
12227 static int debug_first_unchanged_at_end_vpos;
12228 static int debug_last_unchanged_at_beg_vpos;
12229
12230 /* Delta vpos and y. */
12231
12232 static int debug_dvpos, debug_dy;
12233
12234 /* Delta in characters and bytes for try_window_id. */
12235
12236 static ptrdiff_t debug_delta, debug_delta_bytes;
12237
12238 /* Values of window_end_pos and window_end_vpos at the end of
12239 try_window_id. */
12240
12241 static ptrdiff_t debug_end_vpos;
12242
12243 /* Append a string to W->desired_matrix->method. FMT is a printf
12244 format string. If trace_redisplay_p is non-zero also printf the
12245 resulting string to stderr. */
12246
12247 static void debug_method_add (struct window *, char const *, ...)
12248 ATTRIBUTE_FORMAT_PRINTF (2, 3);
12249
12250 static void
12251 debug_method_add (struct window *w, char const *fmt, ...)
12252 {
12253 char buffer[512];
12254 char *method = w->desired_matrix->method;
12255 int len = strlen (method);
12256 int size = sizeof w->desired_matrix->method;
12257 int remaining = size - len - 1;
12258 va_list ap;
12259
12260 va_start (ap, fmt);
12261 vsprintf (buffer, fmt, ap);
12262 va_end (ap);
12263 if (len && remaining)
12264 {
12265 method[len] = '|';
12266 --remaining, ++len;
12267 }
12268
12269 strncpy (method + len, buffer, remaining);
12270
12271 if (trace_redisplay_p)
12272 fprintf (stderr, "%p (%s): %s\n",
12273 w,
12274 ((BUFFERP (w->buffer)
12275 && STRINGP (BVAR (XBUFFER (w->buffer), name)))
12276 ? SSDATA (BVAR (XBUFFER (w->buffer), name))
12277 : "no buffer"),
12278 buffer);
12279 }
12280
12281 #endif /* GLYPH_DEBUG */
12282
12283
12284 /* Value is non-zero if all changes in window W, which displays
12285 current_buffer, are in the text between START and END. START is a
12286 buffer position, END is given as a distance from Z. Used in
12287 redisplay_internal for display optimization. */
12288
12289 static inline int
12290 text_outside_line_unchanged_p (struct window *w,
12291 ptrdiff_t start, ptrdiff_t end)
12292 {
12293 int unchanged_p = 1;
12294
12295 /* If text or overlays have changed, see where. */
12296 if (XFASTINT (w->last_modified) < MODIFF
12297 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF)
12298 {
12299 /* Gap in the line? */
12300 if (GPT < start || Z - GPT < end)
12301 unchanged_p = 0;
12302
12303 /* Changes start in front of the line, or end after it? */
12304 if (unchanged_p
12305 && (BEG_UNCHANGED < start - 1
12306 || END_UNCHANGED < end))
12307 unchanged_p = 0;
12308
12309 /* If selective display, can't optimize if changes start at the
12310 beginning of the line. */
12311 if (unchanged_p
12312 && INTEGERP (BVAR (current_buffer, selective_display))
12313 && XINT (BVAR (current_buffer, selective_display)) > 0
12314 && (BEG_UNCHANGED < start || GPT <= start))
12315 unchanged_p = 0;
12316
12317 /* If there are overlays at the start or end of the line, these
12318 may have overlay strings with newlines in them. A change at
12319 START, for instance, may actually concern the display of such
12320 overlay strings as well, and they are displayed on different
12321 lines. So, quickly rule out this case. (For the future, it
12322 might be desirable to implement something more telling than
12323 just BEG/END_UNCHANGED.) */
12324 if (unchanged_p)
12325 {
12326 if (BEG + BEG_UNCHANGED == start
12327 && overlay_touches_p (start))
12328 unchanged_p = 0;
12329 if (END_UNCHANGED == end
12330 && overlay_touches_p (Z - end))
12331 unchanged_p = 0;
12332 }
12333
12334 /* Under bidi reordering, adding or deleting a character in the
12335 beginning of a paragraph, before the first strong directional
12336 character, can change the base direction of the paragraph (unless
12337 the buffer specifies a fixed paragraph direction), which will
12338 require to redisplay the whole paragraph. It might be worthwhile
12339 to find the paragraph limits and widen the range of redisplayed
12340 lines to that, but for now just give up this optimization. */
12341 if (!NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering))
12342 && NILP (BVAR (XBUFFER (w->buffer), bidi_paragraph_direction)))
12343 unchanged_p = 0;
12344 }
12345
12346 return unchanged_p;
12347 }
12348
12349
12350 /* Do a frame update, taking possible shortcuts into account. This is
12351 the main external entry point for redisplay.
12352
12353 If the last redisplay displayed an echo area message and that message
12354 is no longer requested, we clear the echo area or bring back the
12355 mini-buffer if that is in use. */
12356
12357 void
12358 redisplay (void)
12359 {
12360 redisplay_internal ();
12361 }
12362
12363
12364 static Lisp_Object
12365 overlay_arrow_string_or_property (Lisp_Object var)
12366 {
12367 Lisp_Object val;
12368
12369 if (val = Fget (var, Qoverlay_arrow_string), STRINGP (val))
12370 return val;
12371
12372 return Voverlay_arrow_string;
12373 }
12374
12375 /* Return 1 if there are any overlay-arrows in current_buffer. */
12376 static int
12377 overlay_arrow_in_current_buffer_p (void)
12378 {
12379 Lisp_Object vlist;
12380
12381 for (vlist = Voverlay_arrow_variable_list;
12382 CONSP (vlist);
12383 vlist = XCDR (vlist))
12384 {
12385 Lisp_Object var = XCAR (vlist);
12386 Lisp_Object val;
12387
12388 if (!SYMBOLP (var))
12389 continue;
12390 val = find_symbol_value (var);
12391 if (MARKERP (val)
12392 && current_buffer == XMARKER (val)->buffer)
12393 return 1;
12394 }
12395 return 0;
12396 }
12397
12398
12399 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
12400 has changed. */
12401
12402 static int
12403 overlay_arrows_changed_p (void)
12404 {
12405 Lisp_Object vlist;
12406
12407 for (vlist = Voverlay_arrow_variable_list;
12408 CONSP (vlist);
12409 vlist = XCDR (vlist))
12410 {
12411 Lisp_Object var = XCAR (vlist);
12412 Lisp_Object val, pstr;
12413
12414 if (!SYMBOLP (var))
12415 continue;
12416 val = find_symbol_value (var);
12417 if (!MARKERP (val))
12418 continue;
12419 if (! EQ (COERCE_MARKER (val),
12420 Fget (var, Qlast_arrow_position))
12421 || ! (pstr = overlay_arrow_string_or_property (var),
12422 EQ (pstr, Fget (var, Qlast_arrow_string))))
12423 return 1;
12424 }
12425 return 0;
12426 }
12427
12428 /* Mark overlay arrows to be updated on next redisplay. */
12429
12430 static void
12431 update_overlay_arrows (int up_to_date)
12432 {
12433 Lisp_Object vlist;
12434
12435 for (vlist = Voverlay_arrow_variable_list;
12436 CONSP (vlist);
12437 vlist = XCDR (vlist))
12438 {
12439 Lisp_Object var = XCAR (vlist);
12440
12441 if (!SYMBOLP (var))
12442 continue;
12443
12444 if (up_to_date > 0)
12445 {
12446 Lisp_Object val = find_symbol_value (var);
12447 Fput (var, Qlast_arrow_position,
12448 COERCE_MARKER (val));
12449 Fput (var, Qlast_arrow_string,
12450 overlay_arrow_string_or_property (var));
12451 }
12452 else if (up_to_date < 0
12453 || !NILP (Fget (var, Qlast_arrow_position)))
12454 {
12455 Fput (var, Qlast_arrow_position, Qt);
12456 Fput (var, Qlast_arrow_string, Qt);
12457 }
12458 }
12459 }
12460
12461
12462 /* Return overlay arrow string to display at row.
12463 Return integer (bitmap number) for arrow bitmap in left fringe.
12464 Return nil if no overlay arrow. */
12465
12466 static Lisp_Object
12467 overlay_arrow_at_row (struct it *it, struct glyph_row *row)
12468 {
12469 Lisp_Object vlist;
12470
12471 for (vlist = Voverlay_arrow_variable_list;
12472 CONSP (vlist);
12473 vlist = XCDR (vlist))
12474 {
12475 Lisp_Object var = XCAR (vlist);
12476 Lisp_Object val;
12477
12478 if (!SYMBOLP (var))
12479 continue;
12480
12481 val = find_symbol_value (var);
12482
12483 if (MARKERP (val)
12484 && current_buffer == XMARKER (val)->buffer
12485 && (MATRIX_ROW_START_CHARPOS (row) == marker_position (val)))
12486 {
12487 if (FRAME_WINDOW_P (it->f)
12488 /* FIXME: if ROW->reversed_p is set, this should test
12489 the right fringe, not the left one. */
12490 && WINDOW_LEFT_FRINGE_WIDTH (it->w) > 0)
12491 {
12492 #ifdef HAVE_WINDOW_SYSTEM
12493 if (val = Fget (var, Qoverlay_arrow_bitmap), SYMBOLP (val))
12494 {
12495 int fringe_bitmap;
12496 if ((fringe_bitmap = lookup_fringe_bitmap (val)) != 0)
12497 return make_number (fringe_bitmap);
12498 }
12499 #endif
12500 return make_number (-1); /* Use default arrow bitmap */
12501 }
12502 return overlay_arrow_string_or_property (var);
12503 }
12504 }
12505
12506 return Qnil;
12507 }
12508
12509 /* Return 1 if point moved out of or into a composition. Otherwise
12510 return 0. PREV_BUF and PREV_PT are the last point buffer and
12511 position. BUF and PT are the current point buffer and position. */
12512
12513 static int
12514 check_point_in_composition (struct buffer *prev_buf, ptrdiff_t prev_pt,
12515 struct buffer *buf, ptrdiff_t pt)
12516 {
12517 ptrdiff_t start, end;
12518 Lisp_Object prop;
12519 Lisp_Object buffer;
12520
12521 XSETBUFFER (buffer, buf);
12522 /* Check a composition at the last point if point moved within the
12523 same buffer. */
12524 if (prev_buf == buf)
12525 {
12526 if (prev_pt == pt)
12527 /* Point didn't move. */
12528 return 0;
12529
12530 if (prev_pt > BUF_BEGV (buf) && prev_pt < BUF_ZV (buf)
12531 && find_composition (prev_pt, -1, &start, &end, &prop, buffer)
12532 && COMPOSITION_VALID_P (start, end, prop)
12533 && start < prev_pt && end > prev_pt)
12534 /* The last point was within the composition. Return 1 iff
12535 point moved out of the composition. */
12536 return (pt <= start || pt >= end);
12537 }
12538
12539 /* Check a composition at the current point. */
12540 return (pt > BUF_BEGV (buf) && pt < BUF_ZV (buf)
12541 && find_composition (pt, -1, &start, &end, &prop, buffer)
12542 && COMPOSITION_VALID_P (start, end, prop)
12543 && start < pt && end > pt);
12544 }
12545
12546
12547 /* Reconsider the setting of B->clip_changed which is displayed
12548 in window W. */
12549
12550 static inline void
12551 reconsider_clip_changes (struct window *w, struct buffer *b)
12552 {
12553 if (b->clip_changed
12554 && !NILP (w->window_end_valid)
12555 && w->current_matrix->buffer == b
12556 && w->current_matrix->zv == BUF_ZV (b)
12557 && w->current_matrix->begv == BUF_BEGV (b))
12558 b->clip_changed = 0;
12559
12560 /* If display wasn't paused, and W is not a tool bar window, see if
12561 point has been moved into or out of a composition. In that case,
12562 we set b->clip_changed to 1 to force updating the screen. If
12563 b->clip_changed has already been set to 1, we can skip this
12564 check. */
12565 if (!b->clip_changed
12566 && BUFFERP (w->buffer) && !NILP (w->window_end_valid))
12567 {
12568 ptrdiff_t pt;
12569
12570 if (w == XWINDOW (selected_window))
12571 pt = PT;
12572 else
12573 pt = marker_position (w->pointm);
12574
12575 if ((w->current_matrix->buffer != XBUFFER (w->buffer)
12576 || pt != XINT (w->last_point))
12577 && check_point_in_composition (w->current_matrix->buffer,
12578 XINT (w->last_point),
12579 XBUFFER (w->buffer), pt))
12580 b->clip_changed = 1;
12581 }
12582 }
12583 \f
12584
12585 /* Select FRAME to forward the values of frame-local variables into C
12586 variables so that the redisplay routines can access those values
12587 directly. */
12588
12589 static void
12590 select_frame_for_redisplay (Lisp_Object frame)
12591 {
12592 Lisp_Object tail, tem;
12593 Lisp_Object old = selected_frame;
12594 struct Lisp_Symbol *sym;
12595
12596 xassert (FRAMEP (frame) && FRAME_LIVE_P (XFRAME (frame)));
12597
12598 selected_frame = frame;
12599
12600 do {
12601 for (tail = XFRAME (frame)->param_alist; CONSP (tail); tail = XCDR (tail))
12602 if (CONSP (XCAR (tail))
12603 && (tem = XCAR (XCAR (tail)),
12604 SYMBOLP (tem))
12605 && (sym = indirect_variable (XSYMBOL (tem)),
12606 sym->redirect == SYMBOL_LOCALIZED)
12607 && sym->val.blv->frame_local)
12608 /* Use find_symbol_value rather than Fsymbol_value
12609 to avoid an error if it is void. */
12610 find_symbol_value (tem);
12611 } while (!EQ (frame, old) && (frame = old, 1));
12612 }
12613
12614
12615 #define STOP_POLLING \
12616 do { if (! polling_stopped_here) stop_polling (); \
12617 polling_stopped_here = 1; } while (0)
12618
12619 #define RESUME_POLLING \
12620 do { if (polling_stopped_here) start_polling (); \
12621 polling_stopped_here = 0; } while (0)
12622
12623
12624 /* Perhaps in the future avoid recentering windows if it
12625 is not necessary; currently that causes some problems. */
12626
12627 static void
12628 redisplay_internal (void)
12629 {
12630 struct window *w = XWINDOW (selected_window);
12631 struct window *sw;
12632 struct frame *fr;
12633 int pending;
12634 int must_finish = 0;
12635 struct text_pos tlbufpos, tlendpos;
12636 int number_of_visible_frames;
12637 ptrdiff_t count, count1;
12638 struct frame *sf;
12639 int polling_stopped_here = 0;
12640 Lisp_Object old_frame = selected_frame;
12641
12642 /* Non-zero means redisplay has to consider all windows on all
12643 frames. Zero means, only selected_window is considered. */
12644 int consider_all_windows_p;
12645
12646 TRACE ((stderr, "redisplay_internal %d\n", redisplaying_p));
12647
12648 /* No redisplay if running in batch mode or frame is not yet fully
12649 initialized, or redisplay is explicitly turned off by setting
12650 Vinhibit_redisplay. */
12651 if (FRAME_INITIAL_P (SELECTED_FRAME ())
12652 || !NILP (Vinhibit_redisplay))
12653 return;
12654
12655 /* Don't examine these until after testing Vinhibit_redisplay.
12656 When Emacs is shutting down, perhaps because its connection to
12657 X has dropped, we should not look at them at all. */
12658 fr = XFRAME (w->frame);
12659 sf = SELECTED_FRAME ();
12660
12661 if (!fr->glyphs_initialized_p)
12662 return;
12663
12664 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
12665 if (popup_activated ())
12666 return;
12667 #endif
12668
12669 /* I don't think this happens but let's be paranoid. */
12670 if (redisplaying_p)
12671 return;
12672
12673 /* Record a function that resets redisplaying_p to its old value
12674 when we leave this function. */
12675 count = SPECPDL_INDEX ();
12676 record_unwind_protect (unwind_redisplay,
12677 Fcons (make_number (redisplaying_p), selected_frame));
12678 ++redisplaying_p;
12679 specbind (Qinhibit_free_realized_faces, Qnil);
12680
12681 {
12682 Lisp_Object tail, frame;
12683
12684 FOR_EACH_FRAME (tail, frame)
12685 {
12686 struct frame *f = XFRAME (frame);
12687 f->already_hscrolled_p = 0;
12688 }
12689 }
12690
12691 retry:
12692 /* Remember the currently selected window. */
12693 sw = w;
12694
12695 if (!EQ (old_frame, selected_frame)
12696 && FRAME_LIVE_P (XFRAME (old_frame)))
12697 /* When running redisplay, we play a bit fast-and-loose and allow e.g.
12698 selected_frame and selected_window to be temporarily out-of-sync so
12699 when we come back here via `goto retry', we need to resync because we
12700 may need to run Elisp code (via prepare_menu_bars). */
12701 select_frame_for_redisplay (old_frame);
12702
12703 pending = 0;
12704 reconsider_clip_changes (w, current_buffer);
12705 last_escape_glyph_frame = NULL;
12706 last_escape_glyph_face_id = (1 << FACE_ID_BITS);
12707 last_glyphless_glyph_frame = NULL;
12708 last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
12709
12710 /* If new fonts have been loaded that make a glyph matrix adjustment
12711 necessary, do it. */
12712 if (fonts_changed_p)
12713 {
12714 adjust_glyphs (NULL);
12715 ++windows_or_buffers_changed;
12716 fonts_changed_p = 0;
12717 }
12718
12719 /* If face_change_count is non-zero, init_iterator will free all
12720 realized faces, which includes the faces referenced from current
12721 matrices. So, we can't reuse current matrices in this case. */
12722 if (face_change_count)
12723 ++windows_or_buffers_changed;
12724
12725 if ((FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
12726 && FRAME_TTY (sf)->previous_frame != sf)
12727 {
12728 /* Since frames on a single ASCII terminal share the same
12729 display area, displaying a different frame means redisplay
12730 the whole thing. */
12731 windows_or_buffers_changed++;
12732 SET_FRAME_GARBAGED (sf);
12733 #ifndef DOS_NT
12734 set_tty_color_mode (FRAME_TTY (sf), sf);
12735 #endif
12736 FRAME_TTY (sf)->previous_frame = sf;
12737 }
12738
12739 /* Set the visible flags for all frames. Do this before checking
12740 for resized or garbaged frames; they want to know if their frames
12741 are visible. See the comment in frame.h for
12742 FRAME_SAMPLE_VISIBILITY. */
12743 {
12744 Lisp_Object tail, frame;
12745
12746 number_of_visible_frames = 0;
12747
12748 FOR_EACH_FRAME (tail, frame)
12749 {
12750 struct frame *f = XFRAME (frame);
12751
12752 FRAME_SAMPLE_VISIBILITY (f);
12753 if (FRAME_VISIBLE_P (f))
12754 ++number_of_visible_frames;
12755 clear_desired_matrices (f);
12756 }
12757 }
12758
12759 /* Notice any pending interrupt request to change frame size. */
12760 do_pending_window_change (1);
12761
12762 /* do_pending_window_change could change the selected_window due to
12763 frame resizing which makes the selected window too small. */
12764 if (WINDOWP (selected_window) && (w = XWINDOW (selected_window)) != sw)
12765 {
12766 sw = w;
12767 reconsider_clip_changes (w, current_buffer);
12768 }
12769
12770 /* Clear frames marked as garbaged. */
12771 if (frame_garbaged)
12772 clear_garbaged_frames ();
12773
12774 /* Build menubar and tool-bar items. */
12775 if (NILP (Vmemory_full))
12776 prepare_menu_bars ();
12777
12778 if (windows_or_buffers_changed)
12779 update_mode_lines++;
12780
12781 /* Detect case that we need to write or remove a star in the mode line. */
12782 if ((SAVE_MODIFF < MODIFF) != !NILP (w->last_had_star))
12783 {
12784 w->update_mode_line = Qt;
12785 if (buffer_shared > 1)
12786 update_mode_lines++;
12787 }
12788
12789 /* Avoid invocation of point motion hooks by `current_column' below. */
12790 count1 = SPECPDL_INDEX ();
12791 specbind (Qinhibit_point_motion_hooks, Qt);
12792
12793 /* If %c is in the mode line, update it if needed. */
12794 if (!NILP (w->column_number_displayed)
12795 /* This alternative quickly identifies a common case
12796 where no change is needed. */
12797 && !(PT == XFASTINT (w->last_point)
12798 && XFASTINT (w->last_modified) >= MODIFF
12799 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
12800 && (XFASTINT (w->column_number_displayed) != current_column ()))
12801 w->update_mode_line = Qt;
12802
12803 unbind_to (count1, Qnil);
12804
12805 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w->frame)) = -1;
12806
12807 /* The variable buffer_shared is set in redisplay_window and
12808 indicates that we redisplay a buffer in different windows. See
12809 there. */
12810 consider_all_windows_p = (update_mode_lines || buffer_shared > 1
12811 || cursor_type_changed);
12812
12813 /* If specs for an arrow have changed, do thorough redisplay
12814 to ensure we remove any arrow that should no longer exist. */
12815 if (overlay_arrows_changed_p ())
12816 consider_all_windows_p = windows_or_buffers_changed = 1;
12817
12818 /* Normally the message* functions will have already displayed and
12819 updated the echo area, but the frame may have been trashed, or
12820 the update may have been preempted, so display the echo area
12821 again here. Checking message_cleared_p captures the case that
12822 the echo area should be cleared. */
12823 if ((!NILP (echo_area_buffer[0]) && !display_last_displayed_message_p)
12824 || (!NILP (echo_area_buffer[1]) && display_last_displayed_message_p)
12825 || (message_cleared_p
12826 && minibuf_level == 0
12827 /* If the mini-window is currently selected, this means the
12828 echo-area doesn't show through. */
12829 && !MINI_WINDOW_P (XWINDOW (selected_window))))
12830 {
12831 int window_height_changed_p = echo_area_display (0);
12832 must_finish = 1;
12833
12834 /* If we don't display the current message, don't clear the
12835 message_cleared_p flag, because, if we did, we wouldn't clear
12836 the echo area in the next redisplay which doesn't preserve
12837 the echo area. */
12838 if (!display_last_displayed_message_p)
12839 message_cleared_p = 0;
12840
12841 if (fonts_changed_p)
12842 goto retry;
12843 else if (window_height_changed_p)
12844 {
12845 consider_all_windows_p = 1;
12846 ++update_mode_lines;
12847 ++windows_or_buffers_changed;
12848
12849 /* If window configuration was changed, frames may have been
12850 marked garbaged. Clear them or we will experience
12851 surprises wrt scrolling. */
12852 if (frame_garbaged)
12853 clear_garbaged_frames ();
12854 }
12855 }
12856 else if (EQ (selected_window, minibuf_window)
12857 && (current_buffer->clip_changed
12858 || XFASTINT (w->last_modified) < MODIFF
12859 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF)
12860 && resize_mini_window (w, 0))
12861 {
12862 /* Resized active mini-window to fit the size of what it is
12863 showing if its contents might have changed. */
12864 must_finish = 1;
12865 /* FIXME: this causes all frames to be updated, which seems unnecessary
12866 since only the current frame needs to be considered. This function needs
12867 to be rewritten with two variables, consider_all_windows and
12868 consider_all_frames. */
12869 consider_all_windows_p = 1;
12870 ++windows_or_buffers_changed;
12871 ++update_mode_lines;
12872
12873 /* If window configuration was changed, frames may have been
12874 marked garbaged. Clear them or we will experience
12875 surprises wrt scrolling. */
12876 if (frame_garbaged)
12877 clear_garbaged_frames ();
12878 }
12879
12880
12881 /* If showing the region, and mark has changed, we must redisplay
12882 the whole window. The assignment to this_line_start_pos prevents
12883 the optimization directly below this if-statement. */
12884 if (((!NILP (Vtransient_mark_mode)
12885 && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
12886 != !NILP (w->region_showing))
12887 || (!NILP (w->region_showing)
12888 && !EQ (w->region_showing,
12889 Fmarker_position (BVAR (XBUFFER (w->buffer), mark)))))
12890 CHARPOS (this_line_start_pos) = 0;
12891
12892 /* Optimize the case that only the line containing the cursor in the
12893 selected window has changed. Variables starting with this_ are
12894 set in display_line and record information about the line
12895 containing the cursor. */
12896 tlbufpos = this_line_start_pos;
12897 tlendpos = this_line_end_pos;
12898 if (!consider_all_windows_p
12899 && CHARPOS (tlbufpos) > 0
12900 && NILP (w->update_mode_line)
12901 && !current_buffer->clip_changed
12902 && !current_buffer->prevent_redisplay_optimizations_p
12903 && FRAME_VISIBLE_P (XFRAME (w->frame))
12904 && !FRAME_OBSCURED_P (XFRAME (w->frame))
12905 /* Make sure recorded data applies to current buffer, etc. */
12906 && this_line_buffer == current_buffer
12907 && current_buffer == XBUFFER (w->buffer)
12908 && NILP (w->force_start)
12909 && NILP (w->optional_new_start)
12910 /* Point must be on the line that we have info recorded about. */
12911 && PT >= CHARPOS (tlbufpos)
12912 && PT <= Z - CHARPOS (tlendpos)
12913 /* All text outside that line, including its final newline,
12914 must be unchanged. */
12915 && text_outside_line_unchanged_p (w, CHARPOS (tlbufpos),
12916 CHARPOS (tlendpos)))
12917 {
12918 if (CHARPOS (tlbufpos) > BEGV
12919 && FETCH_BYTE (BYTEPOS (tlbufpos) - 1) != '\n'
12920 && (CHARPOS (tlbufpos) == ZV
12921 || FETCH_BYTE (BYTEPOS (tlbufpos)) == '\n'))
12922 /* Former continuation line has disappeared by becoming empty. */
12923 goto cancel;
12924 else if (XFASTINT (w->last_modified) < MODIFF
12925 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF
12926 || MINI_WINDOW_P (w))
12927 {
12928 /* We have to handle the case of continuation around a
12929 wide-column character (see the comment in indent.c around
12930 line 1340).
12931
12932 For instance, in the following case:
12933
12934 -------- Insert --------
12935 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
12936 J_I_ ==> J_I_ `^^' are cursors.
12937 ^^ ^^
12938 -------- --------
12939
12940 As we have to redraw the line above, we cannot use this
12941 optimization. */
12942
12943 struct it it;
12944 int line_height_before = this_line_pixel_height;
12945
12946 /* Note that start_display will handle the case that the
12947 line starting at tlbufpos is a continuation line. */
12948 start_display (&it, w, tlbufpos);
12949
12950 /* Implementation note: It this still necessary? */
12951 if (it.current_x != this_line_start_x)
12952 goto cancel;
12953
12954 TRACE ((stderr, "trying display optimization 1\n"));
12955 w->cursor.vpos = -1;
12956 overlay_arrow_seen = 0;
12957 it.vpos = this_line_vpos;
12958 it.current_y = this_line_y;
12959 it.glyph_row = MATRIX_ROW (w->desired_matrix, this_line_vpos);
12960 display_line (&it);
12961
12962 /* If line contains point, is not continued,
12963 and ends at same distance from eob as before, we win. */
12964 if (w->cursor.vpos >= 0
12965 /* Line is not continued, otherwise this_line_start_pos
12966 would have been set to 0 in display_line. */
12967 && CHARPOS (this_line_start_pos)
12968 /* Line ends as before. */
12969 && CHARPOS (this_line_end_pos) == CHARPOS (tlendpos)
12970 /* Line has same height as before. Otherwise other lines
12971 would have to be shifted up or down. */
12972 && this_line_pixel_height == line_height_before)
12973 {
12974 /* If this is not the window's last line, we must adjust
12975 the charstarts of the lines below. */
12976 if (it.current_y < it.last_visible_y)
12977 {
12978 struct glyph_row *row
12979 = MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
12980 ptrdiff_t delta, delta_bytes;
12981
12982 /* We used to distinguish between two cases here,
12983 conditioned by Z - CHARPOS (tlendpos) == ZV, for
12984 when the line ends in a newline or the end of the
12985 buffer's accessible portion. But both cases did
12986 the same, so they were collapsed. */
12987 delta = (Z
12988 - CHARPOS (tlendpos)
12989 - MATRIX_ROW_START_CHARPOS (row));
12990 delta_bytes = (Z_BYTE
12991 - BYTEPOS (tlendpos)
12992 - MATRIX_ROW_START_BYTEPOS (row));
12993
12994 increment_matrix_positions (w->current_matrix,
12995 this_line_vpos + 1,
12996 w->current_matrix->nrows,
12997 delta, delta_bytes);
12998 }
12999
13000 /* If this row displays text now but previously didn't,
13001 or vice versa, w->window_end_vpos may have to be
13002 adjusted. */
13003 if ((it.glyph_row - 1)->displays_text_p)
13004 {
13005 if (XFASTINT (w->window_end_vpos) < this_line_vpos)
13006 XSETINT (w->window_end_vpos, this_line_vpos);
13007 }
13008 else if (XFASTINT (w->window_end_vpos) == this_line_vpos
13009 && this_line_vpos > 0)
13010 XSETINT (w->window_end_vpos, this_line_vpos - 1);
13011 w->window_end_valid = Qnil;
13012
13013 /* Update hint: No need to try to scroll in update_window. */
13014 w->desired_matrix->no_scrolling_p = 1;
13015
13016 #if GLYPH_DEBUG
13017 *w->desired_matrix->method = 0;
13018 debug_method_add (w, "optimization 1");
13019 #endif
13020 #ifdef HAVE_WINDOW_SYSTEM
13021 update_window_fringes (w, 0);
13022 #endif
13023 goto update;
13024 }
13025 else
13026 goto cancel;
13027 }
13028 else if (/* Cursor position hasn't changed. */
13029 PT == XFASTINT (w->last_point)
13030 /* Make sure the cursor was last displayed
13031 in this window. Otherwise we have to reposition it. */
13032 && 0 <= w->cursor.vpos
13033 && WINDOW_TOTAL_LINES (w) > w->cursor.vpos)
13034 {
13035 if (!must_finish)
13036 {
13037 do_pending_window_change (1);
13038 /* If selected_window changed, redisplay again. */
13039 if (WINDOWP (selected_window)
13040 && (w = XWINDOW (selected_window)) != sw)
13041 goto retry;
13042
13043 /* We used to always goto end_of_redisplay here, but this
13044 isn't enough if we have a blinking cursor. */
13045 if (w->cursor_off_p == w->last_cursor_off_p)
13046 goto end_of_redisplay;
13047 }
13048 goto update;
13049 }
13050 /* If highlighting the region, or if the cursor is in the echo area,
13051 then we can't just move the cursor. */
13052 else if (! (!NILP (Vtransient_mark_mode)
13053 && !NILP (BVAR (current_buffer, mark_active)))
13054 && (EQ (selected_window, BVAR (current_buffer, last_selected_window))
13055 || highlight_nonselected_windows)
13056 && NILP (w->region_showing)
13057 && NILP (Vshow_trailing_whitespace)
13058 && !cursor_in_echo_area)
13059 {
13060 struct it it;
13061 struct glyph_row *row;
13062
13063 /* Skip from tlbufpos to PT and see where it is. Note that
13064 PT may be in invisible text. If so, we will end at the
13065 next visible position. */
13066 init_iterator (&it, w, CHARPOS (tlbufpos), BYTEPOS (tlbufpos),
13067 NULL, DEFAULT_FACE_ID);
13068 it.current_x = this_line_start_x;
13069 it.current_y = this_line_y;
13070 it.vpos = this_line_vpos;
13071
13072 /* The call to move_it_to stops in front of PT, but
13073 moves over before-strings. */
13074 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
13075
13076 if (it.vpos == this_line_vpos
13077 && (row = MATRIX_ROW (w->current_matrix, this_line_vpos),
13078 row->enabled_p))
13079 {
13080 xassert (this_line_vpos == it.vpos);
13081 xassert (this_line_y == it.current_y);
13082 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
13083 #if GLYPH_DEBUG
13084 *w->desired_matrix->method = 0;
13085 debug_method_add (w, "optimization 3");
13086 #endif
13087 goto update;
13088 }
13089 else
13090 goto cancel;
13091 }
13092
13093 cancel:
13094 /* Text changed drastically or point moved off of line. */
13095 SET_MATRIX_ROW_ENABLED_P (w->desired_matrix, this_line_vpos, 0);
13096 }
13097
13098 CHARPOS (this_line_start_pos) = 0;
13099 consider_all_windows_p |= buffer_shared > 1;
13100 ++clear_face_cache_count;
13101 #ifdef HAVE_WINDOW_SYSTEM
13102 ++clear_image_cache_count;
13103 #endif
13104
13105 /* Build desired matrices, and update the display. If
13106 consider_all_windows_p is non-zero, do it for all windows on all
13107 frames. Otherwise do it for selected_window, only. */
13108
13109 if (consider_all_windows_p)
13110 {
13111 Lisp_Object tail, frame;
13112
13113 FOR_EACH_FRAME (tail, frame)
13114 XFRAME (frame)->updated_p = 0;
13115
13116 /* Recompute # windows showing selected buffer. This will be
13117 incremented each time such a window is displayed. */
13118 buffer_shared = 0;
13119
13120 FOR_EACH_FRAME (tail, frame)
13121 {
13122 struct frame *f = XFRAME (frame);
13123
13124 if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
13125 {
13126 if (! EQ (frame, selected_frame))
13127 /* Select the frame, for the sake of frame-local
13128 variables. */
13129 select_frame_for_redisplay (frame);
13130
13131 /* Mark all the scroll bars to be removed; we'll redeem
13132 the ones we want when we redisplay their windows. */
13133 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
13134 FRAME_TERMINAL (f)->condemn_scroll_bars_hook (f);
13135
13136 if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
13137 redisplay_windows (FRAME_ROOT_WINDOW (f));
13138
13139 /* The X error handler may have deleted that frame. */
13140 if (!FRAME_LIVE_P (f))
13141 continue;
13142
13143 /* Any scroll bars which redisplay_windows should have
13144 nuked should now go away. */
13145 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
13146 FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
13147
13148 /* If fonts changed, display again. */
13149 /* ??? rms: I suspect it is a mistake to jump all the way
13150 back to retry here. It should just retry this frame. */
13151 if (fonts_changed_p)
13152 goto retry;
13153
13154 if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
13155 {
13156 /* See if we have to hscroll. */
13157 if (!f->already_hscrolled_p)
13158 {
13159 f->already_hscrolled_p = 1;
13160 if (hscroll_windows (f->root_window))
13161 goto retry;
13162 }
13163
13164 /* Prevent various kinds of signals during display
13165 update. stdio is not robust about handling
13166 signals, which can cause an apparent I/O
13167 error. */
13168 if (interrupt_input)
13169 unrequest_sigio ();
13170 STOP_POLLING;
13171
13172 /* Update the display. */
13173 set_window_update_flags (XWINDOW (f->root_window), 1);
13174 pending |= update_frame (f, 0, 0);
13175 f->updated_p = 1;
13176 }
13177 }
13178 }
13179
13180 if (!EQ (old_frame, selected_frame)
13181 && FRAME_LIVE_P (XFRAME (old_frame)))
13182 /* We played a bit fast-and-loose above and allowed selected_frame
13183 and selected_window to be temporarily out-of-sync but let's make
13184 sure this stays contained. */
13185 select_frame_for_redisplay (old_frame);
13186 eassert (EQ (XFRAME (selected_frame)->selected_window, selected_window));
13187
13188 if (!pending)
13189 {
13190 /* Do the mark_window_display_accurate after all windows have
13191 been redisplayed because this call resets flags in buffers
13192 which are needed for proper redisplay. */
13193 FOR_EACH_FRAME (tail, frame)
13194 {
13195 struct frame *f = XFRAME (frame);
13196 if (f->updated_p)
13197 {
13198 mark_window_display_accurate (f->root_window, 1);
13199 if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
13200 FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
13201 }
13202 }
13203 }
13204 }
13205 else if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
13206 {
13207 Lisp_Object mini_window;
13208 struct frame *mini_frame;
13209
13210 displayed_buffer = XBUFFER (XWINDOW (selected_window)->buffer);
13211 /* Use list_of_error, not Qerror, so that
13212 we catch only errors and don't run the debugger. */
13213 internal_condition_case_1 (redisplay_window_1, selected_window,
13214 list_of_error,
13215 redisplay_window_error);
13216
13217 /* Compare desired and current matrices, perform output. */
13218
13219 update:
13220 /* If fonts changed, display again. */
13221 if (fonts_changed_p)
13222 goto retry;
13223
13224 /* Prevent various kinds of signals during display update.
13225 stdio is not robust about handling signals,
13226 which can cause an apparent I/O error. */
13227 if (interrupt_input)
13228 unrequest_sigio ();
13229 STOP_POLLING;
13230
13231 if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
13232 {
13233 if (hscroll_windows (selected_window))
13234 goto retry;
13235
13236 XWINDOW (selected_window)->must_be_updated_p = 1;
13237 pending = update_frame (sf, 0, 0);
13238 }
13239
13240 /* We may have called echo_area_display at the top of this
13241 function. If the echo area is on another frame, that may
13242 have put text on a frame other than the selected one, so the
13243 above call to update_frame would not have caught it. Catch
13244 it here. */
13245 mini_window = FRAME_MINIBUF_WINDOW (sf);
13246 mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
13247
13248 if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
13249 {
13250 XWINDOW (mini_window)->must_be_updated_p = 1;
13251 pending |= update_frame (mini_frame, 0, 0);
13252 if (!pending && hscroll_windows (mini_window))
13253 goto retry;
13254 }
13255 }
13256
13257 /* If display was paused because of pending input, make sure we do a
13258 thorough update the next time. */
13259 if (pending)
13260 {
13261 /* Prevent the optimization at the beginning of
13262 redisplay_internal that tries a single-line update of the
13263 line containing the cursor in the selected window. */
13264 CHARPOS (this_line_start_pos) = 0;
13265
13266 /* Let the overlay arrow be updated the next time. */
13267 update_overlay_arrows (0);
13268
13269 /* If we pause after scrolling, some rows in the current
13270 matrices of some windows are not valid. */
13271 if (!WINDOW_FULL_WIDTH_P (w)
13272 && !FRAME_WINDOW_P (XFRAME (w->frame)))
13273 update_mode_lines = 1;
13274 }
13275 else
13276 {
13277 if (!consider_all_windows_p)
13278 {
13279 /* This has already been done above if
13280 consider_all_windows_p is set. */
13281 mark_window_display_accurate_1 (w, 1);
13282
13283 /* Say overlay arrows are up to date. */
13284 update_overlay_arrows (1);
13285
13286 if (FRAME_TERMINAL (sf)->frame_up_to_date_hook != 0)
13287 FRAME_TERMINAL (sf)->frame_up_to_date_hook (sf);
13288 }
13289
13290 update_mode_lines = 0;
13291 windows_or_buffers_changed = 0;
13292 cursor_type_changed = 0;
13293 }
13294
13295 /* Start SIGIO interrupts coming again. Having them off during the
13296 code above makes it less likely one will discard output, but not
13297 impossible, since there might be stuff in the system buffer here.
13298 But it is much hairier to try to do anything about that. */
13299 if (interrupt_input)
13300 request_sigio ();
13301 RESUME_POLLING;
13302
13303 /* If a frame has become visible which was not before, redisplay
13304 again, so that we display it. Expose events for such a frame
13305 (which it gets when becoming visible) don't call the parts of
13306 redisplay constructing glyphs, so simply exposing a frame won't
13307 display anything in this case. So, we have to display these
13308 frames here explicitly. */
13309 if (!pending)
13310 {
13311 Lisp_Object tail, frame;
13312 int new_count = 0;
13313
13314 FOR_EACH_FRAME (tail, frame)
13315 {
13316 int this_is_visible = 0;
13317
13318 if (XFRAME (frame)->visible)
13319 this_is_visible = 1;
13320 FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
13321 if (XFRAME (frame)->visible)
13322 this_is_visible = 1;
13323
13324 if (this_is_visible)
13325 new_count++;
13326 }
13327
13328 if (new_count != number_of_visible_frames)
13329 windows_or_buffers_changed++;
13330 }
13331
13332 /* Change frame size now if a change is pending. */
13333 do_pending_window_change (1);
13334
13335 /* If we just did a pending size change, or have additional
13336 visible frames, or selected_window changed, redisplay again. */
13337 if ((windows_or_buffers_changed && !pending)
13338 || (WINDOWP (selected_window) && (w = XWINDOW (selected_window)) != sw))
13339 goto retry;
13340
13341 /* Clear the face and image caches.
13342
13343 We used to do this only if consider_all_windows_p. But the cache
13344 needs to be cleared if a timer creates images in the current
13345 buffer (e.g. the test case in Bug#6230). */
13346
13347 if (clear_face_cache_count > CLEAR_FACE_CACHE_COUNT)
13348 {
13349 clear_face_cache (0);
13350 clear_face_cache_count = 0;
13351 }
13352
13353 #ifdef HAVE_WINDOW_SYSTEM
13354 if (clear_image_cache_count > CLEAR_IMAGE_CACHE_COUNT)
13355 {
13356 clear_image_caches (Qnil);
13357 clear_image_cache_count = 0;
13358 }
13359 #endif /* HAVE_WINDOW_SYSTEM */
13360
13361 end_of_redisplay:
13362 unbind_to (count, Qnil);
13363 RESUME_POLLING;
13364 }
13365
13366
13367 /* Redisplay, but leave alone any recent echo area message unless
13368 another message has been requested in its place.
13369
13370 This is useful in situations where you need to redisplay but no
13371 user action has occurred, making it inappropriate for the message
13372 area to be cleared. See tracking_off and
13373 wait_reading_process_output for examples of these situations.
13374
13375 FROM_WHERE is an integer saying from where this function was
13376 called. This is useful for debugging. */
13377
13378 void
13379 redisplay_preserve_echo_area (int from_where)
13380 {
13381 TRACE ((stderr, "redisplay_preserve_echo_area (%d)\n", from_where));
13382
13383 if (!NILP (echo_area_buffer[1]))
13384 {
13385 /* We have a previously displayed message, but no current
13386 message. Redisplay the previous message. */
13387 display_last_displayed_message_p = 1;
13388 redisplay_internal ();
13389 display_last_displayed_message_p = 0;
13390 }
13391 else
13392 redisplay_internal ();
13393
13394 if (FRAME_RIF (SELECTED_FRAME ()) != NULL
13395 && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
13396 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL);
13397 }
13398
13399
13400 /* Function registered with record_unwind_protect in
13401 redisplay_internal. Reset redisplaying_p to the value it had
13402 before redisplay_internal was called, and clear
13403 prevent_freeing_realized_faces_p. It also selects the previously
13404 selected frame, unless it has been deleted (by an X connection
13405 failure during redisplay, for example). */
13406
13407 static Lisp_Object
13408 unwind_redisplay (Lisp_Object val)
13409 {
13410 Lisp_Object old_redisplaying_p, old_frame;
13411
13412 old_redisplaying_p = XCAR (val);
13413 redisplaying_p = XFASTINT (old_redisplaying_p);
13414 old_frame = XCDR (val);
13415 if (! EQ (old_frame, selected_frame)
13416 && FRAME_LIVE_P (XFRAME (old_frame)))
13417 select_frame_for_redisplay (old_frame);
13418 return Qnil;
13419 }
13420
13421
13422 /* Mark the display of window W as accurate or inaccurate. If
13423 ACCURATE_P is non-zero mark display of W as accurate. If
13424 ACCURATE_P is zero, arrange for W to be redisplayed the next time
13425 redisplay_internal is called. */
13426
13427 static void
13428 mark_window_display_accurate_1 (struct window *w, int accurate_p)
13429 {
13430 if (BUFFERP (w->buffer))
13431 {
13432 struct buffer *b = XBUFFER (w->buffer);
13433
13434 w->last_modified
13435 = make_number (accurate_p ? BUF_MODIFF (b) : 0);
13436 w->last_overlay_modified
13437 = make_number (accurate_p ? BUF_OVERLAY_MODIFF (b) : 0);
13438 w->last_had_star
13439 = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b) ? Qt : Qnil;
13440
13441 if (accurate_p)
13442 {
13443 b->clip_changed = 0;
13444 b->prevent_redisplay_optimizations_p = 0;
13445
13446 BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
13447 BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
13448 BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
13449 BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
13450
13451 w->current_matrix->buffer = b;
13452 w->current_matrix->begv = BUF_BEGV (b);
13453 w->current_matrix->zv = BUF_ZV (b);
13454
13455 w->last_cursor = w->cursor;
13456 w->last_cursor_off_p = w->cursor_off_p;
13457
13458 if (w == XWINDOW (selected_window))
13459 w->last_point = make_number (BUF_PT (b));
13460 else
13461 w->last_point = make_number (XMARKER (w->pointm)->charpos);
13462 }
13463 }
13464
13465 if (accurate_p)
13466 {
13467 w->window_end_valid = w->buffer;
13468 w->update_mode_line = Qnil;
13469 }
13470 }
13471
13472
13473 /* Mark the display of windows in the window tree rooted at WINDOW as
13474 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
13475 windows as accurate. If ACCURATE_P is zero, arrange for windows to
13476 be redisplayed the next time redisplay_internal is called. */
13477
13478 void
13479 mark_window_display_accurate (Lisp_Object window, int accurate_p)
13480 {
13481 struct window *w;
13482
13483 for (; !NILP (window); window = w->next)
13484 {
13485 w = XWINDOW (window);
13486 mark_window_display_accurate_1 (w, accurate_p);
13487
13488 if (!NILP (w->vchild))
13489 mark_window_display_accurate (w->vchild, accurate_p);
13490 if (!NILP (w->hchild))
13491 mark_window_display_accurate (w->hchild, accurate_p);
13492 }
13493
13494 if (accurate_p)
13495 {
13496 update_overlay_arrows (1);
13497 }
13498 else
13499 {
13500 /* Force a thorough redisplay the next time by setting
13501 last_arrow_position and last_arrow_string to t, which is
13502 unequal to any useful value of Voverlay_arrow_... */
13503 update_overlay_arrows (-1);
13504 }
13505 }
13506
13507
13508 /* Return value in display table DP (Lisp_Char_Table *) for character
13509 C. Since a display table doesn't have any parent, we don't have to
13510 follow parent. Do not call this function directly but use the
13511 macro DISP_CHAR_VECTOR. */
13512
13513 Lisp_Object
13514 disp_char_vector (struct Lisp_Char_Table *dp, int c)
13515 {
13516 Lisp_Object val;
13517
13518 if (ASCII_CHAR_P (c))
13519 {
13520 val = dp->ascii;
13521 if (SUB_CHAR_TABLE_P (val))
13522 val = XSUB_CHAR_TABLE (val)->contents[c];
13523 }
13524 else
13525 {
13526 Lisp_Object table;
13527
13528 XSETCHAR_TABLE (table, dp);
13529 val = char_table_ref (table, c);
13530 }
13531 if (NILP (val))
13532 val = dp->defalt;
13533 return val;
13534 }
13535
13536
13537 \f
13538 /***********************************************************************
13539 Window Redisplay
13540 ***********************************************************************/
13541
13542 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
13543
13544 static void
13545 redisplay_windows (Lisp_Object window)
13546 {
13547 while (!NILP (window))
13548 {
13549 struct window *w = XWINDOW (window);
13550
13551 if (!NILP (w->hchild))
13552 redisplay_windows (w->hchild);
13553 else if (!NILP (w->vchild))
13554 redisplay_windows (w->vchild);
13555 else if (!NILP (w->buffer))
13556 {
13557 displayed_buffer = XBUFFER (w->buffer);
13558 /* Use list_of_error, not Qerror, so that
13559 we catch only errors and don't run the debugger. */
13560 internal_condition_case_1 (redisplay_window_0, window,
13561 list_of_error,
13562 redisplay_window_error);
13563 }
13564
13565 window = w->next;
13566 }
13567 }
13568
13569 static Lisp_Object
13570 redisplay_window_error (Lisp_Object ignore)
13571 {
13572 displayed_buffer->display_error_modiff = BUF_MODIFF (displayed_buffer);
13573 return Qnil;
13574 }
13575
13576 static Lisp_Object
13577 redisplay_window_0 (Lisp_Object window)
13578 {
13579 if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
13580 redisplay_window (window, 0);
13581 return Qnil;
13582 }
13583
13584 static Lisp_Object
13585 redisplay_window_1 (Lisp_Object window)
13586 {
13587 if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
13588 redisplay_window (window, 1);
13589 return Qnil;
13590 }
13591 \f
13592
13593 /* Set cursor position of W. PT is assumed to be displayed in ROW.
13594 DELTA and DELTA_BYTES are the numbers of characters and bytes by
13595 which positions recorded in ROW differ from current buffer
13596 positions.
13597
13598 Return 0 if cursor is not on this row, 1 otherwise. */
13599
13600 static int
13601 set_cursor_from_row (struct window *w, struct glyph_row *row,
13602 struct glyph_matrix *matrix,
13603 ptrdiff_t delta, ptrdiff_t delta_bytes,
13604 int dy, int dvpos)
13605 {
13606 struct glyph *glyph = row->glyphs[TEXT_AREA];
13607 struct glyph *end = glyph + row->used[TEXT_AREA];
13608 struct glyph *cursor = NULL;
13609 /* The last known character position in row. */
13610 ptrdiff_t last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
13611 int x = row->x;
13612 ptrdiff_t pt_old = PT - delta;
13613 ptrdiff_t pos_before = MATRIX_ROW_START_CHARPOS (row) + delta;
13614 ptrdiff_t pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
13615 struct glyph *glyph_before = glyph - 1, *glyph_after = end;
13616 /* A glyph beyond the edge of TEXT_AREA which we should never
13617 touch. */
13618 struct glyph *glyphs_end = end;
13619 /* Non-zero means we've found a match for cursor position, but that
13620 glyph has the avoid_cursor_p flag set. */
13621 int match_with_avoid_cursor = 0;
13622 /* Non-zero means we've seen at least one glyph that came from a
13623 display string. */
13624 int string_seen = 0;
13625 /* Largest and smalles buffer positions seen so far during scan of
13626 glyph row. */
13627 ptrdiff_t bpos_max = pos_before;
13628 ptrdiff_t bpos_min = pos_after;
13629 /* Last buffer position covered by an overlay string with an integer
13630 `cursor' property. */
13631 ptrdiff_t bpos_covered = 0;
13632 /* Non-zero means the display string on which to display the cursor
13633 comes from a text property, not from an overlay. */
13634 int string_from_text_prop = 0;
13635
13636 /* Skip over glyphs not having an object at the start and the end of
13637 the row. These are special glyphs like truncation marks on
13638 terminal frames. */
13639 if (row->displays_text_p)
13640 {
13641 if (!row->reversed_p)
13642 {
13643 while (glyph < end
13644 && INTEGERP (glyph->object)
13645 && glyph->charpos < 0)
13646 {
13647 x += glyph->pixel_width;
13648 ++glyph;
13649 }
13650 while (end > glyph
13651 && INTEGERP ((end - 1)->object)
13652 /* CHARPOS is zero for blanks and stretch glyphs
13653 inserted by extend_face_to_end_of_line. */
13654 && (end - 1)->charpos <= 0)
13655 --end;
13656 glyph_before = glyph - 1;
13657 glyph_after = end;
13658 }
13659 else
13660 {
13661 struct glyph *g;
13662
13663 /* If the glyph row is reversed, we need to process it from back
13664 to front, so swap the edge pointers. */
13665 glyphs_end = end = glyph - 1;
13666 glyph += row->used[TEXT_AREA] - 1;
13667
13668 while (glyph > end + 1
13669 && INTEGERP (glyph->object)
13670 && glyph->charpos < 0)
13671 {
13672 --glyph;
13673 x -= glyph->pixel_width;
13674 }
13675 if (INTEGERP (glyph->object) && glyph->charpos < 0)
13676 --glyph;
13677 /* By default, in reversed rows we put the cursor on the
13678 rightmost (first in the reading order) glyph. */
13679 for (g = end + 1; g < glyph; g++)
13680 x += g->pixel_width;
13681 while (end < glyph
13682 && INTEGERP ((end + 1)->object)
13683 && (end + 1)->charpos <= 0)
13684 ++end;
13685 glyph_before = glyph + 1;
13686 glyph_after = end;
13687 }
13688 }
13689 else if (row->reversed_p)
13690 {
13691 /* In R2L rows that don't display text, put the cursor on the
13692 rightmost glyph. Case in point: an empty last line that is
13693 part of an R2L paragraph. */
13694 cursor = end - 1;
13695 /* Avoid placing the cursor on the last glyph of the row, where
13696 on terminal frames we hold the vertical border between
13697 adjacent windows. */
13698 if (!FRAME_WINDOW_P (WINDOW_XFRAME (w))
13699 && !WINDOW_RIGHTMOST_P (w)
13700 && cursor == row->glyphs[LAST_AREA] - 1)
13701 cursor--;
13702 x = -1; /* will be computed below, at label compute_x */
13703 }
13704
13705 /* Step 1: Try to find the glyph whose character position
13706 corresponds to point. If that's not possible, find 2 glyphs
13707 whose character positions are the closest to point, one before
13708 point, the other after it. */
13709 if (!row->reversed_p)
13710 while (/* not marched to end of glyph row */
13711 glyph < end
13712 /* glyph was not inserted by redisplay for internal purposes */
13713 && !INTEGERP (glyph->object))
13714 {
13715 if (BUFFERP (glyph->object))
13716 {
13717 ptrdiff_t dpos = glyph->charpos - pt_old;
13718
13719 if (glyph->charpos > bpos_max)
13720 bpos_max = glyph->charpos;
13721 if (glyph->charpos < bpos_min)
13722 bpos_min = glyph->charpos;
13723 if (!glyph->avoid_cursor_p)
13724 {
13725 /* If we hit point, we've found the glyph on which to
13726 display the cursor. */
13727 if (dpos == 0)
13728 {
13729 match_with_avoid_cursor = 0;
13730 break;
13731 }
13732 /* See if we've found a better approximation to
13733 POS_BEFORE or to POS_AFTER. Note that we want the
13734 first (leftmost) glyph of all those that are the
13735 closest from below, and the last (rightmost) of all
13736 those from above. */
13737 if (0 > dpos && dpos > pos_before - pt_old)
13738 {
13739 pos_before = glyph->charpos;
13740 glyph_before = glyph;
13741 }
13742 else if (0 < dpos && dpos <= pos_after - pt_old)
13743 {
13744 pos_after = glyph->charpos;
13745 glyph_after = glyph;
13746 }
13747 }
13748 else if (dpos == 0)
13749 match_with_avoid_cursor = 1;
13750 }
13751 else if (STRINGP (glyph->object))
13752 {
13753 Lisp_Object chprop;
13754 ptrdiff_t glyph_pos = glyph->charpos;
13755
13756 chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
13757 glyph->object);
13758 if (INTEGERP (chprop))
13759 {
13760 bpos_covered = bpos_max + XINT (chprop);
13761 /* If the `cursor' property covers buffer positions up
13762 to and including point, we should display cursor on
13763 this glyph. Note that overlays and text properties
13764 with string values stop bidi reordering, so every
13765 buffer position to the left of the string is always
13766 smaller than any position to the right of the
13767 string. Therefore, if a `cursor' property on one
13768 of the string's characters has an integer value, we
13769 will break out of the loop below _before_ we get to
13770 the position match above. IOW, integer values of
13771 the `cursor' property override the "exact match for
13772 point" strategy of positioning the cursor. */
13773 /* Implementation note: bpos_max == pt_old when, e.g.,
13774 we are in an empty line, where bpos_max is set to
13775 MATRIX_ROW_START_CHARPOS, see above. */
13776 if (bpos_max <= pt_old && bpos_covered >= pt_old)
13777 {
13778 cursor = glyph;
13779 break;
13780 }
13781 }
13782
13783 string_seen = 1;
13784 }
13785 x += glyph->pixel_width;
13786 ++glyph;
13787 }
13788 else if (glyph > end) /* row is reversed */
13789 while (!INTEGERP (glyph->object))
13790 {
13791 if (BUFFERP (glyph->object))
13792 {
13793 ptrdiff_t dpos = glyph->charpos - pt_old;
13794
13795 if (glyph->charpos > bpos_max)
13796 bpos_max = glyph->charpos;
13797 if (glyph->charpos < bpos_min)
13798 bpos_min = glyph->charpos;
13799 if (!glyph->avoid_cursor_p)
13800 {
13801 if (dpos == 0)
13802 {
13803 match_with_avoid_cursor = 0;
13804 break;
13805 }
13806 if (0 > dpos && dpos > pos_before - pt_old)
13807 {
13808 pos_before = glyph->charpos;
13809 glyph_before = glyph;
13810 }
13811 else if (0 < dpos && dpos <= pos_after - pt_old)
13812 {
13813 pos_after = glyph->charpos;
13814 glyph_after = glyph;
13815 }
13816 }
13817 else if (dpos == 0)
13818 match_with_avoid_cursor = 1;
13819 }
13820 else if (STRINGP (glyph->object))
13821 {
13822 Lisp_Object chprop;
13823 ptrdiff_t glyph_pos = glyph->charpos;
13824
13825 chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
13826 glyph->object);
13827 if (INTEGERP (chprop))
13828 {
13829 bpos_covered = bpos_max + XINT (chprop);
13830 /* If the `cursor' property covers buffer positions up
13831 to and including point, we should display cursor on
13832 this glyph. */
13833 if (bpos_max <= pt_old && bpos_covered >= pt_old)
13834 {
13835 cursor = glyph;
13836 break;
13837 }
13838 }
13839 string_seen = 1;
13840 }
13841 --glyph;
13842 if (glyph == glyphs_end) /* don't dereference outside TEXT_AREA */
13843 {
13844 x--; /* can't use any pixel_width */
13845 break;
13846 }
13847 x -= glyph->pixel_width;
13848 }
13849
13850 /* Step 2: If we didn't find an exact match for point, we need to
13851 look for a proper place to put the cursor among glyphs between
13852 GLYPH_BEFORE and GLYPH_AFTER. */
13853 if (!((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
13854 && BUFFERP (glyph->object) && glyph->charpos == pt_old)
13855 && bpos_covered < pt_old)
13856 {
13857 /* An empty line has a single glyph whose OBJECT is zero and
13858 whose CHARPOS is the position of a newline on that line.
13859 Note that on a TTY, there are more glyphs after that, which
13860 were produced by extend_face_to_end_of_line, but their
13861 CHARPOS is zero or negative. */
13862 int empty_line_p =
13863 (row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
13864 && INTEGERP (glyph->object) && glyph->charpos > 0;
13865
13866 if (row->ends_in_ellipsis_p && pos_after == last_pos)
13867 {
13868 ptrdiff_t ellipsis_pos;
13869
13870 /* Scan back over the ellipsis glyphs. */
13871 if (!row->reversed_p)
13872 {
13873 ellipsis_pos = (glyph - 1)->charpos;
13874 while (glyph > row->glyphs[TEXT_AREA]
13875 && (glyph - 1)->charpos == ellipsis_pos)
13876 glyph--, x -= glyph->pixel_width;
13877 /* That loop always goes one position too far, including
13878 the glyph before the ellipsis. So scan forward over
13879 that one. */
13880 x += glyph->pixel_width;
13881 glyph++;
13882 }
13883 else /* row is reversed */
13884 {
13885 ellipsis_pos = (glyph + 1)->charpos;
13886 while (glyph < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
13887 && (glyph + 1)->charpos == ellipsis_pos)
13888 glyph++, x += glyph->pixel_width;
13889 x -= glyph->pixel_width;
13890 glyph--;
13891 }
13892 }
13893 else if (match_with_avoid_cursor)
13894 {
13895 cursor = glyph_after;
13896 x = -1;
13897 }
13898 else if (string_seen)
13899 {
13900 int incr = row->reversed_p ? -1 : +1;
13901
13902 /* Need to find the glyph that came out of a string which is
13903 present at point. That glyph is somewhere between
13904 GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
13905 positioned between POS_BEFORE and POS_AFTER in the
13906 buffer. */
13907 struct glyph *start, *stop;
13908 ptrdiff_t pos = pos_before;
13909
13910 x = -1;
13911
13912 /* If the row ends in a newline from a display string,
13913 reordering could have moved the glyphs belonging to the
13914 string out of the [GLYPH_BEFORE..GLYPH_AFTER] range. So
13915 in this case we extend the search to the last glyph in
13916 the row that was not inserted by redisplay. */
13917 if (row->ends_in_newline_from_string_p)
13918 {
13919 glyph_after = end;
13920 pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
13921 }
13922
13923 /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
13924 correspond to POS_BEFORE and POS_AFTER, respectively. We
13925 need START and STOP in the order that corresponds to the
13926 row's direction as given by its reversed_p flag. If the
13927 directionality of characters between POS_BEFORE and
13928 POS_AFTER is the opposite of the row's base direction,
13929 these characters will have been reordered for display,
13930 and we need to reverse START and STOP. */
13931 if (!row->reversed_p)
13932 {
13933 start = min (glyph_before, glyph_after);
13934 stop = max (glyph_before, glyph_after);
13935 }
13936 else
13937 {
13938 start = max (glyph_before, glyph_after);
13939 stop = min (glyph_before, glyph_after);
13940 }
13941 for (glyph = start + incr;
13942 row->reversed_p ? glyph > stop : glyph < stop; )
13943 {
13944
13945 /* Any glyphs that come from the buffer are here because
13946 of bidi reordering. Skip them, and only pay
13947 attention to glyphs that came from some string. */
13948 if (STRINGP (glyph->object))
13949 {
13950 Lisp_Object str;
13951 ptrdiff_t tem;
13952 /* If the display property covers the newline, we
13953 need to search for it one position farther. */
13954 ptrdiff_t lim = pos_after
13955 + (pos_after == MATRIX_ROW_END_CHARPOS (row) + delta);
13956
13957 string_from_text_prop = 0;
13958 str = glyph->object;
13959 tem = string_buffer_position_lim (str, pos, lim, 0);
13960 if (tem == 0 /* from overlay */
13961 || pos <= tem)
13962 {
13963 /* If the string from which this glyph came is
13964 found in the buffer at point, then we've
13965 found the glyph we've been looking for. If
13966 it comes from an overlay (tem == 0), and it
13967 has the `cursor' property on one of its
13968 glyphs, record that glyph as a candidate for
13969 displaying the cursor. (As in the
13970 unidirectional version, we will display the
13971 cursor on the last candidate we find.) */
13972 if (tem == 0 || tem == pt_old)
13973 {
13974 /* The glyphs from this string could have
13975 been reordered. Find the one with the
13976 smallest string position. Or there could
13977 be a character in the string with the
13978 `cursor' property, which means display
13979 cursor on that character's glyph. */
13980 ptrdiff_t strpos = glyph->charpos;
13981
13982 if (tem)
13983 {
13984 cursor = glyph;
13985 string_from_text_prop = 1;
13986 }
13987 for ( ;
13988 (row->reversed_p ? glyph > stop : glyph < stop)
13989 && EQ (glyph->object, str);
13990 glyph += incr)
13991 {
13992 Lisp_Object cprop;
13993 ptrdiff_t gpos = glyph->charpos;
13994
13995 cprop = Fget_char_property (make_number (gpos),
13996 Qcursor,
13997 glyph->object);
13998 if (!NILP (cprop))
13999 {
14000 cursor = glyph;
14001 break;
14002 }
14003 if (tem && glyph->charpos < strpos)
14004 {
14005 strpos = glyph->charpos;
14006 cursor = glyph;
14007 }
14008 }
14009
14010 if (tem == pt_old)
14011 goto compute_x;
14012 }
14013 if (tem)
14014 pos = tem + 1; /* don't find previous instances */
14015 }
14016 /* This string is not what we want; skip all of the
14017 glyphs that came from it. */
14018 while ((row->reversed_p ? glyph > stop : glyph < stop)
14019 && EQ (glyph->object, str))
14020 glyph += incr;
14021 }
14022 else
14023 glyph += incr;
14024 }
14025
14026 /* If we reached the end of the line, and END was from a string,
14027 the cursor is not on this line. */
14028 if (cursor == NULL
14029 && (row->reversed_p ? glyph <= end : glyph >= end)
14030 && STRINGP (end->object)
14031 && row->continued_p)
14032 return 0;
14033 }
14034 /* A truncated row may not include PT among its character positions.
14035 Setting the cursor inside the scroll margin will trigger
14036 recalculation of hscroll in hscroll_window_tree. But if a
14037 display string covers point, defer to the string-handling
14038 code below to figure this out. */
14039 else if (row->truncated_on_left_p && pt_old < bpos_min)
14040 {
14041 cursor = glyph_before;
14042 x = -1;
14043 }
14044 else if ((row->truncated_on_right_p && pt_old > bpos_max)
14045 /* Zero-width characters produce no glyphs. */
14046 || (!empty_line_p
14047 && (row->reversed_p
14048 ? glyph_after > glyphs_end
14049 : glyph_after < glyphs_end)))
14050 {
14051 cursor = glyph_after;
14052 x = -1;
14053 }
14054 }
14055
14056 compute_x:
14057 if (cursor != NULL)
14058 glyph = cursor;
14059 if (x < 0)
14060 {
14061 struct glyph *g;
14062
14063 /* Need to compute x that corresponds to GLYPH. */
14064 for (g = row->glyphs[TEXT_AREA], x = row->x; g < glyph; g++)
14065 {
14066 if (g >= row->glyphs[TEXT_AREA] + row->used[TEXT_AREA])
14067 abort ();
14068 x += g->pixel_width;
14069 }
14070 }
14071
14072 /* ROW could be part of a continued line, which, under bidi
14073 reordering, might have other rows whose start and end charpos
14074 occlude point. Only set w->cursor if we found a better
14075 approximation to the cursor position than we have from previously
14076 examined candidate rows belonging to the same continued line. */
14077 if (/* we already have a candidate row */
14078 w->cursor.vpos >= 0
14079 /* that candidate is not the row we are processing */
14080 && MATRIX_ROW (matrix, w->cursor.vpos) != row
14081 /* Make sure cursor.vpos specifies a row whose start and end
14082 charpos occlude point, and it is valid candidate for being a
14083 cursor-row. This is because some callers of this function
14084 leave cursor.vpos at the row where the cursor was displayed
14085 during the last redisplay cycle. */
14086 && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)) <= pt_old
14087 && pt_old <= MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
14088 && cursor_row_p (MATRIX_ROW (matrix, w->cursor.vpos)))
14089 {
14090 struct glyph *g1 =
14091 MATRIX_ROW_GLYPH_START (matrix, w->cursor.vpos) + w->cursor.hpos;
14092
14093 /* Don't consider glyphs that are outside TEXT_AREA. */
14094 if (!(row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end))
14095 return 0;
14096 /* Keep the candidate whose buffer position is the closest to
14097 point or has the `cursor' property. */
14098 if (/* previous candidate is a glyph in TEXT_AREA of that row */
14099 w->cursor.hpos >= 0
14100 && w->cursor.hpos < MATRIX_ROW_USED (matrix, w->cursor.vpos)
14101 && ((BUFFERP (g1->object)
14102 && (g1->charpos == pt_old /* an exact match always wins */
14103 || (BUFFERP (glyph->object)
14104 && eabs (g1->charpos - pt_old)
14105 < eabs (glyph->charpos - pt_old))))
14106 /* previous candidate is a glyph from a string that has
14107 a non-nil `cursor' property */
14108 || (STRINGP (g1->object)
14109 && (!NILP (Fget_char_property (make_number (g1->charpos),
14110 Qcursor, g1->object))
14111 /* pevious candidate is from the same display
14112 string as this one, and the display string
14113 came from a text property */
14114 || (EQ (g1->object, glyph->object)
14115 && string_from_text_prop)
14116 /* this candidate is from newline and its
14117 position is not an exact match */
14118 || (INTEGERP (glyph->object)
14119 && glyph->charpos != pt_old)))))
14120 return 0;
14121 /* If this candidate gives an exact match, use that. */
14122 if (!((BUFFERP (glyph->object) && glyph->charpos == pt_old)
14123 /* If this candidate is a glyph created for the
14124 terminating newline of a line, and point is on that
14125 newline, it wins because it's an exact match. */
14126 || (!row->continued_p
14127 && INTEGERP (glyph->object)
14128 && glyph->charpos == 0
14129 && pt_old == MATRIX_ROW_END_CHARPOS (row) - 1))
14130 /* Otherwise, keep the candidate that comes from a row
14131 spanning less buffer positions. This may win when one or
14132 both candidate positions are on glyphs that came from
14133 display strings, for which we cannot compare buffer
14134 positions. */
14135 && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
14136 - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
14137 < MATRIX_ROW_END_CHARPOS (row) - MATRIX_ROW_START_CHARPOS (row))
14138 return 0;
14139 }
14140 w->cursor.hpos = glyph - row->glyphs[TEXT_AREA];
14141 w->cursor.x = x;
14142 w->cursor.vpos = MATRIX_ROW_VPOS (row, matrix) + dvpos;
14143 w->cursor.y = row->y + dy;
14144
14145 if (w == XWINDOW (selected_window))
14146 {
14147 if (!row->continued_p
14148 && !MATRIX_ROW_CONTINUATION_LINE_P (row)
14149 && row->x == 0)
14150 {
14151 this_line_buffer = XBUFFER (w->buffer);
14152
14153 CHARPOS (this_line_start_pos)
14154 = MATRIX_ROW_START_CHARPOS (row) + delta;
14155 BYTEPOS (this_line_start_pos)
14156 = MATRIX_ROW_START_BYTEPOS (row) + delta_bytes;
14157
14158 CHARPOS (this_line_end_pos)
14159 = Z - (MATRIX_ROW_END_CHARPOS (row) + delta);
14160 BYTEPOS (this_line_end_pos)
14161 = Z_BYTE - (MATRIX_ROW_END_BYTEPOS (row) + delta_bytes);
14162
14163 this_line_y = w->cursor.y;
14164 this_line_pixel_height = row->height;
14165 this_line_vpos = w->cursor.vpos;
14166 this_line_start_x = row->x;
14167 }
14168 else
14169 CHARPOS (this_line_start_pos) = 0;
14170 }
14171
14172 return 1;
14173 }
14174
14175
14176 /* Run window scroll functions, if any, for WINDOW with new window
14177 start STARTP. Sets the window start of WINDOW to that position.
14178
14179 We assume that the window's buffer is really current. */
14180
14181 static inline struct text_pos
14182 run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
14183 {
14184 struct window *w = XWINDOW (window);
14185 SET_MARKER_FROM_TEXT_POS (w->start, startp);
14186
14187 if (current_buffer != XBUFFER (w->buffer))
14188 abort ();
14189
14190 if (!NILP (Vwindow_scroll_functions))
14191 {
14192 run_hook_with_args_2 (Qwindow_scroll_functions, window,
14193 make_number (CHARPOS (startp)));
14194 SET_TEXT_POS_FROM_MARKER (startp, w->start);
14195 /* In case the hook functions switch buffers. */
14196 if (current_buffer != XBUFFER (w->buffer))
14197 set_buffer_internal_1 (XBUFFER (w->buffer));
14198 }
14199
14200 return startp;
14201 }
14202
14203
14204 /* Make sure the line containing the cursor is fully visible.
14205 A value of 1 means there is nothing to be done.
14206 (Either the line is fully visible, or it cannot be made so,
14207 or we cannot tell.)
14208
14209 If FORCE_P is non-zero, return 0 even if partial visible cursor row
14210 is higher than window.
14211
14212 A value of 0 means the caller should do scrolling
14213 as if point had gone off the screen. */
14214
14215 static int
14216 cursor_row_fully_visible_p (struct window *w, int force_p, int current_matrix_p)
14217 {
14218 struct glyph_matrix *matrix;
14219 struct glyph_row *row;
14220 int window_height;
14221
14222 if (!make_cursor_line_fully_visible_p)
14223 return 1;
14224
14225 /* It's not always possible to find the cursor, e.g, when a window
14226 is full of overlay strings. Don't do anything in that case. */
14227 if (w->cursor.vpos < 0)
14228 return 1;
14229
14230 matrix = current_matrix_p ? w->current_matrix : w->desired_matrix;
14231 row = MATRIX_ROW (matrix, w->cursor.vpos);
14232
14233 /* If the cursor row is not partially visible, there's nothing to do. */
14234 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row))
14235 return 1;
14236
14237 /* If the row the cursor is in is taller than the window's height,
14238 it's not clear what to do, so do nothing. */
14239 window_height = window_box_height (w);
14240 if (row->height >= window_height)
14241 {
14242 if (!force_p || MINI_WINDOW_P (w)
14243 || w->vscroll || w->cursor.vpos == 0)
14244 return 1;
14245 }
14246 return 0;
14247 }
14248
14249
14250 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
14251 non-zero means only WINDOW is redisplayed in redisplay_internal.
14252 TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
14253 in redisplay_window to bring a partially visible line into view in
14254 the case that only the cursor has moved.
14255
14256 LAST_LINE_MISFIT should be nonzero if we're scrolling because the
14257 last screen line's vertical height extends past the end of the screen.
14258
14259 Value is
14260
14261 1 if scrolling succeeded
14262
14263 0 if scrolling didn't find point.
14264
14265 -1 if new fonts have been loaded so that we must interrupt
14266 redisplay, adjust glyph matrices, and try again. */
14267
14268 enum
14269 {
14270 SCROLLING_SUCCESS,
14271 SCROLLING_FAILED,
14272 SCROLLING_NEED_LARGER_MATRICES
14273 };
14274
14275 /* If scroll-conservatively is more than this, never recenter.
14276
14277 If you change this, don't forget to update the doc string of
14278 `scroll-conservatively' and the Emacs manual. */
14279 #define SCROLL_LIMIT 100
14280
14281 static int
14282 try_scrolling (Lisp_Object window, int just_this_one_p,
14283 ptrdiff_t arg_scroll_conservatively, ptrdiff_t scroll_step,
14284 int temp_scroll_step, int last_line_misfit)
14285 {
14286 struct window *w = XWINDOW (window);
14287 struct frame *f = XFRAME (w->frame);
14288 struct text_pos pos, startp;
14289 struct it it;
14290 int this_scroll_margin, scroll_max, rc, height;
14291 int dy = 0, amount_to_scroll = 0, scroll_down_p = 0;
14292 int extra_scroll_margin_lines = last_line_misfit ? 1 : 0;
14293 Lisp_Object aggressive;
14294 /* We will never try scrolling more than this number of lines. */
14295 int scroll_limit = SCROLL_LIMIT;
14296
14297 #if GLYPH_DEBUG
14298 debug_method_add (w, "try_scrolling");
14299 #endif
14300
14301 SET_TEXT_POS_FROM_MARKER (startp, w->start);
14302
14303 /* Compute scroll margin height in pixels. We scroll when point is
14304 within this distance from the top or bottom of the window. */
14305 if (scroll_margin > 0)
14306 this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4)
14307 * FRAME_LINE_HEIGHT (f);
14308 else
14309 this_scroll_margin = 0;
14310
14311 /* Force arg_scroll_conservatively to have a reasonable value, to
14312 avoid scrolling too far away with slow move_it_* functions. Note
14313 that the user can supply scroll-conservatively equal to
14314 `most-positive-fixnum', which can be larger than INT_MAX. */
14315 if (arg_scroll_conservatively > scroll_limit)
14316 {
14317 arg_scroll_conservatively = scroll_limit + 1;
14318 scroll_max = scroll_limit * FRAME_LINE_HEIGHT (f);
14319 }
14320 else if (scroll_step || arg_scroll_conservatively || temp_scroll_step)
14321 /* Compute how much we should try to scroll maximally to bring
14322 point into view. */
14323 scroll_max = (max (scroll_step,
14324 max (arg_scroll_conservatively, temp_scroll_step))
14325 * FRAME_LINE_HEIGHT (f));
14326 else if (NUMBERP (BVAR (current_buffer, scroll_down_aggressively))
14327 || NUMBERP (BVAR (current_buffer, scroll_up_aggressively)))
14328 /* We're trying to scroll because of aggressive scrolling but no
14329 scroll_step is set. Choose an arbitrary one. */
14330 scroll_max = 10 * FRAME_LINE_HEIGHT (f);
14331 else
14332 scroll_max = 0;
14333
14334 too_near_end:
14335
14336 /* Decide whether to scroll down. */
14337 if (PT > CHARPOS (startp))
14338 {
14339 int scroll_margin_y;
14340
14341 /* Compute the pixel ypos of the scroll margin, then move it to
14342 either that ypos or PT, whichever comes first. */
14343 start_display (&it, w, startp);
14344 scroll_margin_y = it.last_visible_y - this_scroll_margin
14345 - FRAME_LINE_HEIGHT (f) * extra_scroll_margin_lines;
14346 move_it_to (&it, PT, -1, scroll_margin_y - 1, -1,
14347 (MOVE_TO_POS | MOVE_TO_Y));
14348
14349 if (PT > CHARPOS (it.current.pos))
14350 {
14351 int y0 = line_bottom_y (&it);
14352 /* Compute how many pixels below window bottom to stop searching
14353 for PT. This avoids costly search for PT that is far away if
14354 the user limited scrolling by a small number of lines, but
14355 always finds PT if scroll_conservatively is set to a large
14356 number, such as most-positive-fixnum. */
14357 int slack = max (scroll_max, 10 * FRAME_LINE_HEIGHT (f));
14358 int y_to_move = it.last_visible_y + slack;
14359
14360 /* Compute the distance from the scroll margin to PT or to
14361 the scroll limit, whichever comes first. This should
14362 include the height of the cursor line, to make that line
14363 fully visible. */
14364 move_it_to (&it, PT, -1, y_to_move,
14365 -1, MOVE_TO_POS | MOVE_TO_Y);
14366 dy = line_bottom_y (&it) - y0;
14367
14368 if (dy > scroll_max)
14369 return SCROLLING_FAILED;
14370
14371 scroll_down_p = 1;
14372 }
14373 }
14374
14375 if (scroll_down_p)
14376 {
14377 /* Point is in or below the bottom scroll margin, so move the
14378 window start down. If scrolling conservatively, move it just
14379 enough down to make point visible. If scroll_step is set,
14380 move it down by scroll_step. */
14381 if (arg_scroll_conservatively)
14382 amount_to_scroll
14383 = min (max (dy, FRAME_LINE_HEIGHT (f)),
14384 FRAME_LINE_HEIGHT (f) * arg_scroll_conservatively);
14385 else if (scroll_step || temp_scroll_step)
14386 amount_to_scroll = scroll_max;
14387 else
14388 {
14389 aggressive = BVAR (current_buffer, scroll_up_aggressively);
14390 height = WINDOW_BOX_TEXT_HEIGHT (w);
14391 if (NUMBERP (aggressive))
14392 {
14393 double float_amount = XFLOATINT (aggressive) * height;
14394 amount_to_scroll = float_amount;
14395 if (amount_to_scroll == 0 && float_amount > 0)
14396 amount_to_scroll = 1;
14397 /* Don't let point enter the scroll margin near top of
14398 the window. */
14399 if (amount_to_scroll > height - 2*this_scroll_margin + dy)
14400 amount_to_scroll = height - 2*this_scroll_margin + dy;
14401 }
14402 }
14403
14404 if (amount_to_scroll <= 0)
14405 return SCROLLING_FAILED;
14406
14407 start_display (&it, w, startp);
14408 if (arg_scroll_conservatively <= scroll_limit)
14409 move_it_vertically (&it, amount_to_scroll);
14410 else
14411 {
14412 /* Extra precision for users who set scroll-conservatively
14413 to a large number: make sure the amount we scroll
14414 the window start is never less than amount_to_scroll,
14415 which was computed as distance from window bottom to
14416 point. This matters when lines at window top and lines
14417 below window bottom have different height. */
14418 struct it it1;
14419 void *it1data = NULL;
14420 /* We use a temporary it1 because line_bottom_y can modify
14421 its argument, if it moves one line down; see there. */
14422 int start_y;
14423
14424 SAVE_IT (it1, it, it1data);
14425 start_y = line_bottom_y (&it1);
14426 do {
14427 RESTORE_IT (&it, &it, it1data);
14428 move_it_by_lines (&it, 1);
14429 SAVE_IT (it1, it, it1data);
14430 } while (line_bottom_y (&it1) - start_y < amount_to_scroll);
14431 }
14432
14433 /* If STARTP is unchanged, move it down another screen line. */
14434 if (CHARPOS (it.current.pos) == CHARPOS (startp))
14435 move_it_by_lines (&it, 1);
14436 startp = it.current.pos;
14437 }
14438 else
14439 {
14440 struct text_pos scroll_margin_pos = startp;
14441
14442 /* See if point is inside the scroll margin at the top of the
14443 window. */
14444 if (this_scroll_margin)
14445 {
14446 start_display (&it, w, startp);
14447 move_it_vertically (&it, this_scroll_margin);
14448 scroll_margin_pos = it.current.pos;
14449 }
14450
14451 if (PT < CHARPOS (scroll_margin_pos))
14452 {
14453 /* Point is in the scroll margin at the top of the window or
14454 above what is displayed in the window. */
14455 int y0, y_to_move;
14456
14457 /* Compute the vertical distance from PT to the scroll
14458 margin position. Move as far as scroll_max allows, or
14459 one screenful, or 10 screen lines, whichever is largest.
14460 Give up if distance is greater than scroll_max. */
14461 SET_TEXT_POS (pos, PT, PT_BYTE);
14462 start_display (&it, w, pos);
14463 y0 = it.current_y;
14464 y_to_move = max (it.last_visible_y,
14465 max (scroll_max, 10 * FRAME_LINE_HEIGHT (f)));
14466 move_it_to (&it, CHARPOS (scroll_margin_pos), 0,
14467 y_to_move, -1,
14468 MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
14469 dy = it.current_y - y0;
14470 if (dy > scroll_max)
14471 return SCROLLING_FAILED;
14472
14473 /* Compute new window start. */
14474 start_display (&it, w, startp);
14475
14476 if (arg_scroll_conservatively)
14477 amount_to_scroll = max (dy, FRAME_LINE_HEIGHT (f) *
14478 max (scroll_step, temp_scroll_step));
14479 else if (scroll_step || temp_scroll_step)
14480 amount_to_scroll = scroll_max;
14481 else
14482 {
14483 aggressive = BVAR (current_buffer, scroll_down_aggressively);
14484 height = WINDOW_BOX_TEXT_HEIGHT (w);
14485 if (NUMBERP (aggressive))
14486 {
14487 double float_amount = XFLOATINT (aggressive) * height;
14488 amount_to_scroll = float_amount;
14489 if (amount_to_scroll == 0 && float_amount > 0)
14490 amount_to_scroll = 1;
14491 amount_to_scroll -=
14492 this_scroll_margin - dy - FRAME_LINE_HEIGHT (f);
14493 /* Don't let point enter the scroll margin near
14494 bottom of the window. */
14495 if (amount_to_scroll > height - 2*this_scroll_margin + dy)
14496 amount_to_scroll = height - 2*this_scroll_margin + dy;
14497 }
14498 }
14499
14500 if (amount_to_scroll <= 0)
14501 return SCROLLING_FAILED;
14502
14503 move_it_vertically_backward (&it, amount_to_scroll);
14504 startp = it.current.pos;
14505 }
14506 }
14507
14508 /* Run window scroll functions. */
14509 startp = run_window_scroll_functions (window, startp);
14510
14511 /* Display the window. Give up if new fonts are loaded, or if point
14512 doesn't appear. */
14513 if (!try_window (window, startp, 0))
14514 rc = SCROLLING_NEED_LARGER_MATRICES;
14515 else if (w->cursor.vpos < 0)
14516 {
14517 clear_glyph_matrix (w->desired_matrix);
14518 rc = SCROLLING_FAILED;
14519 }
14520 else
14521 {
14522 /* Maybe forget recorded base line for line number display. */
14523 if (!just_this_one_p
14524 || current_buffer->clip_changed
14525 || BEG_UNCHANGED < CHARPOS (startp))
14526 w->base_line_number = Qnil;
14527
14528 /* If cursor ends up on a partially visible line,
14529 treat that as being off the bottom of the screen. */
14530 if (! cursor_row_fully_visible_p (w, extra_scroll_margin_lines <= 1, 0)
14531 /* It's possible that the cursor is on the first line of the
14532 buffer, which is partially obscured due to a vscroll
14533 (Bug#7537). In that case, avoid looping forever . */
14534 && extra_scroll_margin_lines < w->desired_matrix->nrows - 1)
14535 {
14536 clear_glyph_matrix (w->desired_matrix);
14537 ++extra_scroll_margin_lines;
14538 goto too_near_end;
14539 }
14540 rc = SCROLLING_SUCCESS;
14541 }
14542
14543 return rc;
14544 }
14545
14546
14547 /* Compute a suitable window start for window W if display of W starts
14548 on a continuation line. Value is non-zero if a new window start
14549 was computed.
14550
14551 The new window start will be computed, based on W's width, starting
14552 from the start of the continued line. It is the start of the
14553 screen line with the minimum distance from the old start W->start. */
14554
14555 static int
14556 compute_window_start_on_continuation_line (struct window *w)
14557 {
14558 struct text_pos pos, start_pos;
14559 int window_start_changed_p = 0;
14560
14561 SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
14562
14563 /* If window start is on a continuation line... Window start may be
14564 < BEGV in case there's invisible text at the start of the
14565 buffer (M-x rmail, for example). */
14566 if (CHARPOS (start_pos) > BEGV
14567 && FETCH_BYTE (BYTEPOS (start_pos) - 1) != '\n')
14568 {
14569 struct it it;
14570 struct glyph_row *row;
14571
14572 /* Handle the case that the window start is out of range. */
14573 if (CHARPOS (start_pos) < BEGV)
14574 SET_TEXT_POS (start_pos, BEGV, BEGV_BYTE);
14575 else if (CHARPOS (start_pos) > ZV)
14576 SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
14577
14578 /* Find the start of the continued line. This should be fast
14579 because scan_buffer is fast (newline cache). */
14580 row = w->desired_matrix->rows + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0);
14581 init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
14582 row, DEFAULT_FACE_ID);
14583 reseat_at_previous_visible_line_start (&it);
14584
14585 /* If the line start is "too far" away from the window start,
14586 say it takes too much time to compute a new window start. */
14587 if (CHARPOS (start_pos) - IT_CHARPOS (it)
14588 < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w))
14589 {
14590 int min_distance, distance;
14591
14592 /* Move forward by display lines to find the new window
14593 start. If window width was enlarged, the new start can
14594 be expected to be > the old start. If window width was
14595 decreased, the new window start will be < the old start.
14596 So, we're looking for the display line start with the
14597 minimum distance from the old window start. */
14598 pos = it.current.pos;
14599 min_distance = INFINITY;
14600 while ((distance = eabs (CHARPOS (start_pos) - IT_CHARPOS (it))),
14601 distance < min_distance)
14602 {
14603 min_distance = distance;
14604 pos = it.current.pos;
14605 move_it_by_lines (&it, 1);
14606 }
14607
14608 /* Set the window start there. */
14609 SET_MARKER_FROM_TEXT_POS (w->start, pos);
14610 window_start_changed_p = 1;
14611 }
14612 }
14613
14614 return window_start_changed_p;
14615 }
14616
14617
14618 /* Try cursor movement in case text has not changed in window WINDOW,
14619 with window start STARTP. Value is
14620
14621 CURSOR_MOVEMENT_SUCCESS if successful
14622
14623 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
14624
14625 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
14626 display. *SCROLL_STEP is set to 1, under certain circumstances, if
14627 we want to scroll as if scroll-step were set to 1. See the code.
14628
14629 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
14630 which case we have to abort this redisplay, and adjust matrices
14631 first. */
14632
14633 enum
14634 {
14635 CURSOR_MOVEMENT_SUCCESS,
14636 CURSOR_MOVEMENT_CANNOT_BE_USED,
14637 CURSOR_MOVEMENT_MUST_SCROLL,
14638 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
14639 };
14640
14641 static int
14642 try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_step)
14643 {
14644 struct window *w = XWINDOW (window);
14645 struct frame *f = XFRAME (w->frame);
14646 int rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
14647
14648 #if GLYPH_DEBUG
14649 if (inhibit_try_cursor_movement)
14650 return rc;
14651 #endif
14652
14653 /* Handle case where text has not changed, only point, and it has
14654 not moved off the frame. */
14655 if (/* Point may be in this window. */
14656 PT >= CHARPOS (startp)
14657 /* Selective display hasn't changed. */
14658 && !current_buffer->clip_changed
14659 /* Function force-mode-line-update is used to force a thorough
14660 redisplay. It sets either windows_or_buffers_changed or
14661 update_mode_lines. So don't take a shortcut here for these
14662 cases. */
14663 && !update_mode_lines
14664 && !windows_or_buffers_changed
14665 && !cursor_type_changed
14666 /* Can't use this case if highlighting a region. When a
14667 region exists, cursor movement has to do more than just
14668 set the cursor. */
14669 && !(!NILP (Vtransient_mark_mode)
14670 && !NILP (BVAR (current_buffer, mark_active)))
14671 && NILP (w->region_showing)
14672 && NILP (Vshow_trailing_whitespace)
14673 /* Right after splitting windows, last_point may be nil. */
14674 && INTEGERP (w->last_point)
14675 /* This code is not used for mini-buffer for the sake of the case
14676 of redisplaying to replace an echo area message; since in
14677 that case the mini-buffer contents per se are usually
14678 unchanged. This code is of no real use in the mini-buffer
14679 since the handling of this_line_start_pos, etc., in redisplay
14680 handles the same cases. */
14681 && !EQ (window, minibuf_window)
14682 /* When splitting windows or for new windows, it happens that
14683 redisplay is called with a nil window_end_vpos or one being
14684 larger than the window. This should really be fixed in
14685 window.c. I don't have this on my list, now, so we do
14686 approximately the same as the old redisplay code. --gerd. */
14687 && INTEGERP (w->window_end_vpos)
14688 && XFASTINT (w->window_end_vpos) < w->current_matrix->nrows
14689 && (FRAME_WINDOW_P (f)
14690 || !overlay_arrow_in_current_buffer_p ()))
14691 {
14692 int this_scroll_margin, top_scroll_margin;
14693 struct glyph_row *row = NULL;
14694
14695 #if GLYPH_DEBUG
14696 debug_method_add (w, "cursor movement");
14697 #endif
14698
14699 /* Scroll if point within this distance from the top or bottom
14700 of the window. This is a pixel value. */
14701 if (scroll_margin > 0)
14702 {
14703 this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
14704 this_scroll_margin *= FRAME_LINE_HEIGHT (f);
14705 }
14706 else
14707 this_scroll_margin = 0;
14708
14709 top_scroll_margin = this_scroll_margin;
14710 if (WINDOW_WANTS_HEADER_LINE_P (w))
14711 top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
14712
14713 /* Start with the row the cursor was displayed during the last
14714 not paused redisplay. Give up if that row is not valid. */
14715 if (w->last_cursor.vpos < 0
14716 || w->last_cursor.vpos >= w->current_matrix->nrows)
14717 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14718 else
14719 {
14720 row = MATRIX_ROW (w->current_matrix, w->last_cursor.vpos);
14721 if (row->mode_line_p)
14722 ++row;
14723 if (!row->enabled_p)
14724 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14725 }
14726
14727 if (rc == CURSOR_MOVEMENT_CANNOT_BE_USED)
14728 {
14729 int scroll_p = 0, must_scroll = 0;
14730 int last_y = window_text_bottom_y (w) - this_scroll_margin;
14731
14732 if (PT > XFASTINT (w->last_point))
14733 {
14734 /* Point has moved forward. */
14735 while (MATRIX_ROW_END_CHARPOS (row) < PT
14736 && MATRIX_ROW_BOTTOM_Y (row) < last_y)
14737 {
14738 xassert (row->enabled_p);
14739 ++row;
14740 }
14741
14742 /* If the end position of a row equals the start
14743 position of the next row, and PT is at that position,
14744 we would rather display cursor in the next line. */
14745 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
14746 && MATRIX_ROW_END_CHARPOS (row) == PT
14747 && row < w->current_matrix->rows
14748 + w->current_matrix->nrows - 1
14749 && MATRIX_ROW_START_CHARPOS (row+1) == PT
14750 && !cursor_row_p (row))
14751 ++row;
14752
14753 /* If within the scroll margin, scroll. Note that
14754 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
14755 the next line would be drawn, and that
14756 this_scroll_margin can be zero. */
14757 if (MATRIX_ROW_BOTTOM_Y (row) > last_y
14758 || PT > MATRIX_ROW_END_CHARPOS (row)
14759 /* Line is completely visible last line in window
14760 and PT is to be set in the next line. */
14761 || (MATRIX_ROW_BOTTOM_Y (row) == last_y
14762 && PT == MATRIX_ROW_END_CHARPOS (row)
14763 && !row->ends_at_zv_p
14764 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
14765 scroll_p = 1;
14766 }
14767 else if (PT < XFASTINT (w->last_point))
14768 {
14769 /* Cursor has to be moved backward. Note that PT >=
14770 CHARPOS (startp) because of the outer if-statement. */
14771 while (!row->mode_line_p
14772 && (MATRIX_ROW_START_CHARPOS (row) > PT
14773 || (MATRIX_ROW_START_CHARPOS (row) == PT
14774 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)
14775 || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
14776 row > w->current_matrix->rows
14777 && (row-1)->ends_in_newline_from_string_p))))
14778 && (row->y > top_scroll_margin
14779 || CHARPOS (startp) == BEGV))
14780 {
14781 xassert (row->enabled_p);
14782 --row;
14783 }
14784
14785 /* Consider the following case: Window starts at BEGV,
14786 there is invisible, intangible text at BEGV, so that
14787 display starts at some point START > BEGV. It can
14788 happen that we are called with PT somewhere between
14789 BEGV and START. Try to handle that case. */
14790 if (row < w->current_matrix->rows
14791 || row->mode_line_p)
14792 {
14793 row = w->current_matrix->rows;
14794 if (row->mode_line_p)
14795 ++row;
14796 }
14797
14798 /* Due to newlines in overlay strings, we may have to
14799 skip forward over overlay strings. */
14800 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
14801 && MATRIX_ROW_END_CHARPOS (row) == PT
14802 && !cursor_row_p (row))
14803 ++row;
14804
14805 /* If within the scroll margin, scroll. */
14806 if (row->y < top_scroll_margin
14807 && CHARPOS (startp) != BEGV)
14808 scroll_p = 1;
14809 }
14810 else
14811 {
14812 /* Cursor did not move. So don't scroll even if cursor line
14813 is partially visible, as it was so before. */
14814 rc = CURSOR_MOVEMENT_SUCCESS;
14815 }
14816
14817 if (PT < MATRIX_ROW_START_CHARPOS (row)
14818 || PT > MATRIX_ROW_END_CHARPOS (row))
14819 {
14820 /* if PT is not in the glyph row, give up. */
14821 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14822 must_scroll = 1;
14823 }
14824 else if (rc != CURSOR_MOVEMENT_SUCCESS
14825 && !NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering)))
14826 {
14827 /* If rows are bidi-reordered and point moved, back up
14828 until we find a row that does not belong to a
14829 continuation line. This is because we must consider
14830 all rows of a continued line as candidates for the
14831 new cursor positioning, since row start and end
14832 positions change non-linearly with vertical position
14833 in such rows. */
14834 /* FIXME: Revisit this when glyph ``spilling'' in
14835 continuation lines' rows is implemented for
14836 bidi-reordered rows. */
14837 while (MATRIX_ROW_CONTINUATION_LINE_P (row))
14838 {
14839 xassert (row->enabled_p);
14840 --row;
14841 /* If we hit the beginning of the displayed portion
14842 without finding the first row of a continued
14843 line, give up. */
14844 if (row <= w->current_matrix->rows)
14845 {
14846 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14847 break;
14848 }
14849
14850 }
14851 }
14852 if (must_scroll)
14853 ;
14854 else if (rc != CURSOR_MOVEMENT_SUCCESS
14855 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row)
14856 && make_cursor_line_fully_visible_p)
14857 {
14858 if (PT == MATRIX_ROW_END_CHARPOS (row)
14859 && !row->ends_at_zv_p
14860 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
14861 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14862 else if (row->height > window_box_height (w))
14863 {
14864 /* If we end up in a partially visible line, let's
14865 make it fully visible, except when it's taller
14866 than the window, in which case we can't do much
14867 about it. */
14868 *scroll_step = 1;
14869 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14870 }
14871 else
14872 {
14873 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
14874 if (!cursor_row_fully_visible_p (w, 0, 1))
14875 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14876 else
14877 rc = CURSOR_MOVEMENT_SUCCESS;
14878 }
14879 }
14880 else if (scroll_p)
14881 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14882 else if (rc != CURSOR_MOVEMENT_SUCCESS
14883 && !NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering)))
14884 {
14885 /* With bidi-reordered rows, there could be more than
14886 one candidate row whose start and end positions
14887 occlude point. We need to let set_cursor_from_row
14888 find the best candidate. */
14889 /* FIXME: Revisit this when glyph ``spilling'' in
14890 continuation lines' rows is implemented for
14891 bidi-reordered rows. */
14892 int rv = 0;
14893
14894 do
14895 {
14896 int at_zv_p = 0, exact_match_p = 0;
14897
14898 if (MATRIX_ROW_START_CHARPOS (row) <= PT
14899 && PT <= MATRIX_ROW_END_CHARPOS (row)
14900 && cursor_row_p (row))
14901 rv |= set_cursor_from_row (w, row, w->current_matrix,
14902 0, 0, 0, 0);
14903 /* As soon as we've found the exact match for point,
14904 or the first suitable row whose ends_at_zv_p flag
14905 is set, we are done. */
14906 at_zv_p =
14907 MATRIX_ROW (w->current_matrix, w->cursor.vpos)->ends_at_zv_p;
14908 if (rv && !at_zv_p
14909 && w->cursor.hpos >= 0
14910 && w->cursor.hpos < MATRIX_ROW_USED (w->current_matrix,
14911 w->cursor.vpos))
14912 {
14913 struct glyph_row *candidate =
14914 MATRIX_ROW (w->current_matrix, w->cursor.vpos);
14915 struct glyph *g =
14916 candidate->glyphs[TEXT_AREA] + w->cursor.hpos;
14917 ptrdiff_t endpos = MATRIX_ROW_END_CHARPOS (candidate);
14918
14919 exact_match_p =
14920 (BUFFERP (g->object) && g->charpos == PT)
14921 || (INTEGERP (g->object)
14922 && (g->charpos == PT
14923 || (g->charpos == 0 && endpos - 1 == PT)));
14924 }
14925 if (rv && (at_zv_p || exact_match_p))
14926 {
14927 rc = CURSOR_MOVEMENT_SUCCESS;
14928 break;
14929 }
14930 if (MATRIX_ROW_BOTTOM_Y (row) == last_y)
14931 break;
14932 ++row;
14933 }
14934 while (((MATRIX_ROW_CONTINUATION_LINE_P (row)
14935 || row->continued_p)
14936 && MATRIX_ROW_BOTTOM_Y (row) <= last_y)
14937 || (MATRIX_ROW_START_CHARPOS (row) == PT
14938 && MATRIX_ROW_BOTTOM_Y (row) < last_y));
14939 /* If we didn't find any candidate rows, or exited the
14940 loop before all the candidates were examined, signal
14941 to the caller that this method failed. */
14942 if (rc != CURSOR_MOVEMENT_SUCCESS
14943 && !(rv
14944 && !MATRIX_ROW_CONTINUATION_LINE_P (row)
14945 && !row->continued_p))
14946 rc = CURSOR_MOVEMENT_MUST_SCROLL;
14947 else if (rv)
14948 rc = CURSOR_MOVEMENT_SUCCESS;
14949 }
14950 else
14951 {
14952 do
14953 {
14954 if (set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0))
14955 {
14956 rc = CURSOR_MOVEMENT_SUCCESS;
14957 break;
14958 }
14959 ++row;
14960 }
14961 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
14962 && MATRIX_ROW_START_CHARPOS (row) == PT
14963 && cursor_row_p (row));
14964 }
14965 }
14966 }
14967
14968 return rc;
14969 }
14970
14971 #if !defined USE_TOOLKIT_SCROLL_BARS || defined USE_GTK
14972 static
14973 #endif
14974 void
14975 set_vertical_scroll_bar (struct window *w)
14976 {
14977 ptrdiff_t start, end, whole;
14978
14979 /* Calculate the start and end positions for the current window.
14980 At some point, it would be nice to choose between scrollbars
14981 which reflect the whole buffer size, with special markers
14982 indicating narrowing, and scrollbars which reflect only the
14983 visible region.
14984
14985 Note that mini-buffers sometimes aren't displaying any text. */
14986 if (!MINI_WINDOW_P (w)
14987 || (w == XWINDOW (minibuf_window)
14988 && NILP (echo_area_buffer[0])))
14989 {
14990 struct buffer *buf = XBUFFER (w->buffer);
14991 whole = BUF_ZV (buf) - BUF_BEGV (buf);
14992 start = marker_position (w->start) - BUF_BEGV (buf);
14993 /* I don't think this is guaranteed to be right. For the
14994 moment, we'll pretend it is. */
14995 end = BUF_Z (buf) - XFASTINT (w->window_end_pos) - BUF_BEGV (buf);
14996
14997 if (end < start)
14998 end = start;
14999 if (whole < (end - start))
15000 whole = end - start;
15001 }
15002 else
15003 start = end = whole = 0;
15004
15005 /* Indicate what this scroll bar ought to be displaying now. */
15006 if (FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
15007 (*FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
15008 (w, end - start, whole, start);
15009 }
15010
15011
15012 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
15013 selected_window is redisplayed.
15014
15015 We can return without actually redisplaying the window if
15016 fonts_changed_p is nonzero. In that case, redisplay_internal will
15017 retry. */
15018
15019 static void
15020 redisplay_window (Lisp_Object window, int just_this_one_p)
15021 {
15022 struct window *w = XWINDOW (window);
15023 struct frame *f = XFRAME (w->frame);
15024 struct buffer *buffer = XBUFFER (w->buffer);
15025 struct buffer *old = current_buffer;
15026 struct text_pos lpoint, opoint, startp;
15027 int update_mode_line;
15028 int tem;
15029 struct it it;
15030 /* Record it now because it's overwritten. */
15031 int current_matrix_up_to_date_p = 0;
15032 int used_current_matrix_p = 0;
15033 /* This is less strict than current_matrix_up_to_date_p.
15034 It indictes that the buffer contents and narrowing are unchanged. */
15035 int buffer_unchanged_p = 0;
15036 int temp_scroll_step = 0;
15037 ptrdiff_t count = SPECPDL_INDEX ();
15038 int rc;
15039 int centering_position = -1;
15040 int last_line_misfit = 0;
15041 ptrdiff_t beg_unchanged, end_unchanged;
15042
15043 SET_TEXT_POS (lpoint, PT, PT_BYTE);
15044 opoint = lpoint;
15045
15046 /* W must be a leaf window here. */
15047 xassert (!NILP (w->buffer));
15048 #if GLYPH_DEBUG
15049 *w->desired_matrix->method = 0;
15050 #endif
15051
15052 restart:
15053 reconsider_clip_changes (w, buffer);
15054
15055 /* Has the mode line to be updated? */
15056 update_mode_line = (!NILP (w->update_mode_line)
15057 || update_mode_lines
15058 || buffer->clip_changed
15059 || buffer->prevent_redisplay_optimizations_p);
15060
15061 if (MINI_WINDOW_P (w))
15062 {
15063 if (w == XWINDOW (echo_area_window)
15064 && !NILP (echo_area_buffer[0]))
15065 {
15066 if (update_mode_line)
15067 /* We may have to update a tty frame's menu bar or a
15068 tool-bar. Example `M-x C-h C-h C-g'. */
15069 goto finish_menu_bars;
15070 else
15071 /* We've already displayed the echo area glyphs in this window. */
15072 goto finish_scroll_bars;
15073 }
15074 else if ((w != XWINDOW (minibuf_window)
15075 || minibuf_level == 0)
15076 /* When buffer is nonempty, redisplay window normally. */
15077 && BUF_Z (XBUFFER (w->buffer)) == BUF_BEG (XBUFFER (w->buffer))
15078 /* Quail displays non-mini buffers in minibuffer window.
15079 In that case, redisplay the window normally. */
15080 && !NILP (Fmemq (w->buffer, Vminibuffer_list)))
15081 {
15082 /* W is a mini-buffer window, but it's not active, so clear
15083 it. */
15084 int yb = window_text_bottom_y (w);
15085 struct glyph_row *row;
15086 int y;
15087
15088 for (y = 0, row = w->desired_matrix->rows;
15089 y < yb;
15090 y += row->height, ++row)
15091 blank_row (w, row, y);
15092 goto finish_scroll_bars;
15093 }
15094
15095 clear_glyph_matrix (w->desired_matrix);
15096 }
15097
15098 /* Otherwise set up data on this window; select its buffer and point
15099 value. */
15100 /* Really select the buffer, for the sake of buffer-local
15101 variables. */
15102 set_buffer_internal_1 (XBUFFER (w->buffer));
15103
15104 current_matrix_up_to_date_p
15105 = (!NILP (w->window_end_valid)
15106 && !current_buffer->clip_changed
15107 && !current_buffer->prevent_redisplay_optimizations_p
15108 && XFASTINT (w->last_modified) >= MODIFF
15109 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF);
15110
15111 /* Run the window-bottom-change-functions
15112 if it is possible that the text on the screen has changed
15113 (either due to modification of the text, or any other reason). */
15114 if (!current_matrix_up_to_date_p
15115 && !NILP (Vwindow_text_change_functions))
15116 {
15117 safe_run_hooks (Qwindow_text_change_functions);
15118 goto restart;
15119 }
15120
15121 beg_unchanged = BEG_UNCHANGED;
15122 end_unchanged = END_UNCHANGED;
15123
15124 SET_TEXT_POS (opoint, PT, PT_BYTE);
15125
15126 specbind (Qinhibit_point_motion_hooks, Qt);
15127
15128 buffer_unchanged_p
15129 = (!NILP (w->window_end_valid)
15130 && !current_buffer->clip_changed
15131 && XFASTINT (w->last_modified) >= MODIFF
15132 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF);
15133
15134 /* When windows_or_buffers_changed is non-zero, we can't rely on
15135 the window end being valid, so set it to nil there. */
15136 if (windows_or_buffers_changed)
15137 {
15138 /* If window starts on a continuation line, maybe adjust the
15139 window start in case the window's width changed. */
15140 if (XMARKER (w->start)->buffer == current_buffer)
15141 compute_window_start_on_continuation_line (w);
15142
15143 w->window_end_valid = Qnil;
15144 }
15145
15146 /* Some sanity checks. */
15147 CHECK_WINDOW_END (w);
15148 if (Z == Z_BYTE && CHARPOS (opoint) != BYTEPOS (opoint))
15149 abort ();
15150 if (BYTEPOS (opoint) < CHARPOS (opoint))
15151 abort ();
15152
15153 /* If %c is in mode line, update it if needed. */
15154 if (!NILP (w->column_number_displayed)
15155 /* This alternative quickly identifies a common case
15156 where no change is needed. */
15157 && !(PT == XFASTINT (w->last_point)
15158 && XFASTINT (w->last_modified) >= MODIFF
15159 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
15160 && (XFASTINT (w->column_number_displayed) != current_column ()))
15161 update_mode_line = 1;
15162
15163 /* Count number of windows showing the selected buffer. An indirect
15164 buffer counts as its base buffer. */
15165 if (!just_this_one_p)
15166 {
15167 struct buffer *current_base, *window_base;
15168 current_base = current_buffer;
15169 window_base = XBUFFER (XWINDOW (selected_window)->buffer);
15170 if (current_base->base_buffer)
15171 current_base = current_base->base_buffer;
15172 if (window_base->base_buffer)
15173 window_base = window_base->base_buffer;
15174 if (current_base == window_base)
15175 buffer_shared++;
15176 }
15177
15178 /* Point refers normally to the selected window. For any other
15179 window, set up appropriate value. */
15180 if (!EQ (window, selected_window))
15181 {
15182 ptrdiff_t new_pt = XMARKER (w->pointm)->charpos;
15183 ptrdiff_t new_pt_byte = marker_byte_position (w->pointm);
15184 if (new_pt < BEGV)
15185 {
15186 new_pt = BEGV;
15187 new_pt_byte = BEGV_BYTE;
15188 set_marker_both (w->pointm, Qnil, BEGV, BEGV_BYTE);
15189 }
15190 else if (new_pt > (ZV - 1))
15191 {
15192 new_pt = ZV;
15193 new_pt_byte = ZV_BYTE;
15194 set_marker_both (w->pointm, Qnil, ZV, ZV_BYTE);
15195 }
15196
15197 /* We don't use SET_PT so that the point-motion hooks don't run. */
15198 TEMP_SET_PT_BOTH (new_pt, new_pt_byte);
15199 }
15200
15201 /* If any of the character widths specified in the display table
15202 have changed, invalidate the width run cache. It's true that
15203 this may be a bit late to catch such changes, but the rest of
15204 redisplay goes (non-fatally) haywire when the display table is
15205 changed, so why should we worry about doing any better? */
15206 if (current_buffer->width_run_cache)
15207 {
15208 struct Lisp_Char_Table *disptab = buffer_display_table ();
15209
15210 if (! disptab_matches_widthtab (disptab,
15211 XVECTOR (BVAR (current_buffer, width_table))))
15212 {
15213 invalidate_region_cache (current_buffer,
15214 current_buffer->width_run_cache,
15215 BEG, Z);
15216 recompute_width_table (current_buffer, disptab);
15217 }
15218 }
15219
15220 /* If window-start is screwed up, choose a new one. */
15221 if (XMARKER (w->start)->buffer != current_buffer)
15222 goto recenter;
15223
15224 SET_TEXT_POS_FROM_MARKER (startp, w->start);
15225
15226 /* If someone specified a new starting point but did not insist,
15227 check whether it can be used. */
15228 if (!NILP (w->optional_new_start)
15229 && CHARPOS (startp) >= BEGV
15230 && CHARPOS (startp) <= ZV)
15231 {
15232 w->optional_new_start = Qnil;
15233 start_display (&it, w, startp);
15234 move_it_to (&it, PT, 0, it.last_visible_y, -1,
15235 MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
15236 if (IT_CHARPOS (it) == PT)
15237 w->force_start = Qt;
15238 /* IT may overshoot PT if text at PT is invisible. */
15239 else if (IT_CHARPOS (it) > PT && CHARPOS (startp) <= PT)
15240 w->force_start = Qt;
15241 }
15242
15243 force_start:
15244
15245 /* Handle case where place to start displaying has been specified,
15246 unless the specified location is outside the accessible range. */
15247 if (!NILP (w->force_start)
15248 || w->frozen_window_start_p)
15249 {
15250 /* We set this later on if we have to adjust point. */
15251 int new_vpos = -1;
15252
15253 w->force_start = Qnil;
15254 w->vscroll = 0;
15255 w->window_end_valid = Qnil;
15256
15257 /* Forget any recorded base line for line number display. */
15258 if (!buffer_unchanged_p)
15259 w->base_line_number = Qnil;
15260
15261 /* Redisplay the mode line. Select the buffer properly for that.
15262 Also, run the hook window-scroll-functions
15263 because we have scrolled. */
15264 /* Note, we do this after clearing force_start because
15265 if there's an error, it is better to forget about force_start
15266 than to get into an infinite loop calling the hook functions
15267 and having them get more errors. */
15268 if (!update_mode_line
15269 || ! NILP (Vwindow_scroll_functions))
15270 {
15271 update_mode_line = 1;
15272 w->update_mode_line = Qt;
15273 startp = run_window_scroll_functions (window, startp);
15274 }
15275
15276 w->last_modified = make_number (0);
15277 w->last_overlay_modified = make_number (0);
15278 if (CHARPOS (startp) < BEGV)
15279 SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
15280 else if (CHARPOS (startp) > ZV)
15281 SET_TEXT_POS (startp, ZV, ZV_BYTE);
15282
15283 /* Redisplay, then check if cursor has been set during the
15284 redisplay. Give up if new fonts were loaded. */
15285 /* We used to issue a CHECK_MARGINS argument to try_window here,
15286 but this causes scrolling to fail when point begins inside
15287 the scroll margin (bug#148) -- cyd */
15288 if (!try_window (window, startp, 0))
15289 {
15290 w->force_start = Qt;
15291 clear_glyph_matrix (w->desired_matrix);
15292 goto need_larger_matrices;
15293 }
15294
15295 if (w->cursor.vpos < 0 && !w->frozen_window_start_p)
15296 {
15297 /* If point does not appear, try to move point so it does
15298 appear. The desired matrix has been built above, so we
15299 can use it here. */
15300 new_vpos = window_box_height (w) / 2;
15301 }
15302
15303 if (!cursor_row_fully_visible_p (w, 0, 0))
15304 {
15305 /* Point does appear, but on a line partly visible at end of window.
15306 Move it back to a fully-visible line. */
15307 new_vpos = window_box_height (w);
15308 }
15309
15310 /* If we need to move point for either of the above reasons,
15311 now actually do it. */
15312 if (new_vpos >= 0)
15313 {
15314 struct glyph_row *row;
15315
15316 row = MATRIX_FIRST_TEXT_ROW (w->desired_matrix);
15317 while (MATRIX_ROW_BOTTOM_Y (row) < new_vpos)
15318 ++row;
15319
15320 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row),
15321 MATRIX_ROW_START_BYTEPOS (row));
15322
15323 if (w != XWINDOW (selected_window))
15324 set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
15325 else if (current_buffer == old)
15326 SET_TEXT_POS (lpoint, PT, PT_BYTE);
15327
15328 set_cursor_from_row (w, row, w->desired_matrix, 0, 0, 0, 0);
15329
15330 /* If we are highlighting the region, then we just changed
15331 the region, so redisplay to show it. */
15332 if (!NILP (Vtransient_mark_mode)
15333 && !NILP (BVAR (current_buffer, mark_active)))
15334 {
15335 clear_glyph_matrix (w->desired_matrix);
15336 if (!try_window (window, startp, 0))
15337 goto need_larger_matrices;
15338 }
15339 }
15340
15341 #if GLYPH_DEBUG
15342 debug_method_add (w, "forced window start");
15343 #endif
15344 goto done;
15345 }
15346
15347 /* Handle case where text has not changed, only point, and it has
15348 not moved off the frame, and we are not retrying after hscroll.
15349 (current_matrix_up_to_date_p is nonzero when retrying.) */
15350 if (current_matrix_up_to_date_p
15351 && (rc = try_cursor_movement (window, startp, &temp_scroll_step),
15352 rc != CURSOR_MOVEMENT_CANNOT_BE_USED))
15353 {
15354 switch (rc)
15355 {
15356 case CURSOR_MOVEMENT_SUCCESS:
15357 used_current_matrix_p = 1;
15358 goto done;
15359
15360 case CURSOR_MOVEMENT_MUST_SCROLL:
15361 goto try_to_scroll;
15362
15363 default:
15364 abort ();
15365 }
15366 }
15367 /* If current starting point was originally the beginning of a line
15368 but no longer is, find a new starting point. */
15369 else if (!NILP (w->start_at_line_beg)
15370 && !(CHARPOS (startp) <= BEGV
15371 || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n'))
15372 {
15373 #if GLYPH_DEBUG
15374 debug_method_add (w, "recenter 1");
15375 #endif
15376 goto recenter;
15377 }
15378
15379 /* Try scrolling with try_window_id. Value is > 0 if update has
15380 been done, it is -1 if we know that the same window start will
15381 not work. It is 0 if unsuccessful for some other reason. */
15382 else if ((tem = try_window_id (w)) != 0)
15383 {
15384 #if GLYPH_DEBUG
15385 debug_method_add (w, "try_window_id %d", tem);
15386 #endif
15387
15388 if (fonts_changed_p)
15389 goto need_larger_matrices;
15390 if (tem > 0)
15391 goto done;
15392
15393 /* Otherwise try_window_id has returned -1 which means that we
15394 don't want the alternative below this comment to execute. */
15395 }
15396 else if (CHARPOS (startp) >= BEGV
15397 && CHARPOS (startp) <= ZV
15398 && PT >= CHARPOS (startp)
15399 && (CHARPOS (startp) < ZV
15400 /* Avoid starting at end of buffer. */
15401 || CHARPOS (startp) == BEGV
15402 || (XFASTINT (w->last_modified) >= MODIFF
15403 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)))
15404 {
15405 int d1, d2, d3, d4, d5, d6;
15406
15407 /* If first window line is a continuation line, and window start
15408 is inside the modified region, but the first change is before
15409 current window start, we must select a new window start.
15410
15411 However, if this is the result of a down-mouse event (e.g. by
15412 extending the mouse-drag-overlay), we don't want to select a
15413 new window start, since that would change the position under
15414 the mouse, resulting in an unwanted mouse-movement rather
15415 than a simple mouse-click. */
15416 if (NILP (w->start_at_line_beg)
15417 && NILP (do_mouse_tracking)
15418 && CHARPOS (startp) > BEGV
15419 && CHARPOS (startp) > BEG + beg_unchanged
15420 && CHARPOS (startp) <= Z - end_unchanged
15421 /* Even if w->start_at_line_beg is nil, a new window may
15422 start at a line_beg, since that's how set_buffer_window
15423 sets it. So, we need to check the return value of
15424 compute_window_start_on_continuation_line. (See also
15425 bug#197). */
15426 && XMARKER (w->start)->buffer == current_buffer
15427 && compute_window_start_on_continuation_line (w)
15428 /* It doesn't make sense to force the window start like we
15429 do at label force_start if it is already known that point
15430 will not be visible in the resulting window, because
15431 doing so will move point from its correct position
15432 instead of scrolling the window to bring point into view.
15433 See bug#9324. */
15434 && pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &d6))
15435 {
15436 w->force_start = Qt;
15437 SET_TEXT_POS_FROM_MARKER (startp, w->start);
15438 goto force_start;
15439 }
15440
15441 #if GLYPH_DEBUG
15442 debug_method_add (w, "same window start");
15443 #endif
15444
15445 /* Try to redisplay starting at same place as before.
15446 If point has not moved off frame, accept the results. */
15447 if (!current_matrix_up_to_date_p
15448 /* Don't use try_window_reusing_current_matrix in this case
15449 because a window scroll function can have changed the
15450 buffer. */
15451 || !NILP (Vwindow_scroll_functions)
15452 || MINI_WINDOW_P (w)
15453 || !(used_current_matrix_p
15454 = try_window_reusing_current_matrix (w)))
15455 {
15456 IF_DEBUG (debug_method_add (w, "1"));
15457 if (try_window (window, startp, TRY_WINDOW_CHECK_MARGINS) < 0)
15458 /* -1 means we need to scroll.
15459 0 means we need new matrices, but fonts_changed_p
15460 is set in that case, so we will detect it below. */
15461 goto try_to_scroll;
15462 }
15463
15464 if (fonts_changed_p)
15465 goto need_larger_matrices;
15466
15467 if (w->cursor.vpos >= 0)
15468 {
15469 if (!just_this_one_p
15470 || current_buffer->clip_changed
15471 || BEG_UNCHANGED < CHARPOS (startp))
15472 /* Forget any recorded base line for line number display. */
15473 w->base_line_number = Qnil;
15474
15475 if (!cursor_row_fully_visible_p (w, 1, 0))
15476 {
15477 clear_glyph_matrix (w->desired_matrix);
15478 last_line_misfit = 1;
15479 }
15480 /* Drop through and scroll. */
15481 else
15482 goto done;
15483 }
15484 else
15485 clear_glyph_matrix (w->desired_matrix);
15486 }
15487
15488 try_to_scroll:
15489
15490 w->last_modified = make_number (0);
15491 w->last_overlay_modified = make_number (0);
15492
15493 /* Redisplay the mode line. Select the buffer properly for that. */
15494 if (!update_mode_line)
15495 {
15496 update_mode_line = 1;
15497 w->update_mode_line = Qt;
15498 }
15499
15500 /* Try to scroll by specified few lines. */
15501 if ((scroll_conservatively
15502 || emacs_scroll_step
15503 || temp_scroll_step
15504 || NUMBERP (BVAR (current_buffer, scroll_up_aggressively))
15505 || NUMBERP (BVAR (current_buffer, scroll_down_aggressively)))
15506 && CHARPOS (startp) >= BEGV
15507 && CHARPOS (startp) <= ZV)
15508 {
15509 /* The function returns -1 if new fonts were loaded, 1 if
15510 successful, 0 if not successful. */
15511 int ss = try_scrolling (window, just_this_one_p,
15512 scroll_conservatively,
15513 emacs_scroll_step,
15514 temp_scroll_step, last_line_misfit);
15515 switch (ss)
15516 {
15517 case SCROLLING_SUCCESS:
15518 goto done;
15519
15520 case SCROLLING_NEED_LARGER_MATRICES:
15521 goto need_larger_matrices;
15522
15523 case SCROLLING_FAILED:
15524 break;
15525
15526 default:
15527 abort ();
15528 }
15529 }
15530
15531 /* Finally, just choose a place to start which positions point
15532 according to user preferences. */
15533
15534 recenter:
15535
15536 #if GLYPH_DEBUG
15537 debug_method_add (w, "recenter");
15538 #endif
15539
15540 /* w->vscroll = 0; */
15541
15542 /* Forget any previously recorded base line for line number display. */
15543 if (!buffer_unchanged_p)
15544 w->base_line_number = Qnil;
15545
15546 /* Determine the window start relative to point. */
15547 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
15548 it.current_y = it.last_visible_y;
15549 if (centering_position < 0)
15550 {
15551 int margin =
15552 scroll_margin > 0
15553 ? min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4)
15554 : 0;
15555 ptrdiff_t margin_pos = CHARPOS (startp);
15556 int scrolling_up;
15557 Lisp_Object aggressive;
15558
15559 /* If there is a scroll margin at the top of the window, find
15560 its character position. */
15561 if (margin
15562 /* Cannot call start_display if startp is not in the
15563 accessible region of the buffer. This can happen when we
15564 have just switched to a different buffer and/or changed
15565 its restriction. In that case, startp is initialized to
15566 the character position 1 (BEG) because we did not yet
15567 have chance to display the buffer even once. */
15568 && BEGV <= CHARPOS (startp) && CHARPOS (startp) <= ZV)
15569 {
15570 struct it it1;
15571 void *it1data = NULL;
15572
15573 SAVE_IT (it1, it, it1data);
15574 start_display (&it1, w, startp);
15575 move_it_vertically (&it1, margin);
15576 margin_pos = IT_CHARPOS (it1);
15577 RESTORE_IT (&it, &it, it1data);
15578 }
15579 scrolling_up = PT > margin_pos;
15580 aggressive =
15581 scrolling_up
15582 ? BVAR (current_buffer, scroll_up_aggressively)
15583 : BVAR (current_buffer, scroll_down_aggressively);
15584
15585 if (!MINI_WINDOW_P (w)
15586 && (scroll_conservatively > SCROLL_LIMIT || NUMBERP (aggressive)))
15587 {
15588 int pt_offset = 0;
15589
15590 /* Setting scroll-conservatively overrides
15591 scroll-*-aggressively. */
15592 if (!scroll_conservatively && NUMBERP (aggressive))
15593 {
15594 double float_amount = XFLOATINT (aggressive);
15595
15596 pt_offset = float_amount * WINDOW_BOX_TEXT_HEIGHT (w);
15597 if (pt_offset == 0 && float_amount > 0)
15598 pt_offset = 1;
15599 if (pt_offset)
15600 margin -= 1;
15601 }
15602 /* Compute how much to move the window start backward from
15603 point so that point will be displayed where the user
15604 wants it. */
15605 if (scrolling_up)
15606 {
15607 centering_position = it.last_visible_y;
15608 if (pt_offset)
15609 centering_position -= pt_offset;
15610 centering_position -=
15611 FRAME_LINE_HEIGHT (f) * (1 + margin + (last_line_misfit != 0))
15612 + WINDOW_HEADER_LINE_HEIGHT (w);
15613 /* Don't let point enter the scroll margin near top of
15614 the window. */
15615 if (centering_position < margin * FRAME_LINE_HEIGHT (f))
15616 centering_position = margin * FRAME_LINE_HEIGHT (f);
15617 }
15618 else
15619 centering_position = margin * FRAME_LINE_HEIGHT (f) + pt_offset;
15620 }
15621 else
15622 /* Set the window start half the height of the window backward
15623 from point. */
15624 centering_position = window_box_height (w) / 2;
15625 }
15626 move_it_vertically_backward (&it, centering_position);
15627
15628 xassert (IT_CHARPOS (it) >= BEGV);
15629
15630 /* The function move_it_vertically_backward may move over more
15631 than the specified y-distance. If it->w is small, e.g. a
15632 mini-buffer window, we may end up in front of the window's
15633 display area. Start displaying at the start of the line
15634 containing PT in this case. */
15635 if (it.current_y <= 0)
15636 {
15637 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
15638 move_it_vertically_backward (&it, 0);
15639 it.current_y = 0;
15640 }
15641
15642 it.current_x = it.hpos = 0;
15643
15644 /* Set the window start position here explicitly, to avoid an
15645 infinite loop in case the functions in window-scroll-functions
15646 get errors. */
15647 set_marker_both (w->start, Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
15648
15649 /* Run scroll hooks. */
15650 startp = run_window_scroll_functions (window, it.current.pos);
15651
15652 /* Redisplay the window. */
15653 if (!current_matrix_up_to_date_p
15654 || windows_or_buffers_changed
15655 || cursor_type_changed
15656 /* Don't use try_window_reusing_current_matrix in this case
15657 because it can have changed the buffer. */
15658 || !NILP (Vwindow_scroll_functions)
15659 || !just_this_one_p
15660 || MINI_WINDOW_P (w)
15661 || !(used_current_matrix_p
15662 = try_window_reusing_current_matrix (w)))
15663 try_window (window, startp, 0);
15664
15665 /* If new fonts have been loaded (due to fontsets), give up. We
15666 have to start a new redisplay since we need to re-adjust glyph
15667 matrices. */
15668 if (fonts_changed_p)
15669 goto need_larger_matrices;
15670
15671 /* If cursor did not appear assume that the middle of the window is
15672 in the first line of the window. Do it again with the next line.
15673 (Imagine a window of height 100, displaying two lines of height
15674 60. Moving back 50 from it->last_visible_y will end in the first
15675 line.) */
15676 if (w->cursor.vpos < 0)
15677 {
15678 if (!NILP (w->window_end_valid)
15679 && PT >= Z - XFASTINT (w->window_end_pos))
15680 {
15681 clear_glyph_matrix (w->desired_matrix);
15682 move_it_by_lines (&it, 1);
15683 try_window (window, it.current.pos, 0);
15684 }
15685 else if (PT < IT_CHARPOS (it))
15686 {
15687 clear_glyph_matrix (w->desired_matrix);
15688 move_it_by_lines (&it, -1);
15689 try_window (window, it.current.pos, 0);
15690 }
15691 else
15692 {
15693 /* Not much we can do about it. */
15694 }
15695 }
15696
15697 /* Consider the following case: Window starts at BEGV, there is
15698 invisible, intangible text at BEGV, so that display starts at
15699 some point START > BEGV. It can happen that we are called with
15700 PT somewhere between BEGV and START. Try to handle that case. */
15701 if (w->cursor.vpos < 0)
15702 {
15703 struct glyph_row *row = w->current_matrix->rows;
15704 if (row->mode_line_p)
15705 ++row;
15706 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
15707 }
15708
15709 if (!cursor_row_fully_visible_p (w, 0, 0))
15710 {
15711 /* If vscroll is enabled, disable it and try again. */
15712 if (w->vscroll)
15713 {
15714 w->vscroll = 0;
15715 clear_glyph_matrix (w->desired_matrix);
15716 goto recenter;
15717 }
15718
15719 /* If centering point failed to make the whole line visible,
15720 put point at the top instead. That has to make the whole line
15721 visible, if it can be done. */
15722 if (centering_position == 0)
15723 goto done;
15724
15725 clear_glyph_matrix (w->desired_matrix);
15726 centering_position = 0;
15727 goto recenter;
15728 }
15729
15730 done:
15731
15732 SET_TEXT_POS_FROM_MARKER (startp, w->start);
15733 w->start_at_line_beg = ((CHARPOS (startp) == BEGV
15734 || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n')
15735 ? Qt : Qnil);
15736
15737 /* Display the mode line, if we must. */
15738 if ((update_mode_line
15739 /* If window not full width, must redo its mode line
15740 if (a) the window to its side is being redone and
15741 (b) we do a frame-based redisplay. This is a consequence
15742 of how inverted lines are drawn in frame-based redisplay. */
15743 || (!just_this_one_p
15744 && !FRAME_WINDOW_P (f)
15745 && !WINDOW_FULL_WIDTH_P (w))
15746 /* Line number to display. */
15747 || INTEGERP (w->base_line_pos)
15748 /* Column number is displayed and different from the one displayed. */
15749 || (!NILP (w->column_number_displayed)
15750 && (XFASTINT (w->column_number_displayed) != current_column ())))
15751 /* This means that the window has a mode line. */
15752 && (WINDOW_WANTS_MODELINE_P (w)
15753 || WINDOW_WANTS_HEADER_LINE_P (w)))
15754 {
15755 display_mode_lines (w);
15756
15757 /* If mode line height has changed, arrange for a thorough
15758 immediate redisplay using the correct mode line height. */
15759 if (WINDOW_WANTS_MODELINE_P (w)
15760 && CURRENT_MODE_LINE_HEIGHT (w) != DESIRED_MODE_LINE_HEIGHT (w))
15761 {
15762 fonts_changed_p = 1;
15763 MATRIX_MODE_LINE_ROW (w->current_matrix)->height
15764 = DESIRED_MODE_LINE_HEIGHT (w);
15765 }
15766
15767 /* If header line height has changed, arrange for a thorough
15768 immediate redisplay using the correct header line height. */
15769 if (WINDOW_WANTS_HEADER_LINE_P (w)
15770 && CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
15771 {
15772 fonts_changed_p = 1;
15773 MATRIX_HEADER_LINE_ROW (w->current_matrix)->height
15774 = DESIRED_HEADER_LINE_HEIGHT (w);
15775 }
15776
15777 if (fonts_changed_p)
15778 goto need_larger_matrices;
15779 }
15780
15781 if (!line_number_displayed
15782 && !BUFFERP (w->base_line_pos))
15783 {
15784 w->base_line_pos = Qnil;
15785 w->base_line_number = Qnil;
15786 }
15787
15788 finish_menu_bars:
15789
15790 /* When we reach a frame's selected window, redo the frame's menu bar. */
15791 if (update_mode_line
15792 && EQ (FRAME_SELECTED_WINDOW (f), window))
15793 {
15794 int redisplay_menu_p = 0;
15795
15796 if (FRAME_WINDOW_P (f))
15797 {
15798 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
15799 || defined (HAVE_NS) || defined (USE_GTK)
15800 redisplay_menu_p = FRAME_EXTERNAL_MENU_BAR (f);
15801 #else
15802 redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
15803 #endif
15804 }
15805 else
15806 redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
15807
15808 if (redisplay_menu_p)
15809 display_menu_bar (w);
15810
15811 #ifdef HAVE_WINDOW_SYSTEM
15812 if (FRAME_WINDOW_P (f))
15813 {
15814 #if defined (USE_GTK) || defined (HAVE_NS)
15815 if (FRAME_EXTERNAL_TOOL_BAR (f))
15816 redisplay_tool_bar (f);
15817 #else
15818 if (WINDOWP (f->tool_bar_window)
15819 && (FRAME_TOOL_BAR_LINES (f) > 0
15820 || !NILP (Vauto_resize_tool_bars))
15821 && redisplay_tool_bar (f))
15822 ignore_mouse_drag_p = 1;
15823 #endif
15824 }
15825 #endif
15826 }
15827
15828 #ifdef HAVE_WINDOW_SYSTEM
15829 if (FRAME_WINDOW_P (f)
15830 && update_window_fringes (w, (just_this_one_p
15831 || (!used_current_matrix_p && !overlay_arrow_seen)
15832 || w->pseudo_window_p)))
15833 {
15834 update_begin (f);
15835 BLOCK_INPUT;
15836 if (draw_window_fringes (w, 1))
15837 x_draw_vertical_border (w);
15838 UNBLOCK_INPUT;
15839 update_end (f);
15840 }
15841 #endif /* HAVE_WINDOW_SYSTEM */
15842
15843 /* We go to this label, with fonts_changed_p nonzero,
15844 if it is necessary to try again using larger glyph matrices.
15845 We have to redeem the scroll bar even in this case,
15846 because the loop in redisplay_internal expects that. */
15847 need_larger_matrices:
15848 ;
15849 finish_scroll_bars:
15850
15851 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
15852 {
15853 /* Set the thumb's position and size. */
15854 set_vertical_scroll_bar (w);
15855
15856 /* Note that we actually used the scroll bar attached to this
15857 window, so it shouldn't be deleted at the end of redisplay. */
15858 if (FRAME_TERMINAL (f)->redeem_scroll_bar_hook)
15859 (*FRAME_TERMINAL (f)->redeem_scroll_bar_hook) (w);
15860 }
15861
15862 /* Restore current_buffer and value of point in it. The window
15863 update may have changed the buffer, so first make sure `opoint'
15864 is still valid (Bug#6177). */
15865 if (CHARPOS (opoint) < BEGV)
15866 TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
15867 else if (CHARPOS (opoint) > ZV)
15868 TEMP_SET_PT_BOTH (Z, Z_BYTE);
15869 else
15870 TEMP_SET_PT_BOTH (CHARPOS (opoint), BYTEPOS (opoint));
15871
15872 set_buffer_internal_1 (old);
15873 /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
15874 shorter. This can be caused by log truncation in *Messages*. */
15875 if (CHARPOS (lpoint) <= ZV)
15876 TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
15877
15878 unbind_to (count, Qnil);
15879 }
15880
15881
15882 /* Build the complete desired matrix of WINDOW with a window start
15883 buffer position POS.
15884
15885 Value is 1 if successful. It is zero if fonts were loaded during
15886 redisplay which makes re-adjusting glyph matrices necessary, and -1
15887 if point would appear in the scroll margins.
15888 (We check the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is
15889 unset in FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is
15890 set in FLAGS.) */
15891
15892 int
15893 try_window (Lisp_Object window, struct text_pos pos, int flags)
15894 {
15895 struct window *w = XWINDOW (window);
15896 struct it it;
15897 struct glyph_row *last_text_row = NULL;
15898 struct frame *f = XFRAME (w->frame);
15899
15900 /* Make POS the new window start. */
15901 set_marker_both (w->start, Qnil, CHARPOS (pos), BYTEPOS (pos));
15902
15903 /* Mark cursor position as unknown. No overlay arrow seen. */
15904 w->cursor.vpos = -1;
15905 overlay_arrow_seen = 0;
15906
15907 /* Initialize iterator and info to start at POS. */
15908 start_display (&it, w, pos);
15909
15910 /* Display all lines of W. */
15911 while (it.current_y < it.last_visible_y)
15912 {
15913 if (display_line (&it))
15914 last_text_row = it.glyph_row - 1;
15915 if (fonts_changed_p && !(flags & TRY_WINDOW_IGNORE_FONTS_CHANGE))
15916 return 0;
15917 }
15918
15919 /* Don't let the cursor end in the scroll margins. */
15920 if ((flags & TRY_WINDOW_CHECK_MARGINS)
15921 && !MINI_WINDOW_P (w))
15922 {
15923 int this_scroll_margin;
15924
15925 if (scroll_margin > 0)
15926 {
15927 this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
15928 this_scroll_margin *= FRAME_LINE_HEIGHT (f);
15929 }
15930 else
15931 this_scroll_margin = 0;
15932
15933 if ((w->cursor.y >= 0 /* not vscrolled */
15934 && w->cursor.y < this_scroll_margin
15935 && CHARPOS (pos) > BEGV
15936 && IT_CHARPOS (it) < ZV)
15937 /* rms: considering make_cursor_line_fully_visible_p here
15938 seems to give wrong results. We don't want to recenter
15939 when the last line is partly visible, we want to allow
15940 that case to be handled in the usual way. */
15941 || w->cursor.y > it.last_visible_y - this_scroll_margin - 1)
15942 {
15943 w->cursor.vpos = -1;
15944 clear_glyph_matrix (w->desired_matrix);
15945 return -1;
15946 }
15947 }
15948
15949 /* If bottom moved off end of frame, change mode line percentage. */
15950 if (XFASTINT (w->window_end_pos) <= 0
15951 && Z != IT_CHARPOS (it))
15952 w->update_mode_line = Qt;
15953
15954 /* Set window_end_pos to the offset of the last character displayed
15955 on the window from the end of current_buffer. Set
15956 window_end_vpos to its row number. */
15957 if (last_text_row)
15958 {
15959 xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
15960 w->window_end_bytepos
15961 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
15962 w->window_end_pos
15963 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
15964 w->window_end_vpos
15965 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
15966 xassert (MATRIX_ROW (w->desired_matrix, XFASTINT (w->window_end_vpos))
15967 ->displays_text_p);
15968 }
15969 else
15970 {
15971 w->window_end_bytepos = Z_BYTE - ZV_BYTE;
15972 w->window_end_pos = make_number (Z - ZV);
15973 w->window_end_vpos = make_number (0);
15974 }
15975
15976 /* But that is not valid info until redisplay finishes. */
15977 w->window_end_valid = Qnil;
15978 return 1;
15979 }
15980
15981
15982 \f
15983 /************************************************************************
15984 Window redisplay reusing current matrix when buffer has not changed
15985 ************************************************************************/
15986
15987 /* Try redisplay of window W showing an unchanged buffer with a
15988 different window start than the last time it was displayed by
15989 reusing its current matrix. Value is non-zero if successful.
15990 W->start is the new window start. */
15991
15992 static int
15993 try_window_reusing_current_matrix (struct window *w)
15994 {
15995 struct frame *f = XFRAME (w->frame);
15996 struct glyph_row *bottom_row;
15997 struct it it;
15998 struct run run;
15999 struct text_pos start, new_start;
16000 int nrows_scrolled, i;
16001 struct glyph_row *last_text_row;
16002 struct glyph_row *last_reused_text_row;
16003 struct glyph_row *start_row;
16004 int start_vpos, min_y, max_y;
16005
16006 #if GLYPH_DEBUG
16007 if (inhibit_try_window_reusing)
16008 return 0;
16009 #endif
16010
16011 if (/* This function doesn't handle terminal frames. */
16012 !FRAME_WINDOW_P (f)
16013 /* Don't try to reuse the display if windows have been split
16014 or such. */
16015 || windows_or_buffers_changed
16016 || cursor_type_changed)
16017 return 0;
16018
16019 /* Can't do this if region may have changed. */
16020 if ((!NILP (Vtransient_mark_mode)
16021 && !NILP (BVAR (current_buffer, mark_active)))
16022 || !NILP (w->region_showing)
16023 || !NILP (Vshow_trailing_whitespace))
16024 return 0;
16025
16026 /* If top-line visibility has changed, give up. */
16027 if (WINDOW_WANTS_HEADER_LINE_P (w)
16028 != MATRIX_HEADER_LINE_ROW (w->current_matrix)->mode_line_p)
16029 return 0;
16030
16031 /* Give up if old or new display is scrolled vertically. We could
16032 make this function handle this, but right now it doesn't. */
16033 start_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
16034 if (w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row))
16035 return 0;
16036
16037 /* The variable new_start now holds the new window start. The old
16038 start `start' can be determined from the current matrix. */
16039 SET_TEXT_POS_FROM_MARKER (new_start, w->start);
16040 start = start_row->minpos;
16041 start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
16042
16043 /* Clear the desired matrix for the display below. */
16044 clear_glyph_matrix (w->desired_matrix);
16045
16046 if (CHARPOS (new_start) <= CHARPOS (start))
16047 {
16048 /* Don't use this method if the display starts with an ellipsis
16049 displayed for invisible text. It's not easy to handle that case
16050 below, and it's certainly not worth the effort since this is
16051 not a frequent case. */
16052 if (in_ellipses_for_invisible_text_p (&start_row->start, w))
16053 return 0;
16054
16055 IF_DEBUG (debug_method_add (w, "twu1"));
16056
16057 /* Display up to a row that can be reused. The variable
16058 last_text_row is set to the last row displayed that displays
16059 text. Note that it.vpos == 0 if or if not there is a
16060 header-line; it's not the same as the MATRIX_ROW_VPOS! */
16061 start_display (&it, w, new_start);
16062 w->cursor.vpos = -1;
16063 last_text_row = last_reused_text_row = NULL;
16064
16065 while (it.current_y < it.last_visible_y
16066 && !fonts_changed_p)
16067 {
16068 /* If we have reached into the characters in the START row,
16069 that means the line boundaries have changed. So we
16070 can't start copying with the row START. Maybe it will
16071 work to start copying with the following row. */
16072 while (IT_CHARPOS (it) > CHARPOS (start))
16073 {
16074 /* Advance to the next row as the "start". */
16075 start_row++;
16076 start = start_row->minpos;
16077 /* If there are no more rows to try, or just one, give up. */
16078 if (start_row == MATRIX_MODE_LINE_ROW (w->current_matrix) - 1
16079 || w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row)
16080 || CHARPOS (start) == ZV)
16081 {
16082 clear_glyph_matrix (w->desired_matrix);
16083 return 0;
16084 }
16085
16086 start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
16087 }
16088 /* If we have reached alignment, we can copy the rest of the
16089 rows. */
16090 if (IT_CHARPOS (it) == CHARPOS (start)
16091 /* Don't accept "alignment" inside a display vector,
16092 since start_row could have started in the middle of
16093 that same display vector (thus their character
16094 positions match), and we have no way of telling if
16095 that is the case. */
16096 && it.current.dpvec_index < 0)
16097 break;
16098
16099 if (display_line (&it))
16100 last_text_row = it.glyph_row - 1;
16101
16102 }
16103
16104 /* A value of current_y < last_visible_y means that we stopped
16105 at the previous window start, which in turn means that we
16106 have at least one reusable row. */
16107 if (it.current_y < it.last_visible_y)
16108 {
16109 struct glyph_row *row;
16110
16111 /* IT.vpos always starts from 0; it counts text lines. */
16112 nrows_scrolled = it.vpos - (start_row - MATRIX_FIRST_TEXT_ROW (w->current_matrix));
16113
16114 /* Find PT if not already found in the lines displayed. */
16115 if (w->cursor.vpos < 0)
16116 {
16117 int dy = it.current_y - start_row->y;
16118
16119 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
16120 row = row_containing_pos (w, PT, row, NULL, dy);
16121 if (row)
16122 set_cursor_from_row (w, row, w->current_matrix, 0, 0,
16123 dy, nrows_scrolled);
16124 else
16125 {
16126 clear_glyph_matrix (w->desired_matrix);
16127 return 0;
16128 }
16129 }
16130
16131 /* Scroll the display. Do it before the current matrix is
16132 changed. The problem here is that update has not yet
16133 run, i.e. part of the current matrix is not up to date.
16134 scroll_run_hook will clear the cursor, and use the
16135 current matrix to get the height of the row the cursor is
16136 in. */
16137 run.current_y = start_row->y;
16138 run.desired_y = it.current_y;
16139 run.height = it.last_visible_y - it.current_y;
16140
16141 if (run.height > 0 && run.current_y != run.desired_y)
16142 {
16143 update_begin (f);
16144 FRAME_RIF (f)->update_window_begin_hook (w);
16145 FRAME_RIF (f)->clear_window_mouse_face (w);
16146 FRAME_RIF (f)->scroll_run_hook (w, &run);
16147 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
16148 update_end (f);
16149 }
16150
16151 /* Shift current matrix down by nrows_scrolled lines. */
16152 bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
16153 rotate_matrix (w->current_matrix,
16154 start_vpos,
16155 MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
16156 nrows_scrolled);
16157
16158 /* Disable lines that must be updated. */
16159 for (i = 0; i < nrows_scrolled; ++i)
16160 (start_row + i)->enabled_p = 0;
16161
16162 /* Re-compute Y positions. */
16163 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
16164 max_y = it.last_visible_y;
16165 for (row = start_row + nrows_scrolled;
16166 row < bottom_row;
16167 ++row)
16168 {
16169 row->y = it.current_y;
16170 row->visible_height = row->height;
16171
16172 if (row->y < min_y)
16173 row->visible_height -= min_y - row->y;
16174 if (row->y + row->height > max_y)
16175 row->visible_height -= row->y + row->height - max_y;
16176 if (row->fringe_bitmap_periodic_p)
16177 row->redraw_fringe_bitmaps_p = 1;
16178
16179 it.current_y += row->height;
16180
16181 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
16182 last_reused_text_row = row;
16183 if (MATRIX_ROW_BOTTOM_Y (row) >= it.last_visible_y)
16184 break;
16185 }
16186
16187 /* Disable lines in the current matrix which are now
16188 below the window. */
16189 for (++row; row < bottom_row; ++row)
16190 row->enabled_p = row->mode_line_p = 0;
16191 }
16192
16193 /* Update window_end_pos etc.; last_reused_text_row is the last
16194 reused row from the current matrix containing text, if any.
16195 The value of last_text_row is the last displayed line
16196 containing text. */
16197 if (last_reused_text_row)
16198 {
16199 w->window_end_bytepos
16200 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_reused_text_row);
16201 w->window_end_pos
16202 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row));
16203 w->window_end_vpos
16204 = make_number (MATRIX_ROW_VPOS (last_reused_text_row,
16205 w->current_matrix));
16206 }
16207 else if (last_text_row)
16208 {
16209 w->window_end_bytepos
16210 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
16211 w->window_end_pos
16212 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
16213 w->window_end_vpos
16214 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
16215 }
16216 else
16217 {
16218 /* This window must be completely empty. */
16219 w->window_end_bytepos = Z_BYTE - ZV_BYTE;
16220 w->window_end_pos = make_number (Z - ZV);
16221 w->window_end_vpos = make_number (0);
16222 }
16223 w->window_end_valid = Qnil;
16224
16225 /* Update hint: don't try scrolling again in update_window. */
16226 w->desired_matrix->no_scrolling_p = 1;
16227
16228 #if GLYPH_DEBUG
16229 debug_method_add (w, "try_window_reusing_current_matrix 1");
16230 #endif
16231 return 1;
16232 }
16233 else if (CHARPOS (new_start) > CHARPOS (start))
16234 {
16235 struct glyph_row *pt_row, *row;
16236 struct glyph_row *first_reusable_row;
16237 struct glyph_row *first_row_to_display;
16238 int dy;
16239 int yb = window_text_bottom_y (w);
16240
16241 /* Find the row starting at new_start, if there is one. Don't
16242 reuse a partially visible line at the end. */
16243 first_reusable_row = start_row;
16244 while (first_reusable_row->enabled_p
16245 && MATRIX_ROW_BOTTOM_Y (first_reusable_row) < yb
16246 && (MATRIX_ROW_START_CHARPOS (first_reusable_row)
16247 < CHARPOS (new_start)))
16248 ++first_reusable_row;
16249
16250 /* Give up if there is no row to reuse. */
16251 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row) >= yb
16252 || !first_reusable_row->enabled_p
16253 || (MATRIX_ROW_START_CHARPOS (first_reusable_row)
16254 != CHARPOS (new_start)))
16255 return 0;
16256
16257 /* We can reuse fully visible rows beginning with
16258 first_reusable_row to the end of the window. Set
16259 first_row_to_display to the first row that cannot be reused.
16260 Set pt_row to the row containing point, if there is any. */
16261 pt_row = NULL;
16262 for (first_row_to_display = first_reusable_row;
16263 MATRIX_ROW_BOTTOM_Y (first_row_to_display) < yb;
16264 ++first_row_to_display)
16265 {
16266 if (PT >= MATRIX_ROW_START_CHARPOS (first_row_to_display)
16267 && PT < MATRIX_ROW_END_CHARPOS (first_row_to_display))
16268 pt_row = first_row_to_display;
16269 }
16270
16271 /* Start displaying at the start of first_row_to_display. */
16272 xassert (first_row_to_display->y < yb);
16273 init_to_row_start (&it, w, first_row_to_display);
16274
16275 nrows_scrolled = (MATRIX_ROW_VPOS (first_reusable_row, w->current_matrix)
16276 - start_vpos);
16277 it.vpos = (MATRIX_ROW_VPOS (first_row_to_display, w->current_matrix)
16278 - nrows_scrolled);
16279 it.current_y = (first_row_to_display->y - first_reusable_row->y
16280 + WINDOW_HEADER_LINE_HEIGHT (w));
16281
16282 /* Display lines beginning with first_row_to_display in the
16283 desired matrix. Set last_text_row to the last row displayed
16284 that displays text. */
16285 it.glyph_row = MATRIX_ROW (w->desired_matrix, it.vpos);
16286 if (pt_row == NULL)
16287 w->cursor.vpos = -1;
16288 last_text_row = NULL;
16289 while (it.current_y < it.last_visible_y && !fonts_changed_p)
16290 if (display_line (&it))
16291 last_text_row = it.glyph_row - 1;
16292
16293 /* If point is in a reused row, adjust y and vpos of the cursor
16294 position. */
16295 if (pt_row)
16296 {
16297 w->cursor.vpos -= nrows_scrolled;
16298 w->cursor.y -= first_reusable_row->y - start_row->y;
16299 }
16300
16301 /* Give up if point isn't in a row displayed or reused. (This
16302 also handles the case where w->cursor.vpos < nrows_scrolled
16303 after the calls to display_line, which can happen with scroll
16304 margins. See bug#1295.) */
16305 if (w->cursor.vpos < 0)
16306 {
16307 clear_glyph_matrix (w->desired_matrix);
16308 return 0;
16309 }
16310
16311 /* Scroll the display. */
16312 run.current_y = first_reusable_row->y;
16313 run.desired_y = WINDOW_HEADER_LINE_HEIGHT (w);
16314 run.height = it.last_visible_y - run.current_y;
16315 dy = run.current_y - run.desired_y;
16316
16317 if (run.height)
16318 {
16319 update_begin (f);
16320 FRAME_RIF (f)->update_window_begin_hook (w);
16321 FRAME_RIF (f)->clear_window_mouse_face (w);
16322 FRAME_RIF (f)->scroll_run_hook (w, &run);
16323 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
16324 update_end (f);
16325 }
16326
16327 /* Adjust Y positions of reused rows. */
16328 bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
16329 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
16330 max_y = it.last_visible_y;
16331 for (row = first_reusable_row; row < first_row_to_display; ++row)
16332 {
16333 row->y -= dy;
16334 row->visible_height = row->height;
16335 if (row->y < min_y)
16336 row->visible_height -= min_y - row->y;
16337 if (row->y + row->height > max_y)
16338 row->visible_height -= row->y + row->height - max_y;
16339 if (row->fringe_bitmap_periodic_p)
16340 row->redraw_fringe_bitmaps_p = 1;
16341 }
16342
16343 /* Scroll the current matrix. */
16344 xassert (nrows_scrolled > 0);
16345 rotate_matrix (w->current_matrix,
16346 start_vpos,
16347 MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
16348 -nrows_scrolled);
16349
16350 /* Disable rows not reused. */
16351 for (row -= nrows_scrolled; row < bottom_row; ++row)
16352 row->enabled_p = 0;
16353
16354 /* Point may have moved to a different line, so we cannot assume that
16355 the previous cursor position is valid; locate the correct row. */
16356 if (pt_row)
16357 {
16358 for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
16359 row < bottom_row && PT >= MATRIX_ROW_END_CHARPOS (row);
16360 row++)
16361 {
16362 w->cursor.vpos++;
16363 w->cursor.y = row->y;
16364 }
16365 if (row < bottom_row)
16366 {
16367 struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
16368 struct glyph *end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
16369
16370 /* Can't use this optimization with bidi-reordered glyph
16371 rows, unless cursor is already at point. */
16372 if (!NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering)))
16373 {
16374 if (!(w->cursor.hpos >= 0
16375 && w->cursor.hpos < row->used[TEXT_AREA]
16376 && BUFFERP (glyph->object)
16377 && glyph->charpos == PT))
16378 return 0;
16379 }
16380 else
16381 for (; glyph < end
16382 && (!BUFFERP (glyph->object)
16383 || glyph->charpos < PT);
16384 glyph++)
16385 {
16386 w->cursor.hpos++;
16387 w->cursor.x += glyph->pixel_width;
16388 }
16389 }
16390 }
16391
16392 /* Adjust window end. A null value of last_text_row means that
16393 the window end is in reused rows which in turn means that
16394 only its vpos can have changed. */
16395 if (last_text_row)
16396 {
16397 w->window_end_bytepos
16398 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
16399 w->window_end_pos
16400 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
16401 w->window_end_vpos
16402 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
16403 }
16404 else
16405 {
16406 w->window_end_vpos
16407 = make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled);
16408 }
16409
16410 w->window_end_valid = Qnil;
16411 w->desired_matrix->no_scrolling_p = 1;
16412
16413 #if GLYPH_DEBUG
16414 debug_method_add (w, "try_window_reusing_current_matrix 2");
16415 #endif
16416 return 1;
16417 }
16418
16419 return 0;
16420 }
16421
16422
16423 \f
16424 /************************************************************************
16425 Window redisplay reusing current matrix when buffer has changed
16426 ************************************************************************/
16427
16428 static struct glyph_row *find_last_unchanged_at_beg_row (struct window *);
16429 static struct glyph_row *find_first_unchanged_at_end_row (struct window *,
16430 ptrdiff_t *, ptrdiff_t *);
16431 static struct glyph_row *
16432 find_last_row_displaying_text (struct glyph_matrix *, struct it *,
16433 struct glyph_row *);
16434
16435
16436 /* Return the last row in MATRIX displaying text. If row START is
16437 non-null, start searching with that row. IT gives the dimensions
16438 of the display. Value is null if matrix is empty; otherwise it is
16439 a pointer to the row found. */
16440
16441 static struct glyph_row *
16442 find_last_row_displaying_text (struct glyph_matrix *matrix, struct it *it,
16443 struct glyph_row *start)
16444 {
16445 struct glyph_row *row, *row_found;
16446
16447 /* Set row_found to the last row in IT->w's current matrix
16448 displaying text. The loop looks funny but think of partially
16449 visible lines. */
16450 row_found = NULL;
16451 row = start ? start : MATRIX_FIRST_TEXT_ROW (matrix);
16452 while (MATRIX_ROW_DISPLAYS_TEXT_P (row))
16453 {
16454 xassert (row->enabled_p);
16455 row_found = row;
16456 if (MATRIX_ROW_BOTTOM_Y (row) >= it->last_visible_y)
16457 break;
16458 ++row;
16459 }
16460
16461 return row_found;
16462 }
16463
16464
16465 /* Return the last row in the current matrix of W that is not affected
16466 by changes at the start of current_buffer that occurred since W's
16467 current matrix was built. Value is null if no such row exists.
16468
16469 BEG_UNCHANGED us the number of characters unchanged at the start of
16470 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
16471 first changed character in current_buffer. Characters at positions <
16472 BEG + BEG_UNCHANGED are at the same buffer positions as they were
16473 when the current matrix was built. */
16474
16475 static struct glyph_row *
16476 find_last_unchanged_at_beg_row (struct window *w)
16477 {
16478 ptrdiff_t first_changed_pos = BEG + BEG_UNCHANGED;
16479 struct glyph_row *row;
16480 struct glyph_row *row_found = NULL;
16481 int yb = window_text_bottom_y (w);
16482
16483 /* Find the last row displaying unchanged text. */
16484 for (row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
16485 MATRIX_ROW_DISPLAYS_TEXT_P (row)
16486 && MATRIX_ROW_START_CHARPOS (row) < first_changed_pos;
16487 ++row)
16488 {
16489 if (/* If row ends before first_changed_pos, it is unchanged,
16490 except in some case. */
16491 MATRIX_ROW_END_CHARPOS (row) <= first_changed_pos
16492 /* When row ends in ZV and we write at ZV it is not
16493 unchanged. */
16494 && !row->ends_at_zv_p
16495 /* When first_changed_pos is the end of a continued line,
16496 row is not unchanged because it may be no longer
16497 continued. */
16498 && !(MATRIX_ROW_END_CHARPOS (row) == first_changed_pos
16499 && (row->continued_p
16500 || row->exact_window_width_line_p)))
16501 row_found = row;
16502
16503 /* Stop if last visible row. */
16504 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
16505 break;
16506 }
16507
16508 return row_found;
16509 }
16510
16511
16512 /* Find the first glyph row in the current matrix of W that is not
16513 affected by changes at the end of current_buffer since the
16514 time W's current matrix was built.
16515
16516 Return in *DELTA the number of chars by which buffer positions in
16517 unchanged text at the end of current_buffer must be adjusted.
16518
16519 Return in *DELTA_BYTES the corresponding number of bytes.
16520
16521 Value is null if no such row exists, i.e. all rows are affected by
16522 changes. */
16523
16524 static struct glyph_row *
16525 find_first_unchanged_at_end_row (struct window *w,
16526 ptrdiff_t *delta, ptrdiff_t *delta_bytes)
16527 {
16528 struct glyph_row *row;
16529 struct glyph_row *row_found = NULL;
16530
16531 *delta = *delta_bytes = 0;
16532
16533 /* Display must not have been paused, otherwise the current matrix
16534 is not up to date. */
16535 eassert (!NILP (w->window_end_valid));
16536
16537 /* A value of window_end_pos >= END_UNCHANGED means that the window
16538 end is in the range of changed text. If so, there is no
16539 unchanged row at the end of W's current matrix. */
16540 if (XFASTINT (w->window_end_pos) >= END_UNCHANGED)
16541 return NULL;
16542
16543 /* Set row to the last row in W's current matrix displaying text. */
16544 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
16545
16546 /* If matrix is entirely empty, no unchanged row exists. */
16547 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
16548 {
16549 /* The value of row is the last glyph row in the matrix having a
16550 meaningful buffer position in it. The end position of row
16551 corresponds to window_end_pos. This allows us to translate
16552 buffer positions in the current matrix to current buffer
16553 positions for characters not in changed text. */
16554 ptrdiff_t Z_old =
16555 MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
16556 ptrdiff_t Z_BYTE_old =
16557 MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
16558 ptrdiff_t last_unchanged_pos, last_unchanged_pos_old;
16559 struct glyph_row *first_text_row
16560 = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
16561
16562 *delta = Z - Z_old;
16563 *delta_bytes = Z_BYTE - Z_BYTE_old;
16564
16565 /* Set last_unchanged_pos to the buffer position of the last
16566 character in the buffer that has not been changed. Z is the
16567 index + 1 of the last character in current_buffer, i.e. by
16568 subtracting END_UNCHANGED we get the index of the last
16569 unchanged character, and we have to add BEG to get its buffer
16570 position. */
16571 last_unchanged_pos = Z - END_UNCHANGED + BEG;
16572 last_unchanged_pos_old = last_unchanged_pos - *delta;
16573
16574 /* Search backward from ROW for a row displaying a line that
16575 starts at a minimum position >= last_unchanged_pos_old. */
16576 for (; row > first_text_row; --row)
16577 {
16578 /* This used to abort, but it can happen.
16579 It is ok to just stop the search instead here. KFS. */
16580 if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
16581 break;
16582
16583 if (MATRIX_ROW_START_CHARPOS (row) >= last_unchanged_pos_old)
16584 row_found = row;
16585 }
16586 }
16587
16588 eassert (!row_found || MATRIX_ROW_DISPLAYS_TEXT_P (row_found));
16589
16590 return row_found;
16591 }
16592
16593
16594 /* Make sure that glyph rows in the current matrix of window W
16595 reference the same glyph memory as corresponding rows in the
16596 frame's frame matrix. This function is called after scrolling W's
16597 current matrix on a terminal frame in try_window_id and
16598 try_window_reusing_current_matrix. */
16599
16600 static void
16601 sync_frame_with_window_matrix_rows (struct window *w)
16602 {
16603 struct frame *f = XFRAME (w->frame);
16604 struct glyph_row *window_row, *window_row_end, *frame_row;
16605
16606 /* Preconditions: W must be a leaf window and full-width. Its frame
16607 must have a frame matrix. */
16608 xassert (NILP (w->hchild) && NILP (w->vchild));
16609 xassert (WINDOW_FULL_WIDTH_P (w));
16610 xassert (!FRAME_WINDOW_P (f));
16611
16612 /* If W is a full-width window, glyph pointers in W's current matrix
16613 have, by definition, to be the same as glyph pointers in the
16614 corresponding frame matrix. Note that frame matrices have no
16615 marginal areas (see build_frame_matrix). */
16616 window_row = w->current_matrix->rows;
16617 window_row_end = window_row + w->current_matrix->nrows;
16618 frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
16619 while (window_row < window_row_end)
16620 {
16621 struct glyph *start = window_row->glyphs[LEFT_MARGIN_AREA];
16622 struct glyph *end = window_row->glyphs[LAST_AREA];
16623
16624 frame_row->glyphs[LEFT_MARGIN_AREA] = start;
16625 frame_row->glyphs[TEXT_AREA] = start;
16626 frame_row->glyphs[RIGHT_MARGIN_AREA] = end;
16627 frame_row->glyphs[LAST_AREA] = end;
16628
16629 /* Disable frame rows whose corresponding window rows have
16630 been disabled in try_window_id. */
16631 if (!window_row->enabled_p)
16632 frame_row->enabled_p = 0;
16633
16634 ++window_row, ++frame_row;
16635 }
16636 }
16637
16638
16639 /* Find the glyph row in window W containing CHARPOS. Consider all
16640 rows between START and END (not inclusive). END null means search
16641 all rows to the end of the display area of W. Value is the row
16642 containing CHARPOS or null. */
16643
16644 struct glyph_row *
16645 row_containing_pos (struct window *w, ptrdiff_t charpos,
16646 struct glyph_row *start, struct glyph_row *end, int dy)
16647 {
16648 struct glyph_row *row = start;
16649 struct glyph_row *best_row = NULL;
16650 ptrdiff_t mindif = BUF_ZV (XBUFFER (w->buffer)) + 1;
16651 int last_y;
16652
16653 /* If we happen to start on a header-line, skip that. */
16654 if (row->mode_line_p)
16655 ++row;
16656
16657 if ((end && row >= end) || !row->enabled_p)
16658 return NULL;
16659
16660 last_y = window_text_bottom_y (w) - dy;
16661
16662 while (1)
16663 {
16664 /* Give up if we have gone too far. */
16665 if (end && row >= end)
16666 return NULL;
16667 /* This formerly returned if they were equal.
16668 I think that both quantities are of a "last plus one" type;
16669 if so, when they are equal, the row is within the screen. -- rms. */
16670 if (MATRIX_ROW_BOTTOM_Y (row) > last_y)
16671 return NULL;
16672
16673 /* If it is in this row, return this row. */
16674 if (! (MATRIX_ROW_END_CHARPOS (row) < charpos
16675 || (MATRIX_ROW_END_CHARPOS (row) == charpos
16676 /* The end position of a row equals the start
16677 position of the next row. If CHARPOS is there, we
16678 would rather display it in the next line, except
16679 when this line ends in ZV. */
16680 && !row->ends_at_zv_p
16681 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
16682 && charpos >= MATRIX_ROW_START_CHARPOS (row))
16683 {
16684 struct glyph *g;
16685
16686 if (NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering))
16687 || (!best_row && !row->continued_p))
16688 return row;
16689 /* In bidi-reordered rows, there could be several rows
16690 occluding point, all of them belonging to the same
16691 continued line. We need to find the row which fits
16692 CHARPOS the best. */
16693 for (g = row->glyphs[TEXT_AREA];
16694 g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
16695 g++)
16696 {
16697 if (!STRINGP (g->object))
16698 {
16699 if (g->charpos > 0 && eabs (g->charpos - charpos) < mindif)
16700 {
16701 mindif = eabs (g->charpos - charpos);
16702 best_row = row;
16703 /* Exact match always wins. */
16704 if (mindif == 0)
16705 return best_row;
16706 }
16707 }
16708 }
16709 }
16710 else if (best_row && !row->continued_p)
16711 return best_row;
16712 ++row;
16713 }
16714 }
16715
16716
16717 /* Try to redisplay window W by reusing its existing display. W's
16718 current matrix must be up to date when this function is called,
16719 i.e. window_end_valid must not be nil.
16720
16721 Value is
16722
16723 1 if display has been updated
16724 0 if otherwise unsuccessful
16725 -1 if redisplay with same window start is known not to succeed
16726
16727 The following steps are performed:
16728
16729 1. Find the last row in the current matrix of W that is not
16730 affected by changes at the start of current_buffer. If no such row
16731 is found, give up.
16732
16733 2. Find the first row in W's current matrix that is not affected by
16734 changes at the end of current_buffer. Maybe there is no such row.
16735
16736 3. Display lines beginning with the row + 1 found in step 1 to the
16737 row found in step 2 or, if step 2 didn't find a row, to the end of
16738 the window.
16739
16740 4. If cursor is not known to appear on the window, give up.
16741
16742 5. If display stopped at the row found in step 2, scroll the
16743 display and current matrix as needed.
16744
16745 6. Maybe display some lines at the end of W, if we must. This can
16746 happen under various circumstances, like a partially visible line
16747 becoming fully visible, or because newly displayed lines are displayed
16748 in smaller font sizes.
16749
16750 7. Update W's window end information. */
16751
16752 static int
16753 try_window_id (struct window *w)
16754 {
16755 struct frame *f = XFRAME (w->frame);
16756 struct glyph_matrix *current_matrix = w->current_matrix;
16757 struct glyph_matrix *desired_matrix = w->desired_matrix;
16758 struct glyph_row *last_unchanged_at_beg_row;
16759 struct glyph_row *first_unchanged_at_end_row;
16760 struct glyph_row *row;
16761 struct glyph_row *bottom_row;
16762 int bottom_vpos;
16763 struct it it;
16764 ptrdiff_t delta = 0, delta_bytes = 0, stop_pos;
16765 int dvpos, dy;
16766 struct text_pos start_pos;
16767 struct run run;
16768 int first_unchanged_at_end_vpos = 0;
16769 struct glyph_row *last_text_row, *last_text_row_at_end;
16770 struct text_pos start;
16771 ptrdiff_t first_changed_charpos, last_changed_charpos;
16772
16773 #if GLYPH_DEBUG
16774 if (inhibit_try_window_id)
16775 return 0;
16776 #endif
16777
16778 /* This is handy for debugging. */
16779 #if 0
16780 #define GIVE_UP(X) \
16781 do { \
16782 fprintf (stderr, "try_window_id give up %d\n", (X)); \
16783 return 0; \
16784 } while (0)
16785 #else
16786 #define GIVE_UP(X) return 0
16787 #endif
16788
16789 SET_TEXT_POS_FROM_MARKER (start, w->start);
16790
16791 /* Don't use this for mini-windows because these can show
16792 messages and mini-buffers, and we don't handle that here. */
16793 if (MINI_WINDOW_P (w))
16794 GIVE_UP (1);
16795
16796 /* This flag is used to prevent redisplay optimizations. */
16797 if (windows_or_buffers_changed || cursor_type_changed)
16798 GIVE_UP (2);
16799
16800 /* Verify that narrowing has not changed.
16801 Also verify that we were not told to prevent redisplay optimizations.
16802 It would be nice to further
16803 reduce the number of cases where this prevents try_window_id. */
16804 if (current_buffer->clip_changed
16805 || current_buffer->prevent_redisplay_optimizations_p)
16806 GIVE_UP (3);
16807
16808 /* Window must either use window-based redisplay or be full width. */
16809 if (!FRAME_WINDOW_P (f)
16810 && (!FRAME_LINE_INS_DEL_OK (f)
16811 || !WINDOW_FULL_WIDTH_P (w)))
16812 GIVE_UP (4);
16813
16814 /* Give up if point is known NOT to appear in W. */
16815 if (PT < CHARPOS (start))
16816 GIVE_UP (5);
16817
16818 /* Another way to prevent redisplay optimizations. */
16819 if (XFASTINT (w->last_modified) == 0)
16820 GIVE_UP (6);
16821
16822 /* Verify that window is not hscrolled. */
16823 if (XFASTINT (w->hscroll) != 0)
16824 GIVE_UP (7);
16825
16826 /* Verify that display wasn't paused. */
16827 if (NILP (w->window_end_valid))
16828 GIVE_UP (8);
16829
16830 /* Can't use this if highlighting a region because a cursor movement
16831 will do more than just set the cursor. */
16832 if (!NILP (Vtransient_mark_mode)
16833 && !NILP (BVAR (current_buffer, mark_active)))
16834 GIVE_UP (9);
16835
16836 /* Likewise if highlighting trailing whitespace. */
16837 if (!NILP (Vshow_trailing_whitespace))
16838 GIVE_UP (11);
16839
16840 /* Likewise if showing a region. */
16841 if (!NILP (w->region_showing))
16842 GIVE_UP (10);
16843
16844 /* Can't use this if overlay arrow position and/or string have
16845 changed. */
16846 if (overlay_arrows_changed_p ())
16847 GIVE_UP (12);
16848
16849 /* When word-wrap is on, adding a space to the first word of a
16850 wrapped line can change the wrap position, altering the line
16851 above it. It might be worthwhile to handle this more
16852 intelligently, but for now just redisplay from scratch. */
16853 if (!NILP (BVAR (XBUFFER (w->buffer), word_wrap)))
16854 GIVE_UP (21);
16855
16856 /* Under bidi reordering, adding or deleting a character in the
16857 beginning of a paragraph, before the first strong directional
16858 character, can change the base direction of the paragraph (unless
16859 the buffer specifies a fixed paragraph direction), which will
16860 require to redisplay the whole paragraph. It might be worthwhile
16861 to find the paragraph limits and widen the range of redisplayed
16862 lines to that, but for now just give up this optimization and
16863 redisplay from scratch. */
16864 if (!NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering))
16865 && NILP (BVAR (XBUFFER (w->buffer), bidi_paragraph_direction)))
16866 GIVE_UP (22);
16867
16868 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
16869 only if buffer has really changed. The reason is that the gap is
16870 initially at Z for freshly visited files. The code below would
16871 set end_unchanged to 0 in that case. */
16872 if (MODIFF > SAVE_MODIFF
16873 /* This seems to happen sometimes after saving a buffer. */
16874 || BEG_UNCHANGED + END_UNCHANGED > Z_BYTE)
16875 {
16876 if (GPT - BEG < BEG_UNCHANGED)
16877 BEG_UNCHANGED = GPT - BEG;
16878 if (Z - GPT < END_UNCHANGED)
16879 END_UNCHANGED = Z - GPT;
16880 }
16881
16882 /* The position of the first and last character that has been changed. */
16883 first_changed_charpos = BEG + BEG_UNCHANGED;
16884 last_changed_charpos = Z - END_UNCHANGED;
16885
16886 /* If window starts after a line end, and the last change is in
16887 front of that newline, then changes don't affect the display.
16888 This case happens with stealth-fontification. Note that although
16889 the display is unchanged, glyph positions in the matrix have to
16890 be adjusted, of course. */
16891 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
16892 if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
16893 && ((last_changed_charpos < CHARPOS (start)
16894 && CHARPOS (start) == BEGV)
16895 || (last_changed_charpos < CHARPOS (start) - 1
16896 && FETCH_BYTE (BYTEPOS (start) - 1) == '\n')))
16897 {
16898 ptrdiff_t Z_old, Z_delta, Z_BYTE_old, Z_delta_bytes;
16899 struct glyph_row *r0;
16900
16901 /* Compute how many chars/bytes have been added to or removed
16902 from the buffer. */
16903 Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
16904 Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
16905 Z_delta = Z - Z_old;
16906 Z_delta_bytes = Z_BYTE - Z_BYTE_old;
16907
16908 /* Give up if PT is not in the window. Note that it already has
16909 been checked at the start of try_window_id that PT is not in
16910 front of the window start. */
16911 if (PT >= MATRIX_ROW_END_CHARPOS (row) + Z_delta)
16912 GIVE_UP (13);
16913
16914 /* If window start is unchanged, we can reuse the whole matrix
16915 as is, after adjusting glyph positions. No need to compute
16916 the window end again, since its offset from Z hasn't changed. */
16917 r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
16918 if (CHARPOS (start) == MATRIX_ROW_START_CHARPOS (r0) + Z_delta
16919 && BYTEPOS (start) == MATRIX_ROW_START_BYTEPOS (r0) + Z_delta_bytes
16920 /* PT must not be in a partially visible line. */
16921 && !(PT >= MATRIX_ROW_START_CHARPOS (row) + Z_delta
16922 && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
16923 {
16924 /* Adjust positions in the glyph matrix. */
16925 if (Z_delta || Z_delta_bytes)
16926 {
16927 struct glyph_row *r1
16928 = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
16929 increment_matrix_positions (w->current_matrix,
16930 MATRIX_ROW_VPOS (r0, current_matrix),
16931 MATRIX_ROW_VPOS (r1, current_matrix),
16932 Z_delta, Z_delta_bytes);
16933 }
16934
16935 /* Set the cursor. */
16936 row = row_containing_pos (w, PT, r0, NULL, 0);
16937 if (row)
16938 set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
16939 else
16940 abort ();
16941 return 1;
16942 }
16943 }
16944
16945 /* Handle the case that changes are all below what is displayed in
16946 the window, and that PT is in the window. This shortcut cannot
16947 be taken if ZV is visible in the window, and text has been added
16948 there that is visible in the window. */
16949 if (first_changed_charpos >= MATRIX_ROW_END_CHARPOS (row)
16950 /* ZV is not visible in the window, or there are no
16951 changes at ZV, actually. */
16952 && (current_matrix->zv > MATRIX_ROW_END_CHARPOS (row)
16953 || first_changed_charpos == last_changed_charpos))
16954 {
16955 struct glyph_row *r0;
16956
16957 /* Give up if PT is not in the window. Note that it already has
16958 been checked at the start of try_window_id that PT is not in
16959 front of the window start. */
16960 if (PT >= MATRIX_ROW_END_CHARPOS (row))
16961 GIVE_UP (14);
16962
16963 /* If window start is unchanged, we can reuse the whole matrix
16964 as is, without changing glyph positions since no text has
16965 been added/removed in front of the window end. */
16966 r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
16967 if (TEXT_POS_EQUAL_P (start, r0->minpos)
16968 /* PT must not be in a partially visible line. */
16969 && !(PT >= MATRIX_ROW_START_CHARPOS (row)
16970 && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
16971 {
16972 /* We have to compute the window end anew since text
16973 could have been added/removed after it. */
16974 w->window_end_pos
16975 = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
16976 w->window_end_bytepos
16977 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
16978
16979 /* Set the cursor. */
16980 row = row_containing_pos (w, PT, r0, NULL, 0);
16981 if (row)
16982 set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
16983 else
16984 abort ();
16985 return 2;
16986 }
16987 }
16988
16989 /* Give up if window start is in the changed area.
16990
16991 The condition used to read
16992
16993 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
16994
16995 but why that was tested escapes me at the moment. */
16996 if (CHARPOS (start) >= first_changed_charpos
16997 && CHARPOS (start) <= last_changed_charpos)
16998 GIVE_UP (15);
16999
17000 /* Check that window start agrees with the start of the first glyph
17001 row in its current matrix. Check this after we know the window
17002 start is not in changed text, otherwise positions would not be
17003 comparable. */
17004 row = MATRIX_FIRST_TEXT_ROW (current_matrix);
17005 if (!TEXT_POS_EQUAL_P (start, row->minpos))
17006 GIVE_UP (16);
17007
17008 /* Give up if the window ends in strings. Overlay strings
17009 at the end are difficult to handle, so don't try. */
17010 row = MATRIX_ROW (current_matrix, XFASTINT (w->window_end_vpos));
17011 if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
17012 GIVE_UP (20);
17013
17014 /* Compute the position at which we have to start displaying new
17015 lines. Some of the lines at the top of the window might be
17016 reusable because they are not displaying changed text. Find the
17017 last row in W's current matrix not affected by changes at the
17018 start of current_buffer. Value is null if changes start in the
17019 first line of window. */
17020 last_unchanged_at_beg_row = find_last_unchanged_at_beg_row (w);
17021 if (last_unchanged_at_beg_row)
17022 {
17023 /* Avoid starting to display in the moddle of a character, a TAB
17024 for instance. This is easier than to set up the iterator
17025 exactly, and it's not a frequent case, so the additional
17026 effort wouldn't really pay off. */
17027 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row)
17028 || last_unchanged_at_beg_row->ends_in_newline_from_string_p)
17029 && last_unchanged_at_beg_row > w->current_matrix->rows)
17030 --last_unchanged_at_beg_row;
17031
17032 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row))
17033 GIVE_UP (17);
17034
17035 if (init_to_row_end (&it, w, last_unchanged_at_beg_row) == 0)
17036 GIVE_UP (18);
17037 start_pos = it.current.pos;
17038
17039 /* Start displaying new lines in the desired matrix at the same
17040 vpos we would use in the current matrix, i.e. below
17041 last_unchanged_at_beg_row. */
17042 it.vpos = 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row,
17043 current_matrix);
17044 it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
17045 it.current_y = MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row);
17046
17047 xassert (it.hpos == 0 && it.current_x == 0);
17048 }
17049 else
17050 {
17051 /* There are no reusable lines at the start of the window.
17052 Start displaying in the first text line. */
17053 start_display (&it, w, start);
17054 it.vpos = it.first_vpos;
17055 start_pos = it.current.pos;
17056 }
17057
17058 /* Find the first row that is not affected by changes at the end of
17059 the buffer. Value will be null if there is no unchanged row, in
17060 which case we must redisplay to the end of the window. delta
17061 will be set to the value by which buffer positions beginning with
17062 first_unchanged_at_end_row have to be adjusted due to text
17063 changes. */
17064 first_unchanged_at_end_row
17065 = find_first_unchanged_at_end_row (w, &delta, &delta_bytes);
17066 IF_DEBUG (debug_delta = delta);
17067 IF_DEBUG (debug_delta_bytes = delta_bytes);
17068
17069 /* Set stop_pos to the buffer position up to which we will have to
17070 display new lines. If first_unchanged_at_end_row != NULL, this
17071 is the buffer position of the start of the line displayed in that
17072 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
17073 that we don't stop at a buffer position. */
17074 stop_pos = 0;
17075 if (first_unchanged_at_end_row)
17076 {
17077 xassert (last_unchanged_at_beg_row == NULL
17078 || first_unchanged_at_end_row >= last_unchanged_at_beg_row);
17079
17080 /* If this is a continuation line, move forward to the next one
17081 that isn't. Changes in lines above affect this line.
17082 Caution: this may move first_unchanged_at_end_row to a row
17083 not displaying text. */
17084 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row)
17085 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
17086 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
17087 < it.last_visible_y))
17088 ++first_unchanged_at_end_row;
17089
17090 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
17091 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
17092 >= it.last_visible_y))
17093 first_unchanged_at_end_row = NULL;
17094 else
17095 {
17096 stop_pos = (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row)
17097 + delta);
17098 first_unchanged_at_end_vpos
17099 = MATRIX_ROW_VPOS (first_unchanged_at_end_row, current_matrix);
17100 xassert (stop_pos >= Z - END_UNCHANGED);
17101 }
17102 }
17103 else if (last_unchanged_at_beg_row == NULL)
17104 GIVE_UP (19);
17105
17106
17107 #if GLYPH_DEBUG
17108
17109 /* Either there is no unchanged row at the end, or the one we have
17110 now displays text. This is a necessary condition for the window
17111 end pos calculation at the end of this function. */
17112 xassert (first_unchanged_at_end_row == NULL
17113 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
17114
17115 debug_last_unchanged_at_beg_vpos
17116 = (last_unchanged_at_beg_row
17117 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row, current_matrix)
17118 : -1);
17119 debug_first_unchanged_at_end_vpos = first_unchanged_at_end_vpos;
17120
17121 #endif /* GLYPH_DEBUG != 0 */
17122
17123
17124 /* Display new lines. Set last_text_row to the last new line
17125 displayed which has text on it, i.e. might end up as being the
17126 line where the window_end_vpos is. */
17127 w->cursor.vpos = -1;
17128 last_text_row = NULL;
17129 overlay_arrow_seen = 0;
17130 while (it.current_y < it.last_visible_y
17131 && !fonts_changed_p
17132 && (first_unchanged_at_end_row == NULL
17133 || IT_CHARPOS (it) < stop_pos))
17134 {
17135 if (display_line (&it))
17136 last_text_row = it.glyph_row - 1;
17137 }
17138
17139 if (fonts_changed_p)
17140 return -1;
17141
17142
17143 /* Compute differences in buffer positions, y-positions etc. for
17144 lines reused at the bottom of the window. Compute what we can
17145 scroll. */
17146 if (first_unchanged_at_end_row
17147 /* No lines reused because we displayed everything up to the
17148 bottom of the window. */
17149 && it.current_y < it.last_visible_y)
17150 {
17151 dvpos = (it.vpos
17152 - MATRIX_ROW_VPOS (first_unchanged_at_end_row,
17153 current_matrix));
17154 dy = it.current_y - first_unchanged_at_end_row->y;
17155 run.current_y = first_unchanged_at_end_row->y;
17156 run.desired_y = run.current_y + dy;
17157 run.height = it.last_visible_y - max (run.current_y, run.desired_y);
17158 }
17159 else
17160 {
17161 delta = delta_bytes = dvpos = dy
17162 = run.current_y = run.desired_y = run.height = 0;
17163 first_unchanged_at_end_row = NULL;
17164 }
17165 IF_DEBUG (debug_dvpos = dvpos; debug_dy = dy);
17166
17167
17168 /* Find the cursor if not already found. We have to decide whether
17169 PT will appear on this window (it sometimes doesn't, but this is
17170 not a very frequent case.) This decision has to be made before
17171 the current matrix is altered. A value of cursor.vpos < 0 means
17172 that PT is either in one of the lines beginning at
17173 first_unchanged_at_end_row or below the window. Don't care for
17174 lines that might be displayed later at the window end; as
17175 mentioned, this is not a frequent case. */
17176 if (w->cursor.vpos < 0)
17177 {
17178 /* Cursor in unchanged rows at the top? */
17179 if (PT < CHARPOS (start_pos)
17180 && last_unchanged_at_beg_row)
17181 {
17182 row = row_containing_pos (w, PT,
17183 MATRIX_FIRST_TEXT_ROW (w->current_matrix),
17184 last_unchanged_at_beg_row + 1, 0);
17185 if (row)
17186 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
17187 }
17188
17189 /* Start from first_unchanged_at_end_row looking for PT. */
17190 else if (first_unchanged_at_end_row)
17191 {
17192 row = row_containing_pos (w, PT - delta,
17193 first_unchanged_at_end_row, NULL, 0);
17194 if (row)
17195 set_cursor_from_row (w, row, w->current_matrix, delta,
17196 delta_bytes, dy, dvpos);
17197 }
17198
17199 /* Give up if cursor was not found. */
17200 if (w->cursor.vpos < 0)
17201 {
17202 clear_glyph_matrix (w->desired_matrix);
17203 return -1;
17204 }
17205 }
17206
17207 /* Don't let the cursor end in the scroll margins. */
17208 {
17209 int this_scroll_margin, cursor_height;
17210
17211 this_scroll_margin =
17212 max (0, min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4));
17213 this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
17214 cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
17215
17216 if ((w->cursor.y < this_scroll_margin
17217 && CHARPOS (start) > BEGV)
17218 /* Old redisplay didn't take scroll margin into account at the bottom,
17219 but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
17220 || (w->cursor.y + (make_cursor_line_fully_visible_p
17221 ? cursor_height + this_scroll_margin
17222 : 1)) > it.last_visible_y)
17223 {
17224 w->cursor.vpos = -1;
17225 clear_glyph_matrix (w->desired_matrix);
17226 return -1;
17227 }
17228 }
17229
17230 /* Scroll the display. Do it before changing the current matrix so
17231 that xterm.c doesn't get confused about where the cursor glyph is
17232 found. */
17233 if (dy && run.height)
17234 {
17235 update_begin (f);
17236
17237 if (FRAME_WINDOW_P (f))
17238 {
17239 FRAME_RIF (f)->update_window_begin_hook (w);
17240 FRAME_RIF (f)->clear_window_mouse_face (w);
17241 FRAME_RIF (f)->scroll_run_hook (w, &run);
17242 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
17243 }
17244 else
17245 {
17246 /* Terminal frame. In this case, dvpos gives the number of
17247 lines to scroll by; dvpos < 0 means scroll up. */
17248 int from_vpos
17249 = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
17250 int from = WINDOW_TOP_EDGE_LINE (w) + from_vpos;
17251 int end = (WINDOW_TOP_EDGE_LINE (w)
17252 + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0)
17253 + window_internal_height (w));
17254
17255 #if defined (HAVE_GPM) || defined (MSDOS)
17256 x_clear_window_mouse_face (w);
17257 #endif
17258 /* Perform the operation on the screen. */
17259 if (dvpos > 0)
17260 {
17261 /* Scroll last_unchanged_at_beg_row to the end of the
17262 window down dvpos lines. */
17263 set_terminal_window (f, end);
17264
17265 /* On dumb terminals delete dvpos lines at the end
17266 before inserting dvpos empty lines. */
17267 if (!FRAME_SCROLL_REGION_OK (f))
17268 ins_del_lines (f, end - dvpos, -dvpos);
17269
17270 /* Insert dvpos empty lines in front of
17271 last_unchanged_at_beg_row. */
17272 ins_del_lines (f, from, dvpos);
17273 }
17274 else if (dvpos < 0)
17275 {
17276 /* Scroll up last_unchanged_at_beg_vpos to the end of
17277 the window to last_unchanged_at_beg_vpos - |dvpos|. */
17278 set_terminal_window (f, end);
17279
17280 /* Delete dvpos lines in front of
17281 last_unchanged_at_beg_vpos. ins_del_lines will set
17282 the cursor to the given vpos and emit |dvpos| delete
17283 line sequences. */
17284 ins_del_lines (f, from + dvpos, dvpos);
17285
17286 /* On a dumb terminal insert dvpos empty lines at the
17287 end. */
17288 if (!FRAME_SCROLL_REGION_OK (f))
17289 ins_del_lines (f, end + dvpos, -dvpos);
17290 }
17291
17292 set_terminal_window (f, 0);
17293 }
17294
17295 update_end (f);
17296 }
17297
17298 /* Shift reused rows of the current matrix to the right position.
17299 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
17300 text. */
17301 bottom_row = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
17302 bottom_vpos = MATRIX_ROW_VPOS (bottom_row, current_matrix);
17303 if (dvpos < 0)
17304 {
17305 rotate_matrix (current_matrix, first_unchanged_at_end_vpos + dvpos,
17306 bottom_vpos, dvpos);
17307 enable_glyph_matrix_rows (current_matrix, bottom_vpos + dvpos,
17308 bottom_vpos, 0);
17309 }
17310 else if (dvpos > 0)
17311 {
17312 rotate_matrix (current_matrix, first_unchanged_at_end_vpos,
17313 bottom_vpos, dvpos);
17314 enable_glyph_matrix_rows (current_matrix, first_unchanged_at_end_vpos,
17315 first_unchanged_at_end_vpos + dvpos, 0);
17316 }
17317
17318 /* For frame-based redisplay, make sure that current frame and window
17319 matrix are in sync with respect to glyph memory. */
17320 if (!FRAME_WINDOW_P (f))
17321 sync_frame_with_window_matrix_rows (w);
17322
17323 /* Adjust buffer positions in reused rows. */
17324 if (delta || delta_bytes)
17325 increment_matrix_positions (current_matrix,
17326 first_unchanged_at_end_vpos + dvpos,
17327 bottom_vpos, delta, delta_bytes);
17328
17329 /* Adjust Y positions. */
17330 if (dy)
17331 shift_glyph_matrix (w, current_matrix,
17332 first_unchanged_at_end_vpos + dvpos,
17333 bottom_vpos, dy);
17334
17335 if (first_unchanged_at_end_row)
17336 {
17337 first_unchanged_at_end_row += dvpos;
17338 if (first_unchanged_at_end_row->y >= it.last_visible_y
17339 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row))
17340 first_unchanged_at_end_row = NULL;
17341 }
17342
17343 /* If scrolling up, there may be some lines to display at the end of
17344 the window. */
17345 last_text_row_at_end = NULL;
17346 if (dy < 0)
17347 {
17348 /* Scrolling up can leave for example a partially visible line
17349 at the end of the window to be redisplayed. */
17350 /* Set last_row to the glyph row in the current matrix where the
17351 window end line is found. It has been moved up or down in
17352 the matrix by dvpos. */
17353 int last_vpos = XFASTINT (w->window_end_vpos) + dvpos;
17354 struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
17355
17356 /* If last_row is the window end line, it should display text. */
17357 xassert (last_row->displays_text_p);
17358
17359 /* If window end line was partially visible before, begin
17360 displaying at that line. Otherwise begin displaying with the
17361 line following it. */
17362 if (MATRIX_ROW_BOTTOM_Y (last_row) - dy >= it.last_visible_y)
17363 {
17364 init_to_row_start (&it, w, last_row);
17365 it.vpos = last_vpos;
17366 it.current_y = last_row->y;
17367 }
17368 else
17369 {
17370 init_to_row_end (&it, w, last_row);
17371 it.vpos = 1 + last_vpos;
17372 it.current_y = MATRIX_ROW_BOTTOM_Y (last_row);
17373 ++last_row;
17374 }
17375
17376 /* We may start in a continuation line. If so, we have to
17377 get the right continuation_lines_width and current_x. */
17378 it.continuation_lines_width = last_row->continuation_lines_width;
17379 it.hpos = it.current_x = 0;
17380
17381 /* Display the rest of the lines at the window end. */
17382 it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
17383 while (it.current_y < it.last_visible_y
17384 && !fonts_changed_p)
17385 {
17386 /* Is it always sure that the display agrees with lines in
17387 the current matrix? I don't think so, so we mark rows
17388 displayed invalid in the current matrix by setting their
17389 enabled_p flag to zero. */
17390 MATRIX_ROW (w->current_matrix, it.vpos)->enabled_p = 0;
17391 if (display_line (&it))
17392 last_text_row_at_end = it.glyph_row - 1;
17393 }
17394 }
17395
17396 /* Update window_end_pos and window_end_vpos. */
17397 if (first_unchanged_at_end_row
17398 && !last_text_row_at_end)
17399 {
17400 /* Window end line if one of the preserved rows from the current
17401 matrix. Set row to the last row displaying text in current
17402 matrix starting at first_unchanged_at_end_row, after
17403 scrolling. */
17404 xassert (first_unchanged_at_end_row->displays_text_p);
17405 row = find_last_row_displaying_text (w->current_matrix, &it,
17406 first_unchanged_at_end_row);
17407 xassert (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
17408
17409 w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
17410 w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
17411 w->window_end_vpos
17412 = make_number (MATRIX_ROW_VPOS (row, w->current_matrix));
17413 xassert (w->window_end_bytepos >= 0);
17414 IF_DEBUG (debug_method_add (w, "A"));
17415 }
17416 else if (last_text_row_at_end)
17417 {
17418 w->window_end_pos
17419 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end));
17420 w->window_end_bytepos
17421 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row_at_end);
17422 w->window_end_vpos
17423 = make_number (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix));
17424 xassert (w->window_end_bytepos >= 0);
17425 IF_DEBUG (debug_method_add (w, "B"));
17426 }
17427 else if (last_text_row)
17428 {
17429 /* We have displayed either to the end of the window or at the
17430 end of the window, i.e. the last row with text is to be found
17431 in the desired matrix. */
17432 w->window_end_pos
17433 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
17434 w->window_end_bytepos
17435 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
17436 w->window_end_vpos
17437 = make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix));
17438 xassert (w->window_end_bytepos >= 0);
17439 }
17440 else if (first_unchanged_at_end_row == NULL
17441 && last_text_row == NULL
17442 && last_text_row_at_end == NULL)
17443 {
17444 /* Displayed to end of window, but no line containing text was
17445 displayed. Lines were deleted at the end of the window. */
17446 int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
17447 int vpos = XFASTINT (w->window_end_vpos);
17448 struct glyph_row *current_row = current_matrix->rows + vpos;
17449 struct glyph_row *desired_row = desired_matrix->rows + vpos;
17450
17451 for (row = NULL;
17452 row == NULL && vpos >= first_vpos;
17453 --vpos, --current_row, --desired_row)
17454 {
17455 if (desired_row->enabled_p)
17456 {
17457 if (desired_row->displays_text_p)
17458 row = desired_row;
17459 }
17460 else if (current_row->displays_text_p)
17461 row = current_row;
17462 }
17463
17464 xassert (row != NULL);
17465 w->window_end_vpos = make_number (vpos + 1);
17466 w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
17467 w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
17468 xassert (w->window_end_bytepos >= 0);
17469 IF_DEBUG (debug_method_add (w, "C"));
17470 }
17471 else
17472 abort ();
17473
17474 IF_DEBUG (debug_end_pos = XFASTINT (w->window_end_pos);
17475 debug_end_vpos = XFASTINT (w->window_end_vpos));
17476
17477 /* Record that display has not been completed. */
17478 w->window_end_valid = Qnil;
17479 w->desired_matrix->no_scrolling_p = 1;
17480 return 3;
17481
17482 #undef GIVE_UP
17483 }
17484
17485
17486 \f
17487 /***********************************************************************
17488 More debugging support
17489 ***********************************************************************/
17490
17491 #if GLYPH_DEBUG
17492
17493 void dump_glyph_row (struct glyph_row *, int, int) EXTERNALLY_VISIBLE;
17494 void dump_glyph_matrix (struct glyph_matrix *, int) EXTERNALLY_VISIBLE;
17495 void dump_glyph (struct glyph_row *, struct glyph *, int) EXTERNALLY_VISIBLE;
17496
17497
17498 /* Dump the contents of glyph matrix MATRIX on stderr.
17499
17500 GLYPHS 0 means don't show glyph contents.
17501 GLYPHS 1 means show glyphs in short form
17502 GLYPHS > 1 means show glyphs in long form. */
17503
17504 void
17505 dump_glyph_matrix (struct glyph_matrix *matrix, int glyphs)
17506 {
17507 int i;
17508 for (i = 0; i < matrix->nrows; ++i)
17509 dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
17510 }
17511
17512
17513 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
17514 the glyph row and area where the glyph comes from. */
17515
17516 void
17517 dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
17518 {
17519 if (glyph->type == CHAR_GLYPH)
17520 {
17521 fprintf (stderr,
17522 " %5td %4c %6"pI"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17523 glyph - row->glyphs[TEXT_AREA],
17524 'C',
17525 glyph->charpos,
17526 (BUFFERP (glyph->object)
17527 ? 'B'
17528 : (STRINGP (glyph->object)
17529 ? 'S'
17530 : '-')),
17531 glyph->pixel_width,
17532 glyph->u.ch,
17533 (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
17534 ? glyph->u.ch
17535 : '.'),
17536 glyph->face_id,
17537 glyph->left_box_line_p,
17538 glyph->right_box_line_p);
17539 }
17540 else if (glyph->type == STRETCH_GLYPH)
17541 {
17542 fprintf (stderr,
17543 " %5td %4c %6"pI"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17544 glyph - row->glyphs[TEXT_AREA],
17545 'S',
17546 glyph->charpos,
17547 (BUFFERP (glyph->object)
17548 ? 'B'
17549 : (STRINGP (glyph->object)
17550 ? 'S'
17551 : '-')),
17552 glyph->pixel_width,
17553 0,
17554 '.',
17555 glyph->face_id,
17556 glyph->left_box_line_p,
17557 glyph->right_box_line_p);
17558 }
17559 else if (glyph->type == IMAGE_GLYPH)
17560 {
17561 fprintf (stderr,
17562 " %5td %4c %6"pI"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17563 glyph - row->glyphs[TEXT_AREA],
17564 'I',
17565 glyph->charpos,
17566 (BUFFERP (glyph->object)
17567 ? 'B'
17568 : (STRINGP (glyph->object)
17569 ? 'S'
17570 : '-')),
17571 glyph->pixel_width,
17572 glyph->u.img_id,
17573 '.',
17574 glyph->face_id,
17575 glyph->left_box_line_p,
17576 glyph->right_box_line_p);
17577 }
17578 else if (glyph->type == COMPOSITE_GLYPH)
17579 {
17580 fprintf (stderr,
17581 " %5td %4c %6"pI"d %c %3d 0x%05x",
17582 glyph - row->glyphs[TEXT_AREA],
17583 '+',
17584 glyph->charpos,
17585 (BUFFERP (glyph->object)
17586 ? 'B'
17587 : (STRINGP (glyph->object)
17588 ? 'S'
17589 : '-')),
17590 glyph->pixel_width,
17591 glyph->u.cmp.id);
17592 if (glyph->u.cmp.automatic)
17593 fprintf (stderr,
17594 "[%d-%d]",
17595 glyph->slice.cmp.from, glyph->slice.cmp.to);
17596 fprintf (stderr, " . %4d %1.1d%1.1d\n",
17597 glyph->face_id,
17598 glyph->left_box_line_p,
17599 glyph->right_box_line_p);
17600 }
17601 }
17602
17603
17604 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
17605 GLYPHS 0 means don't show glyph contents.
17606 GLYPHS 1 means show glyphs in short form
17607 GLYPHS > 1 means show glyphs in long form. */
17608
17609 void
17610 dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
17611 {
17612 if (glyphs != 1)
17613 {
17614 fprintf (stderr, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
17615 fprintf (stderr, "======================================================================\n");
17616
17617 fprintf (stderr, "%3d %5"pI"d %5"pI"d %4d %1.1d%1.1d%1.1d%1.1d\
17618 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
17619 vpos,
17620 MATRIX_ROW_START_CHARPOS (row),
17621 MATRIX_ROW_END_CHARPOS (row),
17622 row->used[TEXT_AREA],
17623 row->contains_overlapping_glyphs_p,
17624 row->enabled_p,
17625 row->truncated_on_left_p,
17626 row->truncated_on_right_p,
17627 row->continued_p,
17628 MATRIX_ROW_CONTINUATION_LINE_P (row),
17629 row->displays_text_p,
17630 row->ends_at_zv_p,
17631 row->fill_line_p,
17632 row->ends_in_middle_of_char_p,
17633 row->starts_in_middle_of_char_p,
17634 row->mouse_face_p,
17635 row->x,
17636 row->y,
17637 row->pixel_width,
17638 row->height,
17639 row->visible_height,
17640 row->ascent,
17641 row->phys_ascent);
17642 fprintf (stderr, "%9"pD"d %5"pD"d\t%5d\n", row->start.overlay_string_index,
17643 row->end.overlay_string_index,
17644 row->continuation_lines_width);
17645 fprintf (stderr, "%9"pI"d %5"pI"d\n",
17646 CHARPOS (row->start.string_pos),
17647 CHARPOS (row->end.string_pos));
17648 fprintf (stderr, "%9d %5d\n", row->start.dpvec_index,
17649 row->end.dpvec_index);
17650 }
17651
17652 if (glyphs > 1)
17653 {
17654 int area;
17655
17656 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
17657 {
17658 struct glyph *glyph = row->glyphs[area];
17659 struct glyph *glyph_end = glyph + row->used[area];
17660
17661 /* Glyph for a line end in text. */
17662 if (area == TEXT_AREA && glyph == glyph_end && glyph->charpos > 0)
17663 ++glyph_end;
17664
17665 if (glyph < glyph_end)
17666 fprintf (stderr, " Glyph Type Pos O W Code C Face LR\n");
17667
17668 for (; glyph < glyph_end; ++glyph)
17669 dump_glyph (row, glyph, area);
17670 }
17671 }
17672 else if (glyphs == 1)
17673 {
17674 int area;
17675
17676 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
17677 {
17678 char *s = (char *) alloca (row->used[area] + 1);
17679 int i;
17680
17681 for (i = 0; i < row->used[area]; ++i)
17682 {
17683 struct glyph *glyph = row->glyphs[area] + i;
17684 if (glyph->type == CHAR_GLYPH
17685 && glyph->u.ch < 0x80
17686 && glyph->u.ch >= ' ')
17687 s[i] = glyph->u.ch;
17688 else
17689 s[i] = '.';
17690 }
17691
17692 s[i] = '\0';
17693 fprintf (stderr, "%3d: (%d) '%s'\n", vpos, row->enabled_p, s);
17694 }
17695 }
17696 }
17697
17698
17699 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix,
17700 Sdump_glyph_matrix, 0, 1, "p",
17701 doc: /* Dump the current matrix of the selected window to stderr.
17702 Shows contents of glyph row structures. With non-nil
17703 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
17704 glyphs in short form, otherwise show glyphs in long form. */)
17705 (Lisp_Object glyphs)
17706 {
17707 struct window *w = XWINDOW (selected_window);
17708 struct buffer *buffer = XBUFFER (w->buffer);
17709
17710 fprintf (stderr, "PT = %"pI"d, BEGV = %"pI"d. ZV = %"pI"d\n",
17711 BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
17712 fprintf (stderr, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
17713 w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos);
17714 fprintf (stderr, "=============================================\n");
17715 dump_glyph_matrix (w->current_matrix,
17716 TYPE_RANGED_INTEGERP (int, glyphs) ? XINT (glyphs) : 0);
17717 return Qnil;
17718 }
17719
17720
17721 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix,
17722 Sdump_frame_glyph_matrix, 0, 0, "", doc: /* */)
17723 (void)
17724 {
17725 struct frame *f = XFRAME (selected_frame);
17726 dump_glyph_matrix (f->current_matrix, 1);
17727 return Qnil;
17728 }
17729
17730
17731 DEFUN ("dump-glyph-row", Fdump_glyph_row, Sdump_glyph_row, 1, 2, "",
17732 doc: /* Dump glyph row ROW to stderr.
17733 GLYPH 0 means don't dump glyphs.
17734 GLYPH 1 means dump glyphs in short form.
17735 GLYPH > 1 or omitted means dump glyphs in long form. */)
17736 (Lisp_Object row, Lisp_Object glyphs)
17737 {
17738 struct glyph_matrix *matrix;
17739 EMACS_INT vpos;
17740
17741 CHECK_NUMBER (row);
17742 matrix = XWINDOW (selected_window)->current_matrix;
17743 vpos = XINT (row);
17744 if (vpos >= 0 && vpos < matrix->nrows)
17745 dump_glyph_row (MATRIX_ROW (matrix, vpos),
17746 vpos,
17747 TYPE_RANGED_INTEGERP (int, glyphs) ? XINT (glyphs) : 2);
17748 return Qnil;
17749 }
17750
17751
17752 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row, Sdump_tool_bar_row, 1, 2, "",
17753 doc: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
17754 GLYPH 0 means don't dump glyphs.
17755 GLYPH 1 means dump glyphs in short form.
17756 GLYPH > 1 or omitted means dump glyphs in long form. */)
17757 (Lisp_Object row, Lisp_Object glyphs)
17758 {
17759 struct frame *sf = SELECTED_FRAME ();
17760 struct glyph_matrix *m = XWINDOW (sf->tool_bar_window)->current_matrix;
17761 EMACS_INT vpos;
17762
17763 CHECK_NUMBER (row);
17764 vpos = XINT (row);
17765 if (vpos >= 0 && vpos < m->nrows)
17766 dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
17767 TYPE_RANGED_INTEGERP (int, glyphs) ? XINT (glyphs) : 2);
17768 return Qnil;
17769 }
17770
17771
17772 DEFUN ("trace-redisplay", Ftrace_redisplay, Strace_redisplay, 0, 1, "P",
17773 doc: /* Toggle tracing of redisplay.
17774 With ARG, turn tracing on if and only if ARG is positive. */)
17775 (Lisp_Object arg)
17776 {
17777 if (NILP (arg))
17778 trace_redisplay_p = !trace_redisplay_p;
17779 else
17780 {
17781 arg = Fprefix_numeric_value (arg);
17782 trace_redisplay_p = XINT (arg) > 0;
17783 }
17784
17785 return Qnil;
17786 }
17787
17788
17789 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
17790 doc: /* Like `format', but print result to stderr.
17791 usage: (trace-to-stderr STRING &rest OBJECTS) */)
17792 (ptrdiff_t nargs, Lisp_Object *args)
17793 {
17794 Lisp_Object s = Fformat (nargs, args);
17795 fprintf (stderr, "%s", SDATA (s));
17796 return Qnil;
17797 }
17798
17799 #endif /* GLYPH_DEBUG */
17800
17801
17802 \f
17803 /***********************************************************************
17804 Building Desired Matrix Rows
17805 ***********************************************************************/
17806
17807 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
17808 Used for non-window-redisplay windows, and for windows w/o left fringe. */
17809
17810 static struct glyph_row *
17811 get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
17812 {
17813 struct frame *f = XFRAME (WINDOW_FRAME (w));
17814 struct buffer *buffer = XBUFFER (w->buffer);
17815 struct buffer *old = current_buffer;
17816 const unsigned char *arrow_string = SDATA (overlay_arrow_string);
17817 int arrow_len = SCHARS (overlay_arrow_string);
17818 const unsigned char *arrow_end = arrow_string + arrow_len;
17819 const unsigned char *p;
17820 struct it it;
17821 int multibyte_p;
17822 int n_glyphs_before;
17823
17824 set_buffer_temp (buffer);
17825 init_iterator (&it, w, -1, -1, &scratch_glyph_row, DEFAULT_FACE_ID);
17826 it.glyph_row->used[TEXT_AREA] = 0;
17827 SET_TEXT_POS (it.position, 0, 0);
17828
17829 multibyte_p = !NILP (BVAR (buffer, enable_multibyte_characters));
17830 p = arrow_string;
17831 while (p < arrow_end)
17832 {
17833 Lisp_Object face, ilisp;
17834
17835 /* Get the next character. */
17836 if (multibyte_p)
17837 it.c = it.char_to_display = string_char_and_length (p, &it.len);
17838 else
17839 {
17840 it.c = it.char_to_display = *p, it.len = 1;
17841 if (! ASCII_CHAR_P (it.c))
17842 it.char_to_display = BYTE8_TO_CHAR (it.c);
17843 }
17844 p += it.len;
17845
17846 /* Get its face. */
17847 ilisp = make_number (p - arrow_string);
17848 face = Fget_text_property (ilisp, Qface, overlay_arrow_string);
17849 it.face_id = compute_char_face (f, it.char_to_display, face);
17850
17851 /* Compute its width, get its glyphs. */
17852 n_glyphs_before = it.glyph_row->used[TEXT_AREA];
17853 SET_TEXT_POS (it.position, -1, -1);
17854 PRODUCE_GLYPHS (&it);
17855
17856 /* If this character doesn't fit any more in the line, we have
17857 to remove some glyphs. */
17858 if (it.current_x > it.last_visible_x)
17859 {
17860 it.glyph_row->used[TEXT_AREA] = n_glyphs_before;
17861 break;
17862 }
17863 }
17864
17865 set_buffer_temp (old);
17866 return it.glyph_row;
17867 }
17868
17869
17870 /* Insert truncation glyphs at the start of IT->glyph_row. Truncation
17871 glyphs are only inserted for terminal frames since we can't really
17872 win with truncation glyphs when partially visible glyphs are
17873 involved. Which glyphs to insert is determined by
17874 produce_special_glyphs. */
17875
17876 static void
17877 insert_left_trunc_glyphs (struct it *it)
17878 {
17879 struct it truncate_it;
17880 struct glyph *from, *end, *to, *toend;
17881
17882 xassert (!FRAME_WINDOW_P (it->f));
17883
17884 /* Get the truncation glyphs. */
17885 truncate_it = *it;
17886 truncate_it.current_x = 0;
17887 truncate_it.face_id = DEFAULT_FACE_ID;
17888 truncate_it.glyph_row = &scratch_glyph_row;
17889 truncate_it.glyph_row->used[TEXT_AREA] = 0;
17890 CHARPOS (truncate_it.position) = BYTEPOS (truncate_it.position) = -1;
17891 truncate_it.object = make_number (0);
17892 produce_special_glyphs (&truncate_it, IT_TRUNCATION);
17893
17894 /* Overwrite glyphs from IT with truncation glyphs. */
17895 if (!it->glyph_row->reversed_p)
17896 {
17897 from = truncate_it.glyph_row->glyphs[TEXT_AREA];
17898 end = from + truncate_it.glyph_row->used[TEXT_AREA];
17899 to = it->glyph_row->glyphs[TEXT_AREA];
17900 toend = to + it->glyph_row->used[TEXT_AREA];
17901
17902 while (from < end)
17903 *to++ = *from++;
17904
17905 /* There may be padding glyphs left over. Overwrite them too. */
17906 while (to < toend && CHAR_GLYPH_PADDING_P (*to))
17907 {
17908 from = truncate_it.glyph_row->glyphs[TEXT_AREA];
17909 while (from < end)
17910 *to++ = *from++;
17911 }
17912
17913 if (to > toend)
17914 it->glyph_row->used[TEXT_AREA] = to - it->glyph_row->glyphs[TEXT_AREA];
17915 }
17916 else
17917 {
17918 /* In R2L rows, overwrite the last (rightmost) glyphs, and do
17919 that back to front. */
17920 end = truncate_it.glyph_row->glyphs[TEXT_AREA];
17921 from = end + truncate_it.glyph_row->used[TEXT_AREA] - 1;
17922 toend = it->glyph_row->glyphs[TEXT_AREA];
17923 to = toend + it->glyph_row->used[TEXT_AREA] - 1;
17924
17925 while (from >= end && to >= toend)
17926 *to-- = *from--;
17927 while (to >= toend && CHAR_GLYPH_PADDING_P (*to))
17928 {
17929 from =
17930 truncate_it.glyph_row->glyphs[TEXT_AREA]
17931 + truncate_it.glyph_row->used[TEXT_AREA] - 1;
17932 while (from >= end && to >= toend)
17933 *to-- = *from--;
17934 }
17935 if (from >= end)
17936 {
17937 /* Need to free some room before prepending additional
17938 glyphs. */
17939 int move_by = from - end + 1;
17940 struct glyph *g0 = it->glyph_row->glyphs[TEXT_AREA];
17941 struct glyph *g = g0 + it->glyph_row->used[TEXT_AREA] - 1;
17942
17943 for ( ; g >= g0; g--)
17944 g[move_by] = *g;
17945 while (from >= end)
17946 *to-- = *from--;
17947 it->glyph_row->used[TEXT_AREA] += move_by;
17948 }
17949 }
17950 }
17951
17952
17953 /* Compute the pixel height and width of IT->glyph_row.
17954
17955 Most of the time, ascent and height of a display line will be equal
17956 to the max_ascent and max_height values of the display iterator
17957 structure. This is not the case if
17958
17959 1. We hit ZV without displaying anything. In this case, max_ascent
17960 and max_height will be zero.
17961
17962 2. We have some glyphs that don't contribute to the line height.
17963 (The glyph row flag contributes_to_line_height_p is for future
17964 pixmap extensions).
17965
17966 The first case is easily covered by using default values because in
17967 these cases, the line height does not really matter, except that it
17968 must not be zero. */
17969
17970 static void
17971 compute_line_metrics (struct it *it)
17972 {
17973 struct glyph_row *row = it->glyph_row;
17974
17975 if (FRAME_WINDOW_P (it->f))
17976 {
17977 int i, min_y, max_y;
17978
17979 /* The line may consist of one space only, that was added to
17980 place the cursor on it. If so, the row's height hasn't been
17981 computed yet. */
17982 if (row->height == 0)
17983 {
17984 if (it->max_ascent + it->max_descent == 0)
17985 it->max_descent = it->max_phys_descent = FRAME_LINE_HEIGHT (it->f);
17986 row->ascent = it->max_ascent;
17987 row->height = it->max_ascent + it->max_descent;
17988 row->phys_ascent = it->max_phys_ascent;
17989 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
17990 row->extra_line_spacing = it->max_extra_line_spacing;
17991 }
17992
17993 /* Compute the width of this line. */
17994 row->pixel_width = row->x;
17995 for (i = 0; i < row->used[TEXT_AREA]; ++i)
17996 row->pixel_width += row->glyphs[TEXT_AREA][i].pixel_width;
17997
17998 xassert (row->pixel_width >= 0);
17999 xassert (row->ascent >= 0 && row->height > 0);
18000
18001 row->overlapping_p = (MATRIX_ROW_OVERLAPS_SUCC_P (row)
18002 || MATRIX_ROW_OVERLAPS_PRED_P (row));
18003
18004 /* If first line's physical ascent is larger than its logical
18005 ascent, use the physical ascent, and make the row taller.
18006 This makes accented characters fully visible. */
18007 if (row == MATRIX_FIRST_TEXT_ROW (it->w->desired_matrix)
18008 && row->phys_ascent > row->ascent)
18009 {
18010 row->height += row->phys_ascent - row->ascent;
18011 row->ascent = row->phys_ascent;
18012 }
18013
18014 /* Compute how much of the line is visible. */
18015 row->visible_height = row->height;
18016
18017 min_y = WINDOW_HEADER_LINE_HEIGHT (it->w);
18018 max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);
18019
18020 if (row->y < min_y)
18021 row->visible_height -= min_y - row->y;
18022 if (row->y + row->height > max_y)
18023 row->visible_height -= row->y + row->height - max_y;
18024 }
18025 else
18026 {
18027 row->pixel_width = row->used[TEXT_AREA];
18028 if (row->continued_p)
18029 row->pixel_width -= it->continuation_pixel_width;
18030 else if (row->truncated_on_right_p)
18031 row->pixel_width -= it->truncation_pixel_width;
18032 row->ascent = row->phys_ascent = 0;
18033 row->height = row->phys_height = row->visible_height = 1;
18034 row->extra_line_spacing = 0;
18035 }
18036
18037 /* Compute a hash code for this row. */
18038 {
18039 int area, i;
18040 row->hash = 0;
18041 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
18042 for (i = 0; i < row->used[area]; ++i)
18043 row->hash = ((((row->hash << 4) + (row->hash >> 24)) & 0x0fffffff)
18044 + row->glyphs[area][i].u.val
18045 + row->glyphs[area][i].face_id
18046 + row->glyphs[area][i].padding_p
18047 + (row->glyphs[area][i].type << 2));
18048 }
18049
18050 it->max_ascent = it->max_descent = 0;
18051 it->max_phys_ascent = it->max_phys_descent = 0;
18052 }
18053
18054
18055 /* Append one space to the glyph row of iterator IT if doing a
18056 window-based redisplay. The space has the same face as
18057 IT->face_id. Value is non-zero if a space was added.
18058
18059 This function is called to make sure that there is always one glyph
18060 at the end of a glyph row that the cursor can be set on under
18061 window-systems. (If there weren't such a glyph we would not know
18062 how wide and tall a box cursor should be displayed).
18063
18064 At the same time this space let's a nicely handle clearing to the
18065 end of the line if the row ends in italic text. */
18066
18067 static int
18068 append_space_for_newline (struct it *it, int default_face_p)
18069 {
18070 if (FRAME_WINDOW_P (it->f))
18071 {
18072 int n = it->glyph_row->used[TEXT_AREA];
18073
18074 if (it->glyph_row->glyphs[TEXT_AREA] + n
18075 < it->glyph_row->glyphs[1 + TEXT_AREA])
18076 {
18077 /* Save some values that must not be changed.
18078 Must save IT->c and IT->len because otherwise
18079 ITERATOR_AT_END_P wouldn't work anymore after
18080 append_space_for_newline has been called. */
18081 enum display_element_type saved_what = it->what;
18082 int saved_c = it->c, saved_len = it->len;
18083 int saved_char_to_display = it->char_to_display;
18084 int saved_x = it->current_x;
18085 int saved_face_id = it->face_id;
18086 struct text_pos saved_pos;
18087 Lisp_Object saved_object;
18088 struct face *face;
18089
18090 saved_object = it->object;
18091 saved_pos = it->position;
18092
18093 it->what = IT_CHARACTER;
18094 memset (&it->position, 0, sizeof it->position);
18095 it->object = make_number (0);
18096 it->c = it->char_to_display = ' ';
18097 it->len = 1;
18098
18099 if (default_face_p)
18100 it->face_id = DEFAULT_FACE_ID;
18101 else if (it->face_before_selective_p)
18102 it->face_id = it->saved_face_id;
18103 face = FACE_FROM_ID (it->f, it->face_id);
18104 it->face_id = FACE_FOR_CHAR (it->f, face, 0, -1, Qnil);
18105
18106 PRODUCE_GLYPHS (it);
18107
18108 it->override_ascent = -1;
18109 it->constrain_row_ascent_descent_p = 0;
18110 it->current_x = saved_x;
18111 it->object = saved_object;
18112 it->position = saved_pos;
18113 it->what = saved_what;
18114 it->face_id = saved_face_id;
18115 it->len = saved_len;
18116 it->c = saved_c;
18117 it->char_to_display = saved_char_to_display;
18118 return 1;
18119 }
18120 }
18121
18122 return 0;
18123 }
18124
18125
18126 /* Extend the face of the last glyph in the text area of IT->glyph_row
18127 to the end of the display line. Called from display_line. If the
18128 glyph row is empty, add a space glyph to it so that we know the
18129 face to draw. Set the glyph row flag fill_line_p. If the glyph
18130 row is R2L, prepend a stretch glyph to cover the empty space to the
18131 left of the leftmost glyph. */
18132
18133 static void
18134 extend_face_to_end_of_line (struct it *it)
18135 {
18136 struct face *face;
18137 struct frame *f = it->f;
18138
18139 /* If line is already filled, do nothing. Non window-system frames
18140 get a grace of one more ``pixel'' because their characters are
18141 1-``pixel'' wide, so they hit the equality too early. This grace
18142 is needed only for R2L rows that are not continued, to produce
18143 one extra blank where we could display the cursor. */
18144 if (it->current_x >= it->last_visible_x
18145 + (!FRAME_WINDOW_P (f)
18146 && it->glyph_row->reversed_p
18147 && !it->glyph_row->continued_p))
18148 return;
18149
18150 /* Face extension extends the background and box of IT->face_id
18151 to the end of the line. If the background equals the background
18152 of the frame, we don't have to do anything. */
18153 if (it->face_before_selective_p)
18154 face = FACE_FROM_ID (f, it->saved_face_id);
18155 else
18156 face = FACE_FROM_ID (f, it->face_id);
18157
18158 if (FRAME_WINDOW_P (f)
18159 && it->glyph_row->displays_text_p
18160 && face->box == FACE_NO_BOX
18161 && face->background == FRAME_BACKGROUND_PIXEL (f)
18162 && !face->stipple
18163 && !it->glyph_row->reversed_p)
18164 return;
18165
18166 /* Set the glyph row flag indicating that the face of the last glyph
18167 in the text area has to be drawn to the end of the text area. */
18168 it->glyph_row->fill_line_p = 1;
18169
18170 /* If current character of IT is not ASCII, make sure we have the
18171 ASCII face. This will be automatically undone the next time
18172 get_next_display_element returns a multibyte character. Note
18173 that the character will always be single byte in unibyte
18174 text. */
18175 if (!ASCII_CHAR_P (it->c))
18176 {
18177 it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
18178 }
18179
18180 if (FRAME_WINDOW_P (f))
18181 {
18182 /* If the row is empty, add a space with the current face of IT,
18183 so that we know which face to draw. */
18184 if (it->glyph_row->used[TEXT_AREA] == 0)
18185 {
18186 it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
18187 it->glyph_row->glyphs[TEXT_AREA][0].face_id = it->face_id;
18188 it->glyph_row->used[TEXT_AREA] = 1;
18189 }
18190 #ifdef HAVE_WINDOW_SYSTEM
18191 if (it->glyph_row->reversed_p)
18192 {
18193 /* Prepend a stretch glyph to the row, such that the
18194 rightmost glyph will be drawn flushed all the way to the
18195 right margin of the window. The stretch glyph that will
18196 occupy the empty space, if any, to the left of the
18197 glyphs. */
18198 struct font *font = face->font ? face->font : FRAME_FONT (f);
18199 struct glyph *row_start = it->glyph_row->glyphs[TEXT_AREA];
18200 struct glyph *row_end = row_start + it->glyph_row->used[TEXT_AREA];
18201 struct glyph *g;
18202 int row_width, stretch_ascent, stretch_width;
18203 struct text_pos saved_pos;
18204 int saved_face_id, saved_avoid_cursor;
18205
18206 for (row_width = 0, g = row_start; g < row_end; g++)
18207 row_width += g->pixel_width;
18208 stretch_width = window_box_width (it->w, TEXT_AREA) - row_width;
18209 if (stretch_width > 0)
18210 {
18211 stretch_ascent =
18212 (((it->ascent + it->descent)
18213 * FONT_BASE (font)) / FONT_HEIGHT (font));
18214 saved_pos = it->position;
18215 memset (&it->position, 0, sizeof it->position);
18216 saved_avoid_cursor = it->avoid_cursor_p;
18217 it->avoid_cursor_p = 1;
18218 saved_face_id = it->face_id;
18219 /* The last row's stretch glyph should get the default
18220 face, to avoid painting the rest of the window with
18221 the region face, if the region ends at ZV. */
18222 if (it->glyph_row->ends_at_zv_p)
18223 it->face_id = DEFAULT_FACE_ID;
18224 else
18225 it->face_id = face->id;
18226 append_stretch_glyph (it, make_number (0), stretch_width,
18227 it->ascent + it->descent, stretch_ascent);
18228 it->position = saved_pos;
18229 it->avoid_cursor_p = saved_avoid_cursor;
18230 it->face_id = saved_face_id;
18231 }
18232 }
18233 #endif /* HAVE_WINDOW_SYSTEM */
18234 }
18235 else
18236 {
18237 /* Save some values that must not be changed. */
18238 int saved_x = it->current_x;
18239 struct text_pos saved_pos;
18240 Lisp_Object saved_object;
18241 enum display_element_type saved_what = it->what;
18242 int saved_face_id = it->face_id;
18243
18244 saved_object = it->object;
18245 saved_pos = it->position;
18246
18247 it->what = IT_CHARACTER;
18248 memset (&it->position, 0, sizeof it->position);
18249 it->object = make_number (0);
18250 it->c = it->char_to_display = ' ';
18251 it->len = 1;
18252 /* The last row's blank glyphs should get the default face, to
18253 avoid painting the rest of the window with the region face,
18254 if the region ends at ZV. */
18255 if (it->glyph_row->ends_at_zv_p)
18256 it->face_id = DEFAULT_FACE_ID;
18257 else
18258 it->face_id = face->id;
18259
18260 PRODUCE_GLYPHS (it);
18261
18262 while (it->current_x <= it->last_visible_x)
18263 PRODUCE_GLYPHS (it);
18264
18265 /* Don't count these blanks really. It would let us insert a left
18266 truncation glyph below and make us set the cursor on them, maybe. */
18267 it->current_x = saved_x;
18268 it->object = saved_object;
18269 it->position = saved_pos;
18270 it->what = saved_what;
18271 it->face_id = saved_face_id;
18272 }
18273 }
18274
18275
18276 /* Value is non-zero if text starting at CHARPOS in current_buffer is
18277 trailing whitespace. */
18278
18279 static int
18280 trailing_whitespace_p (ptrdiff_t charpos)
18281 {
18282 ptrdiff_t bytepos = CHAR_TO_BYTE (charpos);
18283 int c = 0;
18284
18285 while (bytepos < ZV_BYTE
18286 && (c = FETCH_CHAR (bytepos),
18287 c == ' ' || c == '\t'))
18288 ++bytepos;
18289
18290 if (bytepos >= ZV_BYTE || c == '\n' || c == '\r')
18291 {
18292 if (bytepos != PT_BYTE)
18293 return 1;
18294 }
18295 return 0;
18296 }
18297
18298
18299 /* Highlight trailing whitespace, if any, in ROW. */
18300
18301 static void
18302 highlight_trailing_whitespace (struct frame *f, struct glyph_row *row)
18303 {
18304 int used = row->used[TEXT_AREA];
18305
18306 if (used)
18307 {
18308 struct glyph *start = row->glyphs[TEXT_AREA];
18309 struct glyph *glyph = start + used - 1;
18310
18311 if (row->reversed_p)
18312 {
18313 /* Right-to-left rows need to be processed in the opposite
18314 direction, so swap the edge pointers. */
18315 glyph = start;
18316 start = row->glyphs[TEXT_AREA] + used - 1;
18317 }
18318
18319 /* Skip over glyphs inserted to display the cursor at the
18320 end of a line, for extending the face of the last glyph
18321 to the end of the line on terminals, and for truncation
18322 and continuation glyphs. */
18323 if (!row->reversed_p)
18324 {
18325 while (glyph >= start
18326 && glyph->type == CHAR_GLYPH
18327 && INTEGERP (glyph->object))
18328 --glyph;
18329 }
18330 else
18331 {
18332 while (glyph <= start
18333 && glyph->type == CHAR_GLYPH
18334 && INTEGERP (glyph->object))
18335 ++glyph;
18336 }
18337
18338 /* If last glyph is a space or stretch, and it's trailing
18339 whitespace, set the face of all trailing whitespace glyphs in
18340 IT->glyph_row to `trailing-whitespace'. */
18341 if ((row->reversed_p ? glyph <= start : glyph >= start)
18342 && BUFFERP (glyph->object)
18343 && (glyph->type == STRETCH_GLYPH
18344 || (glyph->type == CHAR_GLYPH
18345 && glyph->u.ch == ' '))
18346 && trailing_whitespace_p (glyph->charpos))
18347 {
18348 int face_id = lookup_named_face (f, Qtrailing_whitespace, 0);
18349 if (face_id < 0)
18350 return;
18351
18352 if (!row->reversed_p)
18353 {
18354 while (glyph >= start
18355 && BUFFERP (glyph->object)
18356 && (glyph->type == STRETCH_GLYPH
18357 || (glyph->type == CHAR_GLYPH
18358 && glyph->u.ch == ' ')))
18359 (glyph--)->face_id = face_id;
18360 }
18361 else
18362 {
18363 while (glyph <= start
18364 && BUFFERP (glyph->object)
18365 && (glyph->type == STRETCH_GLYPH
18366 || (glyph->type == CHAR_GLYPH
18367 && glyph->u.ch == ' ')))
18368 (glyph++)->face_id = face_id;
18369 }
18370 }
18371 }
18372 }
18373
18374
18375 /* Value is non-zero if glyph row ROW should be
18376 used to hold the cursor. */
18377
18378 static int
18379 cursor_row_p (struct glyph_row *row)
18380 {
18381 int result = 1;
18382
18383 if (PT == CHARPOS (row->end.pos)
18384 || PT == MATRIX_ROW_END_CHARPOS (row))
18385 {
18386 /* Suppose the row ends on a string.
18387 Unless the row is continued, that means it ends on a newline
18388 in the string. If it's anything other than a display string
18389 (e.g. a before-string from an overlay), we don't want the
18390 cursor there. (This heuristic seems to give the optimal
18391 behavior for the various types of multi-line strings.) */
18392 if (CHARPOS (row->end.string_pos) >= 0)
18393 {
18394 if (row->continued_p)
18395 result = 1;
18396 else
18397 {
18398 /* Check for `display' property. */
18399 struct glyph *beg = row->glyphs[TEXT_AREA];
18400 struct glyph *end = beg + row->used[TEXT_AREA] - 1;
18401 struct glyph *glyph;
18402
18403 result = 0;
18404 for (glyph = end; glyph >= beg; --glyph)
18405 if (STRINGP (glyph->object))
18406 {
18407 Lisp_Object prop
18408 = Fget_char_property (make_number (PT),
18409 Qdisplay, Qnil);
18410 result =
18411 (!NILP (prop)
18412 && display_prop_string_p (prop, glyph->object));
18413 break;
18414 }
18415 }
18416 }
18417 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
18418 {
18419 /* If the row ends in middle of a real character,
18420 and the line is continued, we want the cursor here.
18421 That's because CHARPOS (ROW->end.pos) would equal
18422 PT if PT is before the character. */
18423 if (!row->ends_in_ellipsis_p)
18424 result = row->continued_p;
18425 else
18426 /* If the row ends in an ellipsis, then
18427 CHARPOS (ROW->end.pos) will equal point after the
18428 invisible text. We want that position to be displayed
18429 after the ellipsis. */
18430 result = 0;
18431 }
18432 /* If the row ends at ZV, display the cursor at the end of that
18433 row instead of at the start of the row below. */
18434 else if (row->ends_at_zv_p)
18435 result = 1;
18436 else
18437 result = 0;
18438 }
18439
18440 return result;
18441 }
18442
18443 \f
18444
18445 /* Push the property PROP so that it will be rendered at the current
18446 position in IT. Return 1 if PROP was successfully pushed, 0
18447 otherwise. Called from handle_line_prefix to handle the
18448 `line-prefix' and `wrap-prefix' properties. */
18449
18450 static int
18451 push_display_prop (struct it *it, Lisp_Object prop)
18452 {
18453 struct text_pos pos =
18454 STRINGP (it->string) ? it->current.string_pos : it->current.pos;
18455
18456 xassert (it->method == GET_FROM_BUFFER
18457 || it->method == GET_FROM_DISPLAY_VECTOR
18458 || it->method == GET_FROM_STRING);
18459
18460 /* We need to save the current buffer/string position, so it will be
18461 restored by pop_it, because iterate_out_of_display_property
18462 depends on that being set correctly, but some situations leave
18463 it->position not yet set when this function is called. */
18464 push_it (it, &pos);
18465
18466 if (STRINGP (prop))
18467 {
18468 if (SCHARS (prop) == 0)
18469 {
18470 pop_it (it);
18471 return 0;
18472 }
18473
18474 it->string = prop;
18475 it->multibyte_p = STRING_MULTIBYTE (it->string);
18476 it->current.overlay_string_index = -1;
18477 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
18478 it->end_charpos = it->string_nchars = SCHARS (it->string);
18479 it->method = GET_FROM_STRING;
18480 it->stop_charpos = 0;
18481 it->prev_stop = 0;
18482 it->base_level_stop = 0;
18483
18484 /* Force paragraph direction to be that of the parent
18485 buffer/string. */
18486 if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
18487 it->paragraph_embedding = it->bidi_it.paragraph_dir;
18488 else
18489 it->paragraph_embedding = L2R;
18490
18491 /* Set up the bidi iterator for this display string. */
18492 if (it->bidi_p)
18493 {
18494 it->bidi_it.string.lstring = it->string;
18495 it->bidi_it.string.s = NULL;
18496 it->bidi_it.string.schars = it->end_charpos;
18497 it->bidi_it.string.bufpos = IT_CHARPOS (*it);
18498 it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
18499 it->bidi_it.string.unibyte = !it->multibyte_p;
18500 bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
18501 }
18502 }
18503 else if (CONSP (prop) && EQ (XCAR (prop), Qspace))
18504 {
18505 it->method = GET_FROM_STRETCH;
18506 it->object = prop;
18507 }
18508 #ifdef HAVE_WINDOW_SYSTEM
18509 else if (IMAGEP (prop))
18510 {
18511 it->what = IT_IMAGE;
18512 it->image_id = lookup_image (it->f, prop);
18513 it->method = GET_FROM_IMAGE;
18514 }
18515 #endif /* HAVE_WINDOW_SYSTEM */
18516 else
18517 {
18518 pop_it (it); /* bogus display property, give up */
18519 return 0;
18520 }
18521
18522 return 1;
18523 }
18524
18525 /* Return the character-property PROP at the current position in IT. */
18526
18527 static Lisp_Object
18528 get_it_property (struct it *it, Lisp_Object prop)
18529 {
18530 Lisp_Object position;
18531
18532 if (STRINGP (it->object))
18533 position = make_number (IT_STRING_CHARPOS (*it));
18534 else if (BUFFERP (it->object))
18535 position = make_number (IT_CHARPOS (*it));
18536 else
18537 return Qnil;
18538
18539 return Fget_char_property (position, prop, it->object);
18540 }
18541
18542 /* See if there's a line- or wrap-prefix, and if so, push it on IT. */
18543
18544 static void
18545 handle_line_prefix (struct it *it)
18546 {
18547 Lisp_Object prefix;
18548
18549 if (it->continuation_lines_width > 0)
18550 {
18551 prefix = get_it_property (it, Qwrap_prefix);
18552 if (NILP (prefix))
18553 prefix = Vwrap_prefix;
18554 }
18555 else
18556 {
18557 prefix = get_it_property (it, Qline_prefix);
18558 if (NILP (prefix))
18559 prefix = Vline_prefix;
18560 }
18561 if (! NILP (prefix) && push_display_prop (it, prefix))
18562 {
18563 /* If the prefix is wider than the window, and we try to wrap
18564 it, it would acquire its own wrap prefix, and so on till the
18565 iterator stack overflows. So, don't wrap the prefix. */
18566 it->line_wrap = TRUNCATE;
18567 it->avoid_cursor_p = 1;
18568 }
18569 }
18570
18571 \f
18572
18573 /* Remove N glyphs at the start of a reversed IT->glyph_row. Called
18574 only for R2L lines from display_line and display_string, when they
18575 decide that too many glyphs were produced by PRODUCE_GLYPHS, and
18576 the line/string needs to be continued on the next glyph row. */
18577 static void
18578 unproduce_glyphs (struct it *it, int n)
18579 {
18580 struct glyph *glyph, *end;
18581
18582 xassert (it->glyph_row);
18583 xassert (it->glyph_row->reversed_p);
18584 xassert (it->area == TEXT_AREA);
18585 xassert (n <= it->glyph_row->used[TEXT_AREA]);
18586
18587 if (n > it->glyph_row->used[TEXT_AREA])
18588 n = it->glyph_row->used[TEXT_AREA];
18589 glyph = it->glyph_row->glyphs[TEXT_AREA] + n;
18590 end = it->glyph_row->glyphs[TEXT_AREA] + it->glyph_row->used[TEXT_AREA];
18591 for ( ; glyph < end; glyph++)
18592 glyph[-n] = *glyph;
18593 }
18594
18595 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
18596 and ROW->maxpos. */
18597 static void
18598 find_row_edges (struct it *it, struct glyph_row *row,
18599 ptrdiff_t min_pos, ptrdiff_t min_bpos,
18600 ptrdiff_t max_pos, ptrdiff_t max_bpos)
18601 {
18602 /* FIXME: Revisit this when glyph ``spilling'' in continuation
18603 lines' rows is implemented for bidi-reordered rows. */
18604
18605 /* ROW->minpos is the value of min_pos, the minimal buffer position
18606 we have in ROW, or ROW->start.pos if that is smaller. */
18607 if (min_pos <= ZV && min_pos < row->start.pos.charpos)
18608 SET_TEXT_POS (row->minpos, min_pos, min_bpos);
18609 else
18610 /* We didn't find buffer positions smaller than ROW->start, or
18611 didn't find _any_ valid buffer positions in any of the glyphs,
18612 so we must trust the iterator's computed positions. */
18613 row->minpos = row->start.pos;
18614 if (max_pos <= 0)
18615 {
18616 max_pos = CHARPOS (it->current.pos);
18617 max_bpos = BYTEPOS (it->current.pos);
18618 }
18619
18620 /* Here are the various use-cases for ending the row, and the
18621 corresponding values for ROW->maxpos:
18622
18623 Line ends in a newline from buffer eol_pos + 1
18624 Line is continued from buffer max_pos + 1
18625 Line is truncated on right it->current.pos
18626 Line ends in a newline from string max_pos + 1(*)
18627 (*) + 1 only when line ends in a forward scan
18628 Line is continued from string max_pos
18629 Line is continued from display vector max_pos
18630 Line is entirely from a string min_pos == max_pos
18631 Line is entirely from a display vector min_pos == max_pos
18632 Line that ends at ZV ZV
18633
18634 If you discover other use-cases, please add them here as
18635 appropriate. */
18636 if (row->ends_at_zv_p)
18637 row->maxpos = it->current.pos;
18638 else if (row->used[TEXT_AREA])
18639 {
18640 int seen_this_string = 0;
18641 struct glyph_row *r1 = row - 1;
18642
18643 /* Did we see the same display string on the previous row? */
18644 if (STRINGP (it->object)
18645 /* this is not the first row */
18646 && row > it->w->desired_matrix->rows
18647 /* previous row is not the header line */
18648 && !r1->mode_line_p
18649 /* previous row also ends in a newline from a string */
18650 && r1->ends_in_newline_from_string_p)
18651 {
18652 struct glyph *start, *end;
18653
18654 /* Search for the last glyph of the previous row that came
18655 from buffer or string. Depending on whether the row is
18656 L2R or R2L, we need to process it front to back or the
18657 other way round. */
18658 if (!r1->reversed_p)
18659 {
18660 start = r1->glyphs[TEXT_AREA];
18661 end = start + r1->used[TEXT_AREA];
18662 /* Glyphs inserted by redisplay have an integer (zero)
18663 as their object. */
18664 while (end > start
18665 && INTEGERP ((end - 1)->object)
18666 && (end - 1)->charpos <= 0)
18667 --end;
18668 if (end > start)
18669 {
18670 if (EQ ((end - 1)->object, it->object))
18671 seen_this_string = 1;
18672 }
18673 else
18674 /* If all the glyphs of the previous row were inserted
18675 by redisplay, it means the previous row was
18676 produced from a single newline, which is only
18677 possible if that newline came from the same string
18678 as the one which produced this ROW. */
18679 seen_this_string = 1;
18680 }
18681 else
18682 {
18683 end = r1->glyphs[TEXT_AREA] - 1;
18684 start = end + r1->used[TEXT_AREA];
18685 while (end < start
18686 && INTEGERP ((end + 1)->object)
18687 && (end + 1)->charpos <= 0)
18688 ++end;
18689 if (end < start)
18690 {
18691 if (EQ ((end + 1)->object, it->object))
18692 seen_this_string = 1;
18693 }
18694 else
18695 seen_this_string = 1;
18696 }
18697 }
18698 /* Take note of each display string that covers a newline only
18699 once, the first time we see it. This is for when a display
18700 string includes more than one newline in it. */
18701 if (row->ends_in_newline_from_string_p && !seen_this_string)
18702 {
18703 /* If we were scanning the buffer forward when we displayed
18704 the string, we want to account for at least one buffer
18705 position that belongs to this row (position covered by
18706 the display string), so that cursor positioning will
18707 consider this row as a candidate when point is at the end
18708 of the visual line represented by this row. This is not
18709 required when scanning back, because max_pos will already
18710 have a much larger value. */
18711 if (CHARPOS (row->end.pos) > max_pos)
18712 INC_BOTH (max_pos, max_bpos);
18713 SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
18714 }
18715 else if (CHARPOS (it->eol_pos) > 0)
18716 SET_TEXT_POS (row->maxpos,
18717 CHARPOS (it->eol_pos) + 1, BYTEPOS (it->eol_pos) + 1);
18718 else if (row->continued_p)
18719 {
18720 /* If max_pos is different from IT's current position, it
18721 means IT->method does not belong to the display element
18722 at max_pos. However, it also means that the display
18723 element at max_pos was displayed in its entirety on this
18724 line, which is equivalent to saying that the next line
18725 starts at the next buffer position. */
18726 if (IT_CHARPOS (*it) == max_pos && it->method != GET_FROM_BUFFER)
18727 SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
18728 else
18729 {
18730 INC_BOTH (max_pos, max_bpos);
18731 SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
18732 }
18733 }
18734 else if (row->truncated_on_right_p)
18735 /* display_line already called reseat_at_next_visible_line_start,
18736 which puts the iterator at the beginning of the next line, in
18737 the logical order. */
18738 row->maxpos = it->current.pos;
18739 else if (max_pos == min_pos && it->method != GET_FROM_BUFFER)
18740 /* A line that is entirely from a string/image/stretch... */
18741 row->maxpos = row->minpos;
18742 else
18743 abort ();
18744 }
18745 else
18746 row->maxpos = it->current.pos;
18747 }
18748
18749 /* Construct the glyph row IT->glyph_row in the desired matrix of
18750 IT->w from text at the current position of IT. See dispextern.h
18751 for an overview of struct it. Value is non-zero if
18752 IT->glyph_row displays text, as opposed to a line displaying ZV
18753 only. */
18754
18755 static int
18756 display_line (struct it *it)
18757 {
18758 struct glyph_row *row = it->glyph_row;
18759 Lisp_Object overlay_arrow_string;
18760 struct it wrap_it;
18761 void *wrap_data = NULL;
18762 int may_wrap = 0, wrap_x IF_LINT (= 0);
18763 int wrap_row_used = -1;
18764 int wrap_row_ascent IF_LINT (= 0), wrap_row_height IF_LINT (= 0);
18765 int wrap_row_phys_ascent IF_LINT (= 0), wrap_row_phys_height IF_LINT (= 0);
18766 int wrap_row_extra_line_spacing IF_LINT (= 0);
18767 ptrdiff_t wrap_row_min_pos IF_LINT (= 0), wrap_row_min_bpos IF_LINT (= 0);
18768 ptrdiff_t wrap_row_max_pos IF_LINT (= 0), wrap_row_max_bpos IF_LINT (= 0);
18769 int cvpos;
18770 ptrdiff_t min_pos = ZV + 1, max_pos = 0;
18771 ptrdiff_t min_bpos IF_LINT (= 0), max_bpos IF_LINT (= 0);
18772
18773 /* We always start displaying at hpos zero even if hscrolled. */
18774 xassert (it->hpos == 0 && it->current_x == 0);
18775
18776 if (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
18777 >= it->w->desired_matrix->nrows)
18778 {
18779 it->w->nrows_scale_factor++;
18780 fonts_changed_p = 1;
18781 return 0;
18782 }
18783
18784 /* Is IT->w showing the region? */
18785 it->w->region_showing = it->region_beg_charpos > 0 ? Qt : Qnil;
18786
18787 /* Clear the result glyph row and enable it. */
18788 prepare_desired_row (row);
18789
18790 row->y = it->current_y;
18791 row->start = it->start;
18792 row->continuation_lines_width = it->continuation_lines_width;
18793 row->displays_text_p = 1;
18794 row->starts_in_middle_of_char_p = it->starts_in_middle_of_char_p;
18795 it->starts_in_middle_of_char_p = 0;
18796
18797 /* Arrange the overlays nicely for our purposes. Usually, we call
18798 display_line on only one line at a time, in which case this
18799 can't really hurt too much, or we call it on lines which appear
18800 one after another in the buffer, in which case all calls to
18801 recenter_overlay_lists but the first will be pretty cheap. */
18802 recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
18803
18804 /* Move over display elements that are not visible because we are
18805 hscrolled. This may stop at an x-position < IT->first_visible_x
18806 if the first glyph is partially visible or if we hit a line end. */
18807 if (it->current_x < it->first_visible_x)
18808 {
18809 this_line_min_pos = row->start.pos;
18810 move_it_in_display_line_to (it, ZV, it->first_visible_x,
18811 MOVE_TO_POS | MOVE_TO_X);
18812 /* Record the smallest positions seen while we moved over
18813 display elements that are not visible. This is needed by
18814 redisplay_internal for optimizing the case where the cursor
18815 stays inside the same line. The rest of this function only
18816 considers positions that are actually displayed, so
18817 RECORD_MAX_MIN_POS will not otherwise record positions that
18818 are hscrolled to the left of the left edge of the window. */
18819 min_pos = CHARPOS (this_line_min_pos);
18820 min_bpos = BYTEPOS (this_line_min_pos);
18821 }
18822 else
18823 {
18824 /* We only do this when not calling `move_it_in_display_line_to'
18825 above, because move_it_in_display_line_to calls
18826 handle_line_prefix itself. */
18827 handle_line_prefix (it);
18828 }
18829
18830 /* Get the initial row height. This is either the height of the
18831 text hscrolled, if there is any, or zero. */
18832 row->ascent = it->max_ascent;
18833 row->height = it->max_ascent + it->max_descent;
18834 row->phys_ascent = it->max_phys_ascent;
18835 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
18836 row->extra_line_spacing = it->max_extra_line_spacing;
18837
18838 /* Utility macro to record max and min buffer positions seen until now. */
18839 #define RECORD_MAX_MIN_POS(IT) \
18840 do \
18841 { \
18842 int composition_p = (IT)->what == IT_COMPOSITION; \
18843 ptrdiff_t current_pos = \
18844 composition_p ? (IT)->cmp_it.charpos \
18845 : IT_CHARPOS (*(IT)); \
18846 ptrdiff_t current_bpos = \
18847 composition_p ? CHAR_TO_BYTE (current_pos) \
18848 : IT_BYTEPOS (*(IT)); \
18849 if (current_pos < min_pos) \
18850 { \
18851 min_pos = current_pos; \
18852 min_bpos = current_bpos; \
18853 } \
18854 if (IT_CHARPOS (*it) > max_pos) \
18855 { \
18856 max_pos = IT_CHARPOS (*it); \
18857 max_bpos = IT_BYTEPOS (*it); \
18858 } \
18859 } \
18860 while (0)
18861
18862 /* Loop generating characters. The loop is left with IT on the next
18863 character to display. */
18864 while (1)
18865 {
18866 int n_glyphs_before, hpos_before, x_before;
18867 int x, nglyphs;
18868 int ascent = 0, descent = 0, phys_ascent = 0, phys_descent = 0;
18869
18870 /* Retrieve the next thing to display. Value is zero if end of
18871 buffer reached. */
18872 if (!get_next_display_element (it))
18873 {
18874 /* Maybe add a space at the end of this line that is used to
18875 display the cursor there under X. Set the charpos of the
18876 first glyph of blank lines not corresponding to any text
18877 to -1. */
18878 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
18879 row->exact_window_width_line_p = 1;
18880 else if ((append_space_for_newline (it, 1) && row->used[TEXT_AREA] == 1)
18881 || row->used[TEXT_AREA] == 0)
18882 {
18883 row->glyphs[TEXT_AREA]->charpos = -1;
18884 row->displays_text_p = 0;
18885
18886 if (!NILP (BVAR (XBUFFER (it->w->buffer), indicate_empty_lines))
18887 && (!MINI_WINDOW_P (it->w)
18888 || (minibuf_level && EQ (it->window, minibuf_window))))
18889 row->indicate_empty_line_p = 1;
18890 }
18891
18892 it->continuation_lines_width = 0;
18893 row->ends_at_zv_p = 1;
18894 /* A row that displays right-to-left text must always have
18895 its last face extended all the way to the end of line,
18896 even if this row ends in ZV, because we still write to
18897 the screen left to right. */
18898 if (row->reversed_p)
18899 extend_face_to_end_of_line (it);
18900 break;
18901 }
18902
18903 /* Now, get the metrics of what we want to display. This also
18904 generates glyphs in `row' (which is IT->glyph_row). */
18905 n_glyphs_before = row->used[TEXT_AREA];
18906 x = it->current_x;
18907
18908 /* Remember the line height so far in case the next element doesn't
18909 fit on the line. */
18910 if (it->line_wrap != TRUNCATE)
18911 {
18912 ascent = it->max_ascent;
18913 descent = it->max_descent;
18914 phys_ascent = it->max_phys_ascent;
18915 phys_descent = it->max_phys_descent;
18916
18917 if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
18918 {
18919 if (IT_DISPLAYING_WHITESPACE (it))
18920 may_wrap = 1;
18921 else if (may_wrap)
18922 {
18923 SAVE_IT (wrap_it, *it, wrap_data);
18924 wrap_x = x;
18925 wrap_row_used = row->used[TEXT_AREA];
18926 wrap_row_ascent = row->ascent;
18927 wrap_row_height = row->height;
18928 wrap_row_phys_ascent = row->phys_ascent;
18929 wrap_row_phys_height = row->phys_height;
18930 wrap_row_extra_line_spacing = row->extra_line_spacing;
18931 wrap_row_min_pos = min_pos;
18932 wrap_row_min_bpos = min_bpos;
18933 wrap_row_max_pos = max_pos;
18934 wrap_row_max_bpos = max_bpos;
18935 may_wrap = 0;
18936 }
18937 }
18938 }
18939
18940 PRODUCE_GLYPHS (it);
18941
18942 /* If this display element was in marginal areas, continue with
18943 the next one. */
18944 if (it->area != TEXT_AREA)
18945 {
18946 row->ascent = max (row->ascent, it->max_ascent);
18947 row->height = max (row->height, it->max_ascent + it->max_descent);
18948 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
18949 row->phys_height = max (row->phys_height,
18950 it->max_phys_ascent + it->max_phys_descent);
18951 row->extra_line_spacing = max (row->extra_line_spacing,
18952 it->max_extra_line_spacing);
18953 set_iterator_to_next (it, 1);
18954 continue;
18955 }
18956
18957 /* Does the display element fit on the line? If we truncate
18958 lines, we should draw past the right edge of the window. If
18959 we don't truncate, we want to stop so that we can display the
18960 continuation glyph before the right margin. If lines are
18961 continued, there are two possible strategies for characters
18962 resulting in more than 1 glyph (e.g. tabs): Display as many
18963 glyphs as possible in this line and leave the rest for the
18964 continuation line, or display the whole element in the next
18965 line. Original redisplay did the former, so we do it also. */
18966 nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
18967 hpos_before = it->hpos;
18968 x_before = x;
18969
18970 if (/* Not a newline. */
18971 nglyphs > 0
18972 /* Glyphs produced fit entirely in the line. */
18973 && it->current_x < it->last_visible_x)
18974 {
18975 it->hpos += nglyphs;
18976 row->ascent = max (row->ascent, it->max_ascent);
18977 row->height = max (row->height, it->max_ascent + it->max_descent);
18978 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
18979 row->phys_height = max (row->phys_height,
18980 it->max_phys_ascent + it->max_phys_descent);
18981 row->extra_line_spacing = max (row->extra_line_spacing,
18982 it->max_extra_line_spacing);
18983 if (it->current_x - it->pixel_width < it->first_visible_x)
18984 row->x = x - it->first_visible_x;
18985 /* Record the maximum and minimum buffer positions seen so
18986 far in glyphs that will be displayed by this row. */
18987 if (it->bidi_p)
18988 RECORD_MAX_MIN_POS (it);
18989 }
18990 else
18991 {
18992 int i, new_x;
18993 struct glyph *glyph;
18994
18995 for (i = 0; i < nglyphs; ++i, x = new_x)
18996 {
18997 glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
18998 new_x = x + glyph->pixel_width;
18999
19000 if (/* Lines are continued. */
19001 it->line_wrap != TRUNCATE
19002 && (/* Glyph doesn't fit on the line. */
19003 new_x > it->last_visible_x
19004 /* Or it fits exactly on a window system frame. */
19005 || (new_x == it->last_visible_x
19006 && FRAME_WINDOW_P (it->f))))
19007 {
19008 /* End of a continued line. */
19009
19010 if (it->hpos == 0
19011 || (new_x == it->last_visible_x
19012 && FRAME_WINDOW_P (it->f)))
19013 {
19014 /* Current glyph is the only one on the line or
19015 fits exactly on the line. We must continue
19016 the line because we can't draw the cursor
19017 after the glyph. */
19018 row->continued_p = 1;
19019 it->current_x = new_x;
19020 it->continuation_lines_width += new_x;
19021 ++it->hpos;
19022 if (i == nglyphs - 1)
19023 {
19024 /* If line-wrap is on, check if a previous
19025 wrap point was found. */
19026 if (wrap_row_used > 0
19027 /* Even if there is a previous wrap
19028 point, continue the line here as
19029 usual, if (i) the previous character
19030 was a space or tab AND (ii) the
19031 current character is not. */
19032 && (!may_wrap
19033 || IT_DISPLAYING_WHITESPACE (it)))
19034 goto back_to_wrap;
19035
19036 /* Record the maximum and minimum buffer
19037 positions seen so far in glyphs that will be
19038 displayed by this row. */
19039 if (it->bidi_p)
19040 RECORD_MAX_MIN_POS (it);
19041 set_iterator_to_next (it, 1);
19042 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
19043 {
19044 if (!get_next_display_element (it))
19045 {
19046 row->exact_window_width_line_p = 1;
19047 it->continuation_lines_width = 0;
19048 row->continued_p = 0;
19049 row->ends_at_zv_p = 1;
19050 }
19051 else if (ITERATOR_AT_END_OF_LINE_P (it))
19052 {
19053 row->continued_p = 0;
19054 row->exact_window_width_line_p = 1;
19055 }
19056 }
19057 }
19058 else if (it->bidi_p)
19059 RECORD_MAX_MIN_POS (it);
19060 }
19061 else if (CHAR_GLYPH_PADDING_P (*glyph)
19062 && !FRAME_WINDOW_P (it->f))
19063 {
19064 /* A padding glyph that doesn't fit on this line.
19065 This means the whole character doesn't fit
19066 on the line. */
19067 if (row->reversed_p)
19068 unproduce_glyphs (it, row->used[TEXT_AREA]
19069 - n_glyphs_before);
19070 row->used[TEXT_AREA] = n_glyphs_before;
19071
19072 /* Fill the rest of the row with continuation
19073 glyphs like in 20.x. */
19074 while (row->glyphs[TEXT_AREA] + row->used[TEXT_AREA]
19075 < row->glyphs[1 + TEXT_AREA])
19076 produce_special_glyphs (it, IT_CONTINUATION);
19077
19078 row->continued_p = 1;
19079 it->current_x = x_before;
19080 it->continuation_lines_width += x_before;
19081
19082 /* Restore the height to what it was before the
19083 element not fitting on the line. */
19084 it->max_ascent = ascent;
19085 it->max_descent = descent;
19086 it->max_phys_ascent = phys_ascent;
19087 it->max_phys_descent = phys_descent;
19088 }
19089 else if (wrap_row_used > 0)
19090 {
19091 back_to_wrap:
19092 if (row->reversed_p)
19093 unproduce_glyphs (it,
19094 row->used[TEXT_AREA] - wrap_row_used);
19095 RESTORE_IT (it, &wrap_it, wrap_data);
19096 it->continuation_lines_width += wrap_x;
19097 row->used[TEXT_AREA] = wrap_row_used;
19098 row->ascent = wrap_row_ascent;
19099 row->height = wrap_row_height;
19100 row->phys_ascent = wrap_row_phys_ascent;
19101 row->phys_height = wrap_row_phys_height;
19102 row->extra_line_spacing = wrap_row_extra_line_spacing;
19103 min_pos = wrap_row_min_pos;
19104 min_bpos = wrap_row_min_bpos;
19105 max_pos = wrap_row_max_pos;
19106 max_bpos = wrap_row_max_bpos;
19107 row->continued_p = 1;
19108 row->ends_at_zv_p = 0;
19109 row->exact_window_width_line_p = 0;
19110 it->continuation_lines_width += x;
19111
19112 /* Make sure that a non-default face is extended
19113 up to the right margin of the window. */
19114 extend_face_to_end_of_line (it);
19115 }
19116 else if (it->c == '\t' && FRAME_WINDOW_P (it->f))
19117 {
19118 /* A TAB that extends past the right edge of the
19119 window. This produces a single glyph on
19120 window system frames. We leave the glyph in
19121 this row and let it fill the row, but don't
19122 consume the TAB. */
19123 it->continuation_lines_width += it->last_visible_x;
19124 row->ends_in_middle_of_char_p = 1;
19125 row->continued_p = 1;
19126 glyph->pixel_width = it->last_visible_x - x;
19127 it->starts_in_middle_of_char_p = 1;
19128 }
19129 else
19130 {
19131 /* Something other than a TAB that draws past
19132 the right edge of the window. Restore
19133 positions to values before the element. */
19134 if (row->reversed_p)
19135 unproduce_glyphs (it, row->used[TEXT_AREA]
19136 - (n_glyphs_before + i));
19137 row->used[TEXT_AREA] = n_glyphs_before + i;
19138
19139 /* Display continuation glyphs. */
19140 if (!FRAME_WINDOW_P (it->f))
19141 produce_special_glyphs (it, IT_CONTINUATION);
19142 row->continued_p = 1;
19143
19144 it->current_x = x_before;
19145 it->continuation_lines_width += x;
19146 extend_face_to_end_of_line (it);
19147
19148 if (nglyphs > 1 && i > 0)
19149 {
19150 row->ends_in_middle_of_char_p = 1;
19151 it->starts_in_middle_of_char_p = 1;
19152 }
19153
19154 /* Restore the height to what it was before the
19155 element not fitting on the line. */
19156 it->max_ascent = ascent;
19157 it->max_descent = descent;
19158 it->max_phys_ascent = phys_ascent;
19159 it->max_phys_descent = phys_descent;
19160 }
19161
19162 break;
19163 }
19164 else if (new_x > it->first_visible_x)
19165 {
19166 /* Increment number of glyphs actually displayed. */
19167 ++it->hpos;
19168
19169 /* Record the maximum and minimum buffer positions
19170 seen so far in glyphs that will be displayed by
19171 this row. */
19172 if (it->bidi_p)
19173 RECORD_MAX_MIN_POS (it);
19174
19175 if (x < it->first_visible_x)
19176 /* Glyph is partially visible, i.e. row starts at
19177 negative X position. */
19178 row->x = x - it->first_visible_x;
19179 }
19180 else
19181 {
19182 /* Glyph is completely off the left margin of the
19183 window. This should not happen because of the
19184 move_it_in_display_line at the start of this
19185 function, unless the text display area of the
19186 window is empty. */
19187 xassert (it->first_visible_x <= it->last_visible_x);
19188 }
19189 }
19190 /* Even if this display element produced no glyphs at all,
19191 we want to record its position. */
19192 if (it->bidi_p && nglyphs == 0)
19193 RECORD_MAX_MIN_POS (it);
19194
19195 row->ascent = max (row->ascent, it->max_ascent);
19196 row->height = max (row->height, it->max_ascent + it->max_descent);
19197 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
19198 row->phys_height = max (row->phys_height,
19199 it->max_phys_ascent + it->max_phys_descent);
19200 row->extra_line_spacing = max (row->extra_line_spacing,
19201 it->max_extra_line_spacing);
19202
19203 /* End of this display line if row is continued. */
19204 if (row->continued_p || row->ends_at_zv_p)
19205 break;
19206 }
19207
19208 at_end_of_line:
19209 /* Is this a line end? If yes, we're also done, after making
19210 sure that a non-default face is extended up to the right
19211 margin of the window. */
19212 if (ITERATOR_AT_END_OF_LINE_P (it))
19213 {
19214 int used_before = row->used[TEXT_AREA];
19215
19216 row->ends_in_newline_from_string_p = STRINGP (it->object);
19217
19218 /* Add a space at the end of the line that is used to
19219 display the cursor there. */
19220 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
19221 append_space_for_newline (it, 0);
19222
19223 /* Extend the face to the end of the line. */
19224 extend_face_to_end_of_line (it);
19225
19226 /* Make sure we have the position. */
19227 if (used_before == 0)
19228 row->glyphs[TEXT_AREA]->charpos = CHARPOS (it->position);
19229
19230 /* Record the position of the newline, for use in
19231 find_row_edges. */
19232 it->eol_pos = it->current.pos;
19233
19234 /* Consume the line end. This skips over invisible lines. */
19235 set_iterator_to_next (it, 1);
19236 it->continuation_lines_width = 0;
19237 break;
19238 }
19239
19240 /* Proceed with next display element. Note that this skips
19241 over lines invisible because of selective display. */
19242 set_iterator_to_next (it, 1);
19243
19244 /* If we truncate lines, we are done when the last displayed
19245 glyphs reach past the right margin of the window. */
19246 if (it->line_wrap == TRUNCATE
19247 && (FRAME_WINDOW_P (it->f)
19248 ? (it->current_x >= it->last_visible_x)
19249 : (it->current_x > it->last_visible_x)))
19250 {
19251 /* Maybe add truncation glyphs. */
19252 if (!FRAME_WINDOW_P (it->f))
19253 {
19254 int i, n;
19255
19256 if (!row->reversed_p)
19257 {
19258 for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
19259 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
19260 break;
19261 }
19262 else
19263 {
19264 for (i = 0; i < row->used[TEXT_AREA]; i++)
19265 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
19266 break;
19267 /* Remove any padding glyphs at the front of ROW, to
19268 make room for the truncation glyphs we will be
19269 adding below. The loop below always inserts at
19270 least one truncation glyph, so also remove the
19271 last glyph added to ROW. */
19272 unproduce_glyphs (it, i + 1);
19273 /* Adjust i for the loop below. */
19274 i = row->used[TEXT_AREA] - (i + 1);
19275 }
19276
19277 for (n = row->used[TEXT_AREA]; i < n; ++i)
19278 {
19279 row->used[TEXT_AREA] = i;
19280 produce_special_glyphs (it, IT_TRUNCATION);
19281 }
19282 }
19283 else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
19284 {
19285 /* Don't truncate if we can overflow newline into fringe. */
19286 if (!get_next_display_element (it))
19287 {
19288 it->continuation_lines_width = 0;
19289 row->ends_at_zv_p = 1;
19290 row->exact_window_width_line_p = 1;
19291 break;
19292 }
19293 if (ITERATOR_AT_END_OF_LINE_P (it))
19294 {
19295 row->exact_window_width_line_p = 1;
19296 goto at_end_of_line;
19297 }
19298 }
19299
19300 row->truncated_on_right_p = 1;
19301 it->continuation_lines_width = 0;
19302 reseat_at_next_visible_line_start (it, 0);
19303 row->ends_at_zv_p = FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n';
19304 it->hpos = hpos_before;
19305 it->current_x = x_before;
19306 break;
19307 }
19308 }
19309
19310 if (wrap_data)
19311 bidi_unshelve_cache (wrap_data, 1);
19312
19313 /* If line is not empty and hscrolled, maybe insert truncation glyphs
19314 at the left window margin. */
19315 if (it->first_visible_x
19316 && IT_CHARPOS (*it) != CHARPOS (row->start.pos))
19317 {
19318 if (!FRAME_WINDOW_P (it->f))
19319 insert_left_trunc_glyphs (it);
19320 row->truncated_on_left_p = 1;
19321 }
19322
19323 /* Remember the position at which this line ends.
19324
19325 BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
19326 cannot be before the call to find_row_edges below, since that is
19327 where these positions are determined. */
19328 row->end = it->current;
19329 if (!it->bidi_p)
19330 {
19331 row->minpos = row->start.pos;
19332 row->maxpos = row->end.pos;
19333 }
19334 else
19335 {
19336 /* ROW->minpos and ROW->maxpos must be the smallest and
19337 `1 + the largest' buffer positions in ROW. But if ROW was
19338 bidi-reordered, these two positions can be anywhere in the
19339 row, so we must determine them now. */
19340 find_row_edges (it, row, min_pos, min_bpos, max_pos, max_bpos);
19341 }
19342
19343 /* If the start of this line is the overlay arrow-position, then
19344 mark this glyph row as the one containing the overlay arrow.
19345 This is clearly a mess with variable size fonts. It would be
19346 better to let it be displayed like cursors under X. */
19347 if ((row->displays_text_p || !overlay_arrow_seen)
19348 && (overlay_arrow_string = overlay_arrow_at_row (it, row),
19349 !NILP (overlay_arrow_string)))
19350 {
19351 /* Overlay arrow in window redisplay is a fringe bitmap. */
19352 if (STRINGP (overlay_arrow_string))
19353 {
19354 struct glyph_row *arrow_row
19355 = get_overlay_arrow_glyph_row (it->w, overlay_arrow_string);
19356 struct glyph *glyph = arrow_row->glyphs[TEXT_AREA];
19357 struct glyph *arrow_end = glyph + arrow_row->used[TEXT_AREA];
19358 struct glyph *p = row->glyphs[TEXT_AREA];
19359 struct glyph *p2, *end;
19360
19361 /* Copy the arrow glyphs. */
19362 while (glyph < arrow_end)
19363 *p++ = *glyph++;
19364
19365 /* Throw away padding glyphs. */
19366 p2 = p;
19367 end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
19368 while (p2 < end && CHAR_GLYPH_PADDING_P (*p2))
19369 ++p2;
19370 if (p2 > p)
19371 {
19372 while (p2 < end)
19373 *p++ = *p2++;
19374 row->used[TEXT_AREA] = p2 - row->glyphs[TEXT_AREA];
19375 }
19376 }
19377 else
19378 {
19379 xassert (INTEGERP (overlay_arrow_string));
19380 row->overlay_arrow_bitmap = XINT (overlay_arrow_string);
19381 }
19382 overlay_arrow_seen = 1;
19383 }
19384
19385 /* Compute pixel dimensions of this line. */
19386 compute_line_metrics (it);
19387
19388 /* Record whether this row ends inside an ellipsis. */
19389 row->ends_in_ellipsis_p
19390 = (it->method == GET_FROM_DISPLAY_VECTOR
19391 && it->ellipsis_p);
19392
19393 /* Save fringe bitmaps in this row. */
19394 row->left_user_fringe_bitmap = it->left_user_fringe_bitmap;
19395 row->left_user_fringe_face_id = it->left_user_fringe_face_id;
19396 row->right_user_fringe_bitmap = it->right_user_fringe_bitmap;
19397 row->right_user_fringe_face_id = it->right_user_fringe_face_id;
19398
19399 it->left_user_fringe_bitmap = 0;
19400 it->left_user_fringe_face_id = 0;
19401 it->right_user_fringe_bitmap = 0;
19402 it->right_user_fringe_face_id = 0;
19403
19404 /* Maybe set the cursor. */
19405 cvpos = it->w->cursor.vpos;
19406 if ((cvpos < 0
19407 /* In bidi-reordered rows, keep checking for proper cursor
19408 position even if one has been found already, because buffer
19409 positions in such rows change non-linearly with ROW->VPOS,
19410 when a line is continued. One exception: when we are at ZV,
19411 display cursor on the first suitable glyph row, since all
19412 the empty rows after that also have their position set to ZV. */
19413 /* FIXME: Revisit this when glyph ``spilling'' in continuation
19414 lines' rows is implemented for bidi-reordered rows. */
19415 || (it->bidi_p
19416 && !MATRIX_ROW (it->w->desired_matrix, cvpos)->ends_at_zv_p))
19417 && PT >= MATRIX_ROW_START_CHARPOS (row)
19418 && PT <= MATRIX_ROW_END_CHARPOS (row)
19419 && cursor_row_p (row))
19420 set_cursor_from_row (it->w, row, it->w->desired_matrix, 0, 0, 0, 0);
19421
19422 /* Highlight trailing whitespace. */
19423 if (!NILP (Vshow_trailing_whitespace))
19424 highlight_trailing_whitespace (it->f, it->glyph_row);
19425
19426 /* Prepare for the next line. This line starts horizontally at (X
19427 HPOS) = (0 0). Vertical positions are incremented. As a
19428 convenience for the caller, IT->glyph_row is set to the next
19429 row to be used. */
19430 it->current_x = it->hpos = 0;
19431 it->current_y += row->height;
19432 SET_TEXT_POS (it->eol_pos, 0, 0);
19433 ++it->vpos;
19434 ++it->glyph_row;
19435 /* The next row should by default use the same value of the
19436 reversed_p flag as this one. set_iterator_to_next decides when
19437 it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
19438 the flag accordingly. */
19439 if (it->glyph_row < MATRIX_BOTTOM_TEXT_ROW (it->w->desired_matrix, it->w))
19440 it->glyph_row->reversed_p = row->reversed_p;
19441 it->start = row->end;
19442 return row->displays_text_p;
19443
19444 #undef RECORD_MAX_MIN_POS
19445 }
19446
19447 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction,
19448 Scurrent_bidi_paragraph_direction, 0, 1, 0,
19449 doc: /* Return paragraph direction at point in BUFFER.
19450 Value is either `left-to-right' or `right-to-left'.
19451 If BUFFER is omitted or nil, it defaults to the current buffer.
19452
19453 Paragraph direction determines how the text in the paragraph is displayed.
19454 In left-to-right paragraphs, text begins at the left margin of the window
19455 and the reading direction is generally left to right. In right-to-left
19456 paragraphs, text begins at the right margin and is read from right to left.
19457
19458 See also `bidi-paragraph-direction'. */)
19459 (Lisp_Object buffer)
19460 {
19461 struct buffer *buf = current_buffer;
19462 struct buffer *old = buf;
19463
19464 if (! NILP (buffer))
19465 {
19466 CHECK_BUFFER (buffer);
19467 buf = XBUFFER (buffer);
19468 }
19469
19470 if (NILP (BVAR (buf, bidi_display_reordering))
19471 || NILP (BVAR (buf, enable_multibyte_characters)))
19472 return Qleft_to_right;
19473 else if (!NILP (BVAR (buf, bidi_paragraph_direction)))
19474 return BVAR (buf, bidi_paragraph_direction);
19475 else
19476 {
19477 /* Determine the direction from buffer text. We could try to
19478 use current_matrix if it is up to date, but this seems fast
19479 enough as it is. */
19480 struct bidi_it itb;
19481 ptrdiff_t pos = BUF_PT (buf);
19482 ptrdiff_t bytepos = BUF_PT_BYTE (buf);
19483 int c;
19484 void *itb_data = bidi_shelve_cache ();
19485
19486 set_buffer_temp (buf);
19487 /* bidi_paragraph_init finds the base direction of the paragraph
19488 by searching forward from paragraph start. We need the base
19489 direction of the current or _previous_ paragraph, so we need
19490 to make sure we are within that paragraph. To that end, find
19491 the previous non-empty line. */
19492 if (pos >= ZV && pos > BEGV)
19493 {
19494 pos--;
19495 bytepos = CHAR_TO_BYTE (pos);
19496 }
19497 if (fast_looking_at (build_string ("[\f\t ]*\n"),
19498 pos, bytepos, ZV, ZV_BYTE, Qnil) > 0)
19499 {
19500 while ((c = FETCH_BYTE (bytepos)) == '\n'
19501 || c == ' ' || c == '\t' || c == '\f')
19502 {
19503 if (bytepos <= BEGV_BYTE)
19504 break;
19505 bytepos--;
19506 pos--;
19507 }
19508 while (!CHAR_HEAD_P (FETCH_BYTE (bytepos)))
19509 bytepos--;
19510 }
19511 bidi_init_it (pos, bytepos, FRAME_WINDOW_P (SELECTED_FRAME ()), &itb);
19512 itb.paragraph_dir = NEUTRAL_DIR;
19513 itb.string.s = NULL;
19514 itb.string.lstring = Qnil;
19515 itb.string.bufpos = 0;
19516 itb.string.unibyte = 0;
19517 bidi_paragraph_init (NEUTRAL_DIR, &itb, 1);
19518 bidi_unshelve_cache (itb_data, 0);
19519 set_buffer_temp (old);
19520 switch (itb.paragraph_dir)
19521 {
19522 case L2R:
19523 return Qleft_to_right;
19524 break;
19525 case R2L:
19526 return Qright_to_left;
19527 break;
19528 default:
19529 abort ();
19530 }
19531 }
19532 }
19533
19534
19535 \f
19536 /***********************************************************************
19537 Menu Bar
19538 ***********************************************************************/
19539
19540 /* Redisplay the menu bar in the frame for window W.
19541
19542 The menu bar of X frames that don't have X toolkit support is
19543 displayed in a special window W->frame->menu_bar_window.
19544
19545 The menu bar of terminal frames is treated specially as far as
19546 glyph matrices are concerned. Menu bar lines are not part of
19547 windows, so the update is done directly on the frame matrix rows
19548 for the menu bar. */
19549
19550 static void
19551 display_menu_bar (struct window *w)
19552 {
19553 struct frame *f = XFRAME (WINDOW_FRAME (w));
19554 struct it it;
19555 Lisp_Object items;
19556 int i;
19557
19558 /* Don't do all this for graphical frames. */
19559 #ifdef HAVE_NTGUI
19560 if (FRAME_W32_P (f))
19561 return;
19562 #endif
19563 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
19564 if (FRAME_X_P (f))
19565 return;
19566 #endif
19567
19568 #ifdef HAVE_NS
19569 if (FRAME_NS_P (f))
19570 return;
19571 #endif /* HAVE_NS */
19572
19573 #ifdef USE_X_TOOLKIT
19574 xassert (!FRAME_WINDOW_P (f));
19575 init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
19576 it.first_visible_x = 0;
19577 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
19578 #else /* not USE_X_TOOLKIT */
19579 if (FRAME_WINDOW_P (f))
19580 {
19581 /* Menu bar lines are displayed in the desired matrix of the
19582 dummy window menu_bar_window. */
19583 struct window *menu_w;
19584 xassert (WINDOWP (f->menu_bar_window));
19585 menu_w = XWINDOW (f->menu_bar_window);
19586 init_iterator (&it, menu_w, -1, -1, menu_w->desired_matrix->rows,
19587 MENU_FACE_ID);
19588 it.first_visible_x = 0;
19589 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
19590 }
19591 else
19592 {
19593 /* This is a TTY frame, i.e. character hpos/vpos are used as
19594 pixel x/y. */
19595 init_iterator (&it, w, -1, -1, f->desired_matrix->rows,
19596 MENU_FACE_ID);
19597 it.first_visible_x = 0;
19598 it.last_visible_x = FRAME_COLS (f);
19599 }
19600 #endif /* not USE_X_TOOLKIT */
19601
19602 /* FIXME: This should be controlled by a user option. See the
19603 comments in redisplay_tool_bar and display_mode_line about
19604 this. */
19605 it.paragraph_embedding = L2R;
19606
19607 if (! mode_line_inverse_video)
19608 /* Force the menu-bar to be displayed in the default face. */
19609 it.base_face_id = it.face_id = DEFAULT_FACE_ID;
19610
19611 /* Clear all rows of the menu bar. */
19612 for (i = 0; i < FRAME_MENU_BAR_LINES (f); ++i)
19613 {
19614 struct glyph_row *row = it.glyph_row + i;
19615 clear_glyph_row (row);
19616 row->enabled_p = 1;
19617 row->full_width_p = 1;
19618 }
19619
19620 /* Display all items of the menu bar. */
19621 items = FRAME_MENU_BAR_ITEMS (it.f);
19622 for (i = 0; i < ASIZE (items); i += 4)
19623 {
19624 Lisp_Object string;
19625
19626 /* Stop at nil string. */
19627 string = AREF (items, i + 1);
19628 if (NILP (string))
19629 break;
19630
19631 /* Remember where item was displayed. */
19632 ASET (items, i + 3, make_number (it.hpos));
19633
19634 /* Display the item, pad with one space. */
19635 if (it.current_x < it.last_visible_x)
19636 display_string (NULL, string, Qnil, 0, 0, &it,
19637 SCHARS (string) + 1, 0, 0, -1);
19638 }
19639
19640 /* Fill out the line with spaces. */
19641 if (it.current_x < it.last_visible_x)
19642 display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
19643
19644 /* Compute the total height of the lines. */
19645 compute_line_metrics (&it);
19646 }
19647
19648
19649 \f
19650 /***********************************************************************
19651 Mode Line
19652 ***********************************************************************/
19653
19654 /* Redisplay mode lines in the window tree whose root is WINDOW. If
19655 FORCE is non-zero, redisplay mode lines unconditionally.
19656 Otherwise, redisplay only mode lines that are garbaged. Value is
19657 the number of windows whose mode lines were redisplayed. */
19658
19659 static int
19660 redisplay_mode_lines (Lisp_Object window, int force)
19661 {
19662 int nwindows = 0;
19663
19664 while (!NILP (window))
19665 {
19666 struct window *w = XWINDOW (window);
19667
19668 if (WINDOWP (w->hchild))
19669 nwindows += redisplay_mode_lines (w->hchild, force);
19670 else if (WINDOWP (w->vchild))
19671 nwindows += redisplay_mode_lines (w->vchild, force);
19672 else if (force
19673 || FRAME_GARBAGED_P (XFRAME (w->frame))
19674 || !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
19675 {
19676 struct text_pos lpoint;
19677 struct buffer *old = current_buffer;
19678
19679 /* Set the window's buffer for the mode line display. */
19680 SET_TEXT_POS (lpoint, PT, PT_BYTE);
19681 set_buffer_internal_1 (XBUFFER (w->buffer));
19682
19683 /* Point refers normally to the selected window. For any
19684 other window, set up appropriate value. */
19685 if (!EQ (window, selected_window))
19686 {
19687 struct text_pos pt;
19688
19689 SET_TEXT_POS_FROM_MARKER (pt, w->pointm);
19690 if (CHARPOS (pt) < BEGV)
19691 TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
19692 else if (CHARPOS (pt) > (ZV - 1))
19693 TEMP_SET_PT_BOTH (ZV, ZV_BYTE);
19694 else
19695 TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
19696 }
19697
19698 /* Display mode lines. */
19699 clear_glyph_matrix (w->desired_matrix);
19700 if (display_mode_lines (w))
19701 {
19702 ++nwindows;
19703 w->must_be_updated_p = 1;
19704 }
19705
19706 /* Restore old settings. */
19707 set_buffer_internal_1 (old);
19708 TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
19709 }
19710
19711 window = w->next;
19712 }
19713
19714 return nwindows;
19715 }
19716
19717
19718 /* Display the mode and/or header line of window W. Value is the
19719 sum number of mode lines and header lines displayed. */
19720
19721 static int
19722 display_mode_lines (struct window *w)
19723 {
19724 Lisp_Object old_selected_window, old_selected_frame;
19725 int n = 0;
19726
19727 old_selected_frame = selected_frame;
19728 selected_frame = w->frame;
19729 old_selected_window = selected_window;
19730 XSETWINDOW (selected_window, w);
19731
19732 /* These will be set while the mode line specs are processed. */
19733 line_number_displayed = 0;
19734 w->column_number_displayed = Qnil;
19735
19736 if (WINDOW_WANTS_MODELINE_P (w))
19737 {
19738 struct window *sel_w = XWINDOW (old_selected_window);
19739
19740 /* Select mode line face based on the real selected window. */
19741 display_mode_line (w, CURRENT_MODE_LINE_FACE_ID_3 (sel_w, sel_w, w),
19742 BVAR (current_buffer, mode_line_format));
19743 ++n;
19744 }
19745
19746 if (WINDOW_WANTS_HEADER_LINE_P (w))
19747 {
19748 display_mode_line (w, HEADER_LINE_FACE_ID,
19749 BVAR (current_buffer, header_line_format));
19750 ++n;
19751 }
19752
19753 selected_frame = old_selected_frame;
19754 selected_window = old_selected_window;
19755 return n;
19756 }
19757
19758
19759 /* Display mode or header line of window W. FACE_ID specifies which
19760 line to display; it is either MODE_LINE_FACE_ID or
19761 HEADER_LINE_FACE_ID. FORMAT is the mode/header line format to
19762 display. Value is the pixel height of the mode/header line
19763 displayed. */
19764
19765 static int
19766 display_mode_line (struct window *w, enum face_id face_id, Lisp_Object format)
19767 {
19768 struct it it;
19769 struct face *face;
19770 ptrdiff_t count = SPECPDL_INDEX ();
19771
19772 init_iterator (&it, w, -1, -1, NULL, face_id);
19773 /* Don't extend on a previously drawn mode-line.
19774 This may happen if called from pos_visible_p. */
19775 it.glyph_row->enabled_p = 0;
19776 prepare_desired_row (it.glyph_row);
19777
19778 it.glyph_row->mode_line_p = 1;
19779
19780 if (! mode_line_inverse_video)
19781 /* Force the mode-line to be displayed in the default face. */
19782 it.base_face_id = it.face_id = DEFAULT_FACE_ID;
19783
19784 /* FIXME: This should be controlled by a user option. But
19785 supporting such an option is not trivial, since the mode line is
19786 made up of many separate strings. */
19787 it.paragraph_embedding = L2R;
19788
19789 record_unwind_protect (unwind_format_mode_line,
19790 format_mode_line_unwind_data (NULL, Qnil, 0));
19791
19792 mode_line_target = MODE_LINE_DISPLAY;
19793
19794 /* Temporarily make frame's keyboard the current kboard so that
19795 kboard-local variables in the mode_line_format will get the right
19796 values. */
19797 push_kboard (FRAME_KBOARD (it.f));
19798 record_unwind_save_match_data ();
19799 display_mode_element (&it, 0, 0, 0, format, Qnil, 0);
19800 pop_kboard ();
19801
19802 unbind_to (count, Qnil);
19803
19804 /* Fill up with spaces. */
19805 display_string (" ", Qnil, Qnil, 0, 0, &it, 10000, -1, -1, 0);
19806
19807 compute_line_metrics (&it);
19808 it.glyph_row->full_width_p = 1;
19809 it.glyph_row->continued_p = 0;
19810 it.glyph_row->truncated_on_left_p = 0;
19811 it.glyph_row->truncated_on_right_p = 0;
19812
19813 /* Make a 3D mode-line have a shadow at its right end. */
19814 face = FACE_FROM_ID (it.f, face_id);
19815 extend_face_to_end_of_line (&it);
19816 if (face->box != FACE_NO_BOX)
19817 {
19818 struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
19819 + it.glyph_row->used[TEXT_AREA] - 1);
19820 last->right_box_line_p = 1;
19821 }
19822
19823 return it.glyph_row->height;
19824 }
19825
19826 /* Move element ELT in LIST to the front of LIST.
19827 Return the updated list. */
19828
19829 static Lisp_Object
19830 move_elt_to_front (Lisp_Object elt, Lisp_Object list)
19831 {
19832 register Lisp_Object tail, prev;
19833 register Lisp_Object tem;
19834
19835 tail = list;
19836 prev = Qnil;
19837 while (CONSP (tail))
19838 {
19839 tem = XCAR (tail);
19840
19841 if (EQ (elt, tem))
19842 {
19843 /* Splice out the link TAIL. */
19844 if (NILP (prev))
19845 list = XCDR (tail);
19846 else
19847 Fsetcdr (prev, XCDR (tail));
19848
19849 /* Now make it the first. */
19850 Fsetcdr (tail, list);
19851 return tail;
19852 }
19853 else
19854 prev = tail;
19855 tail = XCDR (tail);
19856 QUIT;
19857 }
19858
19859 /* Not found--return unchanged LIST. */
19860 return list;
19861 }
19862
19863 /* Contribute ELT to the mode line for window IT->w. How it
19864 translates into text depends on its data type.
19865
19866 IT describes the display environment in which we display, as usual.
19867
19868 DEPTH is the depth in recursion. It is used to prevent
19869 infinite recursion here.
19870
19871 FIELD_WIDTH is the number of characters the display of ELT should
19872 occupy in the mode line, and PRECISION is the maximum number of
19873 characters to display from ELT's representation. See
19874 display_string for details.
19875
19876 Returns the hpos of the end of the text generated by ELT.
19877
19878 PROPS is a property list to add to any string we encounter.
19879
19880 If RISKY is nonzero, remove (disregard) any properties in any string
19881 we encounter, and ignore :eval and :propertize.
19882
19883 The global variable `mode_line_target' determines whether the
19884 output is passed to `store_mode_line_noprop',
19885 `store_mode_line_string', or `display_string'. */
19886
19887 static int
19888 display_mode_element (struct it *it, int depth, int field_width, int precision,
19889 Lisp_Object elt, Lisp_Object props, int risky)
19890 {
19891 int n = 0, field, prec;
19892 int literal = 0;
19893
19894 tail_recurse:
19895 if (depth > 100)
19896 elt = build_string ("*too-deep*");
19897
19898 depth++;
19899
19900 switch (SWITCH_ENUM_CAST (XTYPE (elt)))
19901 {
19902 case Lisp_String:
19903 {
19904 /* A string: output it and check for %-constructs within it. */
19905 unsigned char c;
19906 ptrdiff_t offset = 0;
19907
19908 if (SCHARS (elt) > 0
19909 && (!NILP (props) || risky))
19910 {
19911 Lisp_Object oprops, aelt;
19912 oprops = Ftext_properties_at (make_number (0), elt);
19913
19914 /* If the starting string's properties are not what
19915 we want, translate the string. Also, if the string
19916 is risky, do that anyway. */
19917
19918 if (NILP (Fequal (props, oprops)) || risky)
19919 {
19920 /* If the starting string has properties,
19921 merge the specified ones onto the existing ones. */
19922 if (! NILP (oprops) && !risky)
19923 {
19924 Lisp_Object tem;
19925
19926 oprops = Fcopy_sequence (oprops);
19927 tem = props;
19928 while (CONSP (tem))
19929 {
19930 oprops = Fplist_put (oprops, XCAR (tem),
19931 XCAR (XCDR (tem)));
19932 tem = XCDR (XCDR (tem));
19933 }
19934 props = oprops;
19935 }
19936
19937 aelt = Fassoc (elt, mode_line_proptrans_alist);
19938 if (! NILP (aelt) && !NILP (Fequal (props, XCDR (aelt))))
19939 {
19940 /* AELT is what we want. Move it to the front
19941 without consing. */
19942 elt = XCAR (aelt);
19943 mode_line_proptrans_alist
19944 = move_elt_to_front (aelt, mode_line_proptrans_alist);
19945 }
19946 else
19947 {
19948 Lisp_Object tem;
19949
19950 /* If AELT has the wrong props, it is useless.
19951 so get rid of it. */
19952 if (! NILP (aelt))
19953 mode_line_proptrans_alist
19954 = Fdelq (aelt, mode_line_proptrans_alist);
19955
19956 elt = Fcopy_sequence (elt);
19957 Fset_text_properties (make_number (0), Flength (elt),
19958 props, elt);
19959 /* Add this item to mode_line_proptrans_alist. */
19960 mode_line_proptrans_alist
19961 = Fcons (Fcons (elt, props),
19962 mode_line_proptrans_alist);
19963 /* Truncate mode_line_proptrans_alist
19964 to at most 50 elements. */
19965 tem = Fnthcdr (make_number (50),
19966 mode_line_proptrans_alist);
19967 if (! NILP (tem))
19968 XSETCDR (tem, Qnil);
19969 }
19970 }
19971 }
19972
19973 offset = 0;
19974
19975 if (literal)
19976 {
19977 prec = precision - n;
19978 switch (mode_line_target)
19979 {
19980 case MODE_LINE_NOPROP:
19981 case MODE_LINE_TITLE:
19982 n += store_mode_line_noprop (SSDATA (elt), -1, prec);
19983 break;
19984 case MODE_LINE_STRING:
19985 n += store_mode_line_string (NULL, elt, 1, 0, prec, Qnil);
19986 break;
19987 case MODE_LINE_DISPLAY:
19988 n += display_string (NULL, elt, Qnil, 0, 0, it,
19989 0, prec, 0, STRING_MULTIBYTE (elt));
19990 break;
19991 }
19992
19993 break;
19994 }
19995
19996 /* Handle the non-literal case. */
19997
19998 while ((precision <= 0 || n < precision)
19999 && SREF (elt, offset) != 0
20000 && (mode_line_target != MODE_LINE_DISPLAY
20001 || it->current_x < it->last_visible_x))
20002 {
20003 ptrdiff_t last_offset = offset;
20004
20005 /* Advance to end of string or next format specifier. */
20006 while ((c = SREF (elt, offset++)) != '\0' && c != '%')
20007 ;
20008
20009 if (offset - 1 != last_offset)
20010 {
20011 ptrdiff_t nchars, nbytes;
20012
20013 /* Output to end of string or up to '%'. Field width
20014 is length of string. Don't output more than
20015 PRECISION allows us. */
20016 offset--;
20017
20018 prec = c_string_width (SDATA (elt) + last_offset,
20019 offset - last_offset, precision - n,
20020 &nchars, &nbytes);
20021
20022 switch (mode_line_target)
20023 {
20024 case MODE_LINE_NOPROP:
20025 case MODE_LINE_TITLE:
20026 n += store_mode_line_noprop (SSDATA (elt) + last_offset, 0, prec);
20027 break;
20028 case MODE_LINE_STRING:
20029 {
20030 ptrdiff_t bytepos = last_offset;
20031 ptrdiff_t charpos = string_byte_to_char (elt, bytepos);
20032 ptrdiff_t endpos = (precision <= 0
20033 ? string_byte_to_char (elt, offset)
20034 : charpos + nchars);
20035
20036 n += store_mode_line_string (NULL,
20037 Fsubstring (elt, make_number (charpos),
20038 make_number (endpos)),
20039 0, 0, 0, Qnil);
20040 }
20041 break;
20042 case MODE_LINE_DISPLAY:
20043 {
20044 ptrdiff_t bytepos = last_offset;
20045 ptrdiff_t charpos = string_byte_to_char (elt, bytepos);
20046
20047 if (precision <= 0)
20048 nchars = string_byte_to_char (elt, offset) - charpos;
20049 n += display_string (NULL, elt, Qnil, 0, charpos,
20050 it, 0, nchars, 0,
20051 STRING_MULTIBYTE (elt));
20052 }
20053 break;
20054 }
20055 }
20056 else /* c == '%' */
20057 {
20058 ptrdiff_t percent_position = offset;
20059
20060 /* Get the specified minimum width. Zero means
20061 don't pad. */
20062 field = 0;
20063 while ((c = SREF (elt, offset++)) >= '0' && c <= '9')
20064 field = field * 10 + c - '0';
20065
20066 /* Don't pad beyond the total padding allowed. */
20067 if (field_width - n > 0 && field > field_width - n)
20068 field = field_width - n;
20069
20070 /* Note that either PRECISION <= 0 or N < PRECISION. */
20071 prec = precision - n;
20072
20073 if (c == 'M')
20074 n += display_mode_element (it, depth, field, prec,
20075 Vglobal_mode_string, props,
20076 risky);
20077 else if (c != 0)
20078 {
20079 int multibyte;
20080 ptrdiff_t bytepos, charpos;
20081 const char *spec;
20082 Lisp_Object string;
20083
20084 bytepos = percent_position;
20085 charpos = (STRING_MULTIBYTE (elt)
20086 ? string_byte_to_char (elt, bytepos)
20087 : bytepos);
20088 spec = decode_mode_spec (it->w, c, field, &string);
20089 multibyte = STRINGP (string) && STRING_MULTIBYTE (string);
20090
20091 switch (mode_line_target)
20092 {
20093 case MODE_LINE_NOPROP:
20094 case MODE_LINE_TITLE:
20095 n += store_mode_line_noprop (spec, field, prec);
20096 break;
20097 case MODE_LINE_STRING:
20098 {
20099 Lisp_Object tem = build_string (spec);
20100 props = Ftext_properties_at (make_number (charpos), elt);
20101 /* Should only keep face property in props */
20102 n += store_mode_line_string (NULL, tem, 0, field, prec, props);
20103 }
20104 break;
20105 case MODE_LINE_DISPLAY:
20106 {
20107 int nglyphs_before, nwritten;
20108
20109 nglyphs_before = it->glyph_row->used[TEXT_AREA];
20110 nwritten = display_string (spec, string, elt,
20111 charpos, 0, it,
20112 field, prec, 0,
20113 multibyte);
20114
20115 /* Assign to the glyphs written above the
20116 string where the `%x' came from, position
20117 of the `%'. */
20118 if (nwritten > 0)
20119 {
20120 struct glyph *glyph
20121 = (it->glyph_row->glyphs[TEXT_AREA]
20122 + nglyphs_before);
20123 int i;
20124
20125 for (i = 0; i < nwritten; ++i)
20126 {
20127 glyph[i].object = elt;
20128 glyph[i].charpos = charpos;
20129 }
20130
20131 n += nwritten;
20132 }
20133 }
20134 break;
20135 }
20136 }
20137 else /* c == 0 */
20138 break;
20139 }
20140 }
20141 }
20142 break;
20143
20144 case Lisp_Symbol:
20145 /* A symbol: process the value of the symbol recursively
20146 as if it appeared here directly. Avoid error if symbol void.
20147 Special case: if value of symbol is a string, output the string
20148 literally. */
20149 {
20150 register Lisp_Object tem;
20151
20152 /* If the variable is not marked as risky to set
20153 then its contents are risky to use. */
20154 if (NILP (Fget (elt, Qrisky_local_variable)))
20155 risky = 1;
20156
20157 tem = Fboundp (elt);
20158 if (!NILP (tem))
20159 {
20160 tem = Fsymbol_value (elt);
20161 /* If value is a string, output that string literally:
20162 don't check for % within it. */
20163 if (STRINGP (tem))
20164 literal = 1;
20165
20166 if (!EQ (tem, elt))
20167 {
20168 /* Give up right away for nil or t. */
20169 elt = tem;
20170 goto tail_recurse;
20171 }
20172 }
20173 }
20174 break;
20175
20176 case Lisp_Cons:
20177 {
20178 register Lisp_Object car, tem;
20179
20180 /* A cons cell: five distinct cases.
20181 If first element is :eval or :propertize, do something special.
20182 If first element is a string or a cons, process all the elements
20183 and effectively concatenate them.
20184 If first element is a negative number, truncate displaying cdr to
20185 at most that many characters. If positive, pad (with spaces)
20186 to at least that many characters.
20187 If first element is a symbol, process the cadr or caddr recursively
20188 according to whether the symbol's value is non-nil or nil. */
20189 car = XCAR (elt);
20190 if (EQ (car, QCeval))
20191 {
20192 /* An element of the form (:eval FORM) means evaluate FORM
20193 and use the result as mode line elements. */
20194
20195 if (risky)
20196 break;
20197
20198 if (CONSP (XCDR (elt)))
20199 {
20200 Lisp_Object spec;
20201 spec = safe_eval (XCAR (XCDR (elt)));
20202 n += display_mode_element (it, depth, field_width - n,
20203 precision - n, spec, props,
20204 risky);
20205 }
20206 }
20207 else if (EQ (car, QCpropertize))
20208 {
20209 /* An element of the form (:propertize ELT PROPS...)
20210 means display ELT but applying properties PROPS. */
20211
20212 if (risky)
20213 break;
20214
20215 if (CONSP (XCDR (elt)))
20216 n += display_mode_element (it, depth, field_width - n,
20217 precision - n, XCAR (XCDR (elt)),
20218 XCDR (XCDR (elt)), risky);
20219 }
20220 else if (SYMBOLP (car))
20221 {
20222 tem = Fboundp (car);
20223 elt = XCDR (elt);
20224 if (!CONSP (elt))
20225 goto invalid;
20226 /* elt is now the cdr, and we know it is a cons cell.
20227 Use its car if CAR has a non-nil value. */
20228 if (!NILP (tem))
20229 {
20230 tem = Fsymbol_value (car);
20231 if (!NILP (tem))
20232 {
20233 elt = XCAR (elt);
20234 goto tail_recurse;
20235 }
20236 }
20237 /* Symbol's value is nil (or symbol is unbound)
20238 Get the cddr of the original list
20239 and if possible find the caddr and use that. */
20240 elt = XCDR (elt);
20241 if (NILP (elt))
20242 break;
20243 else if (!CONSP (elt))
20244 goto invalid;
20245 elt = XCAR (elt);
20246 goto tail_recurse;
20247 }
20248 else if (INTEGERP (car))
20249 {
20250 register int lim = XINT (car);
20251 elt = XCDR (elt);
20252 if (lim < 0)
20253 {
20254 /* Negative int means reduce maximum width. */
20255 if (precision <= 0)
20256 precision = -lim;
20257 else
20258 precision = min (precision, -lim);
20259 }
20260 else if (lim > 0)
20261 {
20262 /* Padding specified. Don't let it be more than
20263 current maximum. */
20264 if (precision > 0)
20265 lim = min (precision, lim);
20266
20267 /* If that's more padding than already wanted, queue it.
20268 But don't reduce padding already specified even if
20269 that is beyond the current truncation point. */
20270 field_width = max (lim, field_width);
20271 }
20272 goto tail_recurse;
20273 }
20274 else if (STRINGP (car) || CONSP (car))
20275 {
20276 Lisp_Object halftail = elt;
20277 int len = 0;
20278
20279 while (CONSP (elt)
20280 && (precision <= 0 || n < precision))
20281 {
20282 n += display_mode_element (it, depth,
20283 /* Do padding only after the last
20284 element in the list. */
20285 (! CONSP (XCDR (elt))
20286 ? field_width - n
20287 : 0),
20288 precision - n, XCAR (elt),
20289 props, risky);
20290 elt = XCDR (elt);
20291 len++;
20292 if ((len & 1) == 0)
20293 halftail = XCDR (halftail);
20294 /* Check for cycle. */
20295 if (EQ (halftail, elt))
20296 break;
20297 }
20298 }
20299 }
20300 break;
20301
20302 default:
20303 invalid:
20304 elt = build_string ("*invalid*");
20305 goto tail_recurse;
20306 }
20307
20308 /* Pad to FIELD_WIDTH. */
20309 if (field_width > 0 && n < field_width)
20310 {
20311 switch (mode_line_target)
20312 {
20313 case MODE_LINE_NOPROP:
20314 case MODE_LINE_TITLE:
20315 n += store_mode_line_noprop ("", field_width - n, 0);
20316 break;
20317 case MODE_LINE_STRING:
20318 n += store_mode_line_string ("", Qnil, 0, field_width - n, 0, Qnil);
20319 break;
20320 case MODE_LINE_DISPLAY:
20321 n += display_string ("", Qnil, Qnil, 0, 0, it, field_width - n,
20322 0, 0, 0);
20323 break;
20324 }
20325 }
20326
20327 return n;
20328 }
20329
20330 /* Store a mode-line string element in mode_line_string_list.
20331
20332 If STRING is non-null, display that C string. Otherwise, the Lisp
20333 string LISP_STRING is displayed.
20334
20335 FIELD_WIDTH is the minimum number of output glyphs to produce.
20336 If STRING has fewer characters than FIELD_WIDTH, pad to the right
20337 with spaces. FIELD_WIDTH <= 0 means don't pad.
20338
20339 PRECISION is the maximum number of characters to output from
20340 STRING. PRECISION <= 0 means don't truncate the string.
20341
20342 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
20343 properties to the string.
20344
20345 PROPS are the properties to add to the string.
20346 The mode_line_string_face face property is always added to the string.
20347 */
20348
20349 static int
20350 store_mode_line_string (const char *string, Lisp_Object lisp_string, int copy_string,
20351 int field_width, int precision, Lisp_Object props)
20352 {
20353 ptrdiff_t len;
20354 int n = 0;
20355
20356 if (string != NULL)
20357 {
20358 len = strlen (string);
20359 if (precision > 0 && len > precision)
20360 len = precision;
20361 lisp_string = make_string (string, len);
20362 if (NILP (props))
20363 props = mode_line_string_face_prop;
20364 else if (!NILP (mode_line_string_face))
20365 {
20366 Lisp_Object face = Fplist_get (props, Qface);
20367 props = Fcopy_sequence (props);
20368 if (NILP (face))
20369 face = mode_line_string_face;
20370 else
20371 face = Fcons (face, Fcons (mode_line_string_face, Qnil));
20372 props = Fplist_put (props, Qface, face);
20373 }
20374 Fadd_text_properties (make_number (0), make_number (len),
20375 props, lisp_string);
20376 }
20377 else
20378 {
20379 len = XFASTINT (Flength (lisp_string));
20380 if (precision > 0 && len > precision)
20381 {
20382 len = precision;
20383 lisp_string = Fsubstring (lisp_string, make_number (0), make_number (len));
20384 precision = -1;
20385 }
20386 if (!NILP (mode_line_string_face))
20387 {
20388 Lisp_Object face;
20389 if (NILP (props))
20390 props = Ftext_properties_at (make_number (0), lisp_string);
20391 face = Fplist_get (props, Qface);
20392 if (NILP (face))
20393 face = mode_line_string_face;
20394 else
20395 face = Fcons (face, Fcons (mode_line_string_face, Qnil));
20396 props = Fcons (Qface, Fcons (face, Qnil));
20397 if (copy_string)
20398 lisp_string = Fcopy_sequence (lisp_string);
20399 }
20400 if (!NILP (props))
20401 Fadd_text_properties (make_number (0), make_number (len),
20402 props, lisp_string);
20403 }
20404
20405 if (len > 0)
20406 {
20407 mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
20408 n += len;
20409 }
20410
20411 if (field_width > len)
20412 {
20413 field_width -= len;
20414 lisp_string = Fmake_string (make_number (field_width), make_number (' '));
20415 if (!NILP (props))
20416 Fadd_text_properties (make_number (0), make_number (field_width),
20417 props, lisp_string);
20418 mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
20419 n += field_width;
20420 }
20421
20422 return n;
20423 }
20424
20425
20426 DEFUN ("format-mode-line", Fformat_mode_line, Sformat_mode_line,
20427 1, 4, 0,
20428 doc: /* Format a string out of a mode line format specification.
20429 First arg FORMAT specifies the mode line format (see `mode-line-format'
20430 for details) to use.
20431
20432 By default, the format is evaluated for the currently selected window.
20433
20434 Optional second arg FACE specifies the face property to put on all
20435 characters for which no face is specified. The value nil means the
20436 default face. The value t means whatever face the window's mode line
20437 currently uses (either `mode-line' or `mode-line-inactive',
20438 depending on whether the window is the selected window or not).
20439 An integer value means the value string has no text
20440 properties.
20441
20442 Optional third and fourth args WINDOW and BUFFER specify the window
20443 and buffer to use as the context for the formatting (defaults
20444 are the selected window and the WINDOW's buffer). */)
20445 (Lisp_Object format, Lisp_Object face,
20446 Lisp_Object window, Lisp_Object buffer)
20447 {
20448 struct it it;
20449 int len;
20450 struct window *w;
20451 struct buffer *old_buffer = NULL;
20452 int face_id;
20453 int no_props = INTEGERP (face);
20454 ptrdiff_t count = SPECPDL_INDEX ();
20455 Lisp_Object str;
20456 int string_start = 0;
20457
20458 if (NILP (window))
20459 window = selected_window;
20460 CHECK_WINDOW (window);
20461 w = XWINDOW (window);
20462
20463 if (NILP (buffer))
20464 buffer = w->buffer;
20465 CHECK_BUFFER (buffer);
20466
20467 /* Make formatting the modeline a non-op when noninteractive, otherwise
20468 there will be problems later caused by a partially initialized frame. */
20469 if (NILP (format) || noninteractive)
20470 return empty_unibyte_string;
20471
20472 if (no_props)
20473 face = Qnil;
20474
20475 face_id = (NILP (face) || EQ (face, Qdefault)) ? DEFAULT_FACE_ID
20476 : EQ (face, Qt) ? (EQ (window, selected_window)
20477 ? MODE_LINE_FACE_ID : MODE_LINE_INACTIVE_FACE_ID)
20478 : EQ (face, Qmode_line) ? MODE_LINE_FACE_ID
20479 : EQ (face, Qmode_line_inactive) ? MODE_LINE_INACTIVE_FACE_ID
20480 : EQ (face, Qheader_line) ? HEADER_LINE_FACE_ID
20481 : EQ (face, Qtool_bar) ? TOOL_BAR_FACE_ID
20482 : DEFAULT_FACE_ID;
20483
20484 if (XBUFFER (buffer) != current_buffer)
20485 old_buffer = current_buffer;
20486
20487 /* Save things including mode_line_proptrans_alist,
20488 and set that to nil so that we don't alter the outer value. */
20489 record_unwind_protect (unwind_format_mode_line,
20490 format_mode_line_unwind_data
20491 (old_buffer, selected_window, 1));
20492 mode_line_proptrans_alist = Qnil;
20493
20494 Fselect_window (window, Qt);
20495 if (old_buffer)
20496 set_buffer_internal_1 (XBUFFER (buffer));
20497
20498 init_iterator (&it, w, -1, -1, NULL, face_id);
20499
20500 if (no_props)
20501 {
20502 mode_line_target = MODE_LINE_NOPROP;
20503 mode_line_string_face_prop = Qnil;
20504 mode_line_string_list = Qnil;
20505 string_start = MODE_LINE_NOPROP_LEN (0);
20506 }
20507 else
20508 {
20509 mode_line_target = MODE_LINE_STRING;
20510 mode_line_string_list = Qnil;
20511 mode_line_string_face = face;
20512 mode_line_string_face_prop
20513 = (NILP (face) ? Qnil : Fcons (Qface, Fcons (face, Qnil)));
20514 }
20515
20516 push_kboard (FRAME_KBOARD (it.f));
20517 display_mode_element (&it, 0, 0, 0, format, Qnil, 0);
20518 pop_kboard ();
20519
20520 if (no_props)
20521 {
20522 len = MODE_LINE_NOPROP_LEN (string_start);
20523 str = make_string (mode_line_noprop_buf + string_start, len);
20524 }
20525 else
20526 {
20527 mode_line_string_list = Fnreverse (mode_line_string_list);
20528 str = Fmapconcat (intern ("identity"), mode_line_string_list,
20529 empty_unibyte_string);
20530 }
20531
20532 unbind_to (count, Qnil);
20533 return str;
20534 }
20535
20536 /* Write a null-terminated, right justified decimal representation of
20537 the positive integer D to BUF using a minimal field width WIDTH. */
20538
20539 static void
20540 pint2str (register char *buf, register int width, register ptrdiff_t d)
20541 {
20542 register char *p = buf;
20543
20544 if (d <= 0)
20545 *p++ = '0';
20546 else
20547 {
20548 while (d > 0)
20549 {
20550 *p++ = d % 10 + '0';
20551 d /= 10;
20552 }
20553 }
20554
20555 for (width -= (int) (p - buf); width > 0; --width)
20556 *p++ = ' ';
20557 *p-- = '\0';
20558 while (p > buf)
20559 {
20560 d = *buf;
20561 *buf++ = *p;
20562 *p-- = d;
20563 }
20564 }
20565
20566 /* Write a null-terminated, right justified decimal and "human
20567 readable" representation of the nonnegative integer D to BUF using
20568 a minimal field width WIDTH. D should be smaller than 999.5e24. */
20569
20570 static const char power_letter[] =
20571 {
20572 0, /* no letter */
20573 'k', /* kilo */
20574 'M', /* mega */
20575 'G', /* giga */
20576 'T', /* tera */
20577 'P', /* peta */
20578 'E', /* exa */
20579 'Z', /* zetta */
20580 'Y' /* yotta */
20581 };
20582
20583 static void
20584 pint2hrstr (char *buf, int width, ptrdiff_t d)
20585 {
20586 /* We aim to represent the nonnegative integer D as
20587 QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
20588 ptrdiff_t quotient = d;
20589 int remainder = 0;
20590 /* -1 means: do not use TENTHS. */
20591 int tenths = -1;
20592 int exponent = 0;
20593
20594 /* Length of QUOTIENT.TENTHS as a string. */
20595 int length;
20596
20597 char * psuffix;
20598 char * p;
20599
20600 if (1000 <= quotient)
20601 {
20602 /* Scale to the appropriate EXPONENT. */
20603 do
20604 {
20605 remainder = quotient % 1000;
20606 quotient /= 1000;
20607 exponent++;
20608 }
20609 while (1000 <= quotient);
20610
20611 /* Round to nearest and decide whether to use TENTHS or not. */
20612 if (quotient <= 9)
20613 {
20614 tenths = remainder / 100;
20615 if (50 <= remainder % 100)
20616 {
20617 if (tenths < 9)
20618 tenths++;
20619 else
20620 {
20621 quotient++;
20622 if (quotient == 10)
20623 tenths = -1;
20624 else
20625 tenths = 0;
20626 }
20627 }
20628 }
20629 else
20630 if (500 <= remainder)
20631 {
20632 if (quotient < 999)
20633 quotient++;
20634 else
20635 {
20636 quotient = 1;
20637 exponent++;
20638 tenths = 0;
20639 }
20640 }
20641 }
20642
20643 /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
20644 if (tenths == -1 && quotient <= 99)
20645 if (quotient <= 9)
20646 length = 1;
20647 else
20648 length = 2;
20649 else
20650 length = 3;
20651 p = psuffix = buf + max (width, length);
20652
20653 /* Print EXPONENT. */
20654 *psuffix++ = power_letter[exponent];
20655 *psuffix = '\0';
20656
20657 /* Print TENTHS. */
20658 if (tenths >= 0)
20659 {
20660 *--p = '0' + tenths;
20661 *--p = '.';
20662 }
20663
20664 /* Print QUOTIENT. */
20665 do
20666 {
20667 int digit = quotient % 10;
20668 *--p = '0' + digit;
20669 }
20670 while ((quotient /= 10) != 0);
20671
20672 /* Print leading spaces. */
20673 while (buf < p)
20674 *--p = ' ';
20675 }
20676
20677 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
20678 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
20679 type of CODING_SYSTEM. Return updated pointer into BUF. */
20680
20681 static unsigned char invalid_eol_type[] = "(*invalid*)";
20682
20683 static char *
20684 decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_flag)
20685 {
20686 Lisp_Object val;
20687 int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
20688 const unsigned char *eol_str;
20689 int eol_str_len;
20690 /* The EOL conversion we are using. */
20691 Lisp_Object eoltype;
20692
20693 val = CODING_SYSTEM_SPEC (coding_system);
20694 eoltype = Qnil;
20695
20696 if (!VECTORP (val)) /* Not yet decided. */
20697 {
20698 if (multibyte)
20699 *buf++ = '-';
20700 if (eol_flag)
20701 eoltype = eol_mnemonic_undecided;
20702 /* Don't mention EOL conversion if it isn't decided. */
20703 }
20704 else
20705 {
20706 Lisp_Object attrs;
20707 Lisp_Object eolvalue;
20708
20709 attrs = AREF (val, 0);
20710 eolvalue = AREF (val, 2);
20711
20712 if (multibyte)
20713 *buf++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs));
20714
20715 if (eol_flag)
20716 {
20717 /* The EOL conversion that is normal on this system. */
20718
20719 if (NILP (eolvalue)) /* Not yet decided. */
20720 eoltype = eol_mnemonic_undecided;
20721 else if (VECTORP (eolvalue)) /* Not yet decided. */
20722 eoltype = eol_mnemonic_undecided;
20723 else /* eolvalue is Qunix, Qdos, or Qmac. */
20724 eoltype = (EQ (eolvalue, Qunix)
20725 ? eol_mnemonic_unix
20726 : (EQ (eolvalue, Qdos) == 1
20727 ? eol_mnemonic_dos : eol_mnemonic_mac));
20728 }
20729 }
20730
20731 if (eol_flag)
20732 {
20733 /* Mention the EOL conversion if it is not the usual one. */
20734 if (STRINGP (eoltype))
20735 {
20736 eol_str = SDATA (eoltype);
20737 eol_str_len = SBYTES (eoltype);
20738 }
20739 else if (CHARACTERP (eoltype))
20740 {
20741 unsigned char *tmp = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH);
20742 int c = XFASTINT (eoltype);
20743 eol_str_len = CHAR_STRING (c, tmp);
20744 eol_str = tmp;
20745 }
20746 else
20747 {
20748 eol_str = invalid_eol_type;
20749 eol_str_len = sizeof (invalid_eol_type) - 1;
20750 }
20751 memcpy (buf, eol_str, eol_str_len);
20752 buf += eol_str_len;
20753 }
20754
20755 return buf;
20756 }
20757
20758 /* Return a string for the output of a mode line %-spec for window W,
20759 generated by character C. FIELD_WIDTH > 0 means pad the string
20760 returned with spaces to that value. Return a Lisp string in
20761 *STRING if the resulting string is taken from that Lisp string.
20762
20763 Note we operate on the current buffer for most purposes,
20764 the exception being w->base_line_pos. */
20765
20766 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
20767
20768 static const char *
20769 decode_mode_spec (struct window *w, register int c, int field_width,
20770 Lisp_Object *string)
20771 {
20772 Lisp_Object obj;
20773 struct frame *f = XFRAME (WINDOW_FRAME (w));
20774 char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
20775 struct buffer *b = current_buffer;
20776
20777 obj = Qnil;
20778 *string = Qnil;
20779
20780 switch (c)
20781 {
20782 case '*':
20783 if (!NILP (BVAR (b, read_only)))
20784 return "%";
20785 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
20786 return "*";
20787 return "-";
20788
20789 case '+':
20790 /* This differs from %* only for a modified read-only buffer. */
20791 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
20792 return "*";
20793 if (!NILP (BVAR (b, read_only)))
20794 return "%";
20795 return "-";
20796
20797 case '&':
20798 /* This differs from %* in ignoring read-only-ness. */
20799 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
20800 return "*";
20801 return "-";
20802
20803 case '%':
20804 return "%";
20805
20806 case '[':
20807 {
20808 int i;
20809 char *p;
20810
20811 if (command_loop_level > 5)
20812 return "[[[... ";
20813 p = decode_mode_spec_buf;
20814 for (i = 0; i < command_loop_level; i++)
20815 *p++ = '[';
20816 *p = 0;
20817 return decode_mode_spec_buf;
20818 }
20819
20820 case ']':
20821 {
20822 int i;
20823 char *p;
20824
20825 if (command_loop_level > 5)
20826 return " ...]]]";
20827 p = decode_mode_spec_buf;
20828 for (i = 0; i < command_loop_level; i++)
20829 *p++ = ']';
20830 *p = 0;
20831 return decode_mode_spec_buf;
20832 }
20833
20834 case '-':
20835 {
20836 register int i;
20837
20838 /* Let lots_of_dashes be a string of infinite length. */
20839 if (mode_line_target == MODE_LINE_NOPROP ||
20840 mode_line_target == MODE_LINE_STRING)
20841 return "--";
20842 if (field_width <= 0
20843 || field_width > sizeof (lots_of_dashes))
20844 {
20845 for (i = 0; i < FRAME_MESSAGE_BUF_SIZE (f) - 1; ++i)
20846 decode_mode_spec_buf[i] = '-';
20847 decode_mode_spec_buf[i] = '\0';
20848 return decode_mode_spec_buf;
20849 }
20850 else
20851 return lots_of_dashes;
20852 }
20853
20854 case 'b':
20855 obj = BVAR (b, name);
20856 break;
20857
20858 case 'c':
20859 /* %c and %l are ignored in `frame-title-format'.
20860 (In redisplay_internal, the frame title is drawn _before_ the
20861 windows are updated, so the stuff which depends on actual
20862 window contents (such as %l) may fail to render properly, or
20863 even crash emacs.) */
20864 if (mode_line_target == MODE_LINE_TITLE)
20865 return "";
20866 else
20867 {
20868 ptrdiff_t col = current_column ();
20869 w->column_number_displayed = make_number (col);
20870 pint2str (decode_mode_spec_buf, field_width, col);
20871 return decode_mode_spec_buf;
20872 }
20873
20874 case 'e':
20875 #ifndef SYSTEM_MALLOC
20876 {
20877 if (NILP (Vmemory_full))
20878 return "";
20879 else
20880 return "!MEM FULL! ";
20881 }
20882 #else
20883 return "";
20884 #endif
20885
20886 case 'F':
20887 /* %F displays the frame name. */
20888 if (!NILP (f->title))
20889 return SSDATA (f->title);
20890 if (f->explicit_name || ! FRAME_WINDOW_P (f))
20891 return SSDATA (f->name);
20892 return "Emacs";
20893
20894 case 'f':
20895 obj = BVAR (b, filename);
20896 break;
20897
20898 case 'i':
20899 {
20900 ptrdiff_t size = ZV - BEGV;
20901 pint2str (decode_mode_spec_buf, field_width, size);
20902 return decode_mode_spec_buf;
20903 }
20904
20905 case 'I':
20906 {
20907 ptrdiff_t size = ZV - BEGV;
20908 pint2hrstr (decode_mode_spec_buf, field_width, size);
20909 return decode_mode_spec_buf;
20910 }
20911
20912 case 'l':
20913 {
20914 ptrdiff_t startpos, startpos_byte, line, linepos, linepos_byte;
20915 ptrdiff_t topline, nlines, height;
20916 ptrdiff_t junk;
20917
20918 /* %c and %l are ignored in `frame-title-format'. */
20919 if (mode_line_target == MODE_LINE_TITLE)
20920 return "";
20921
20922 startpos = XMARKER (w->start)->charpos;
20923 startpos_byte = marker_byte_position (w->start);
20924 height = WINDOW_TOTAL_LINES (w);
20925
20926 /* If we decided that this buffer isn't suitable for line numbers,
20927 don't forget that too fast. */
20928 if (EQ (w->base_line_pos, w->buffer))
20929 goto no_value;
20930 /* But do forget it, if the window shows a different buffer now. */
20931 else if (BUFFERP (w->base_line_pos))
20932 w->base_line_pos = Qnil;
20933
20934 /* If the buffer is very big, don't waste time. */
20935 if (INTEGERP (Vline_number_display_limit)
20936 && BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
20937 {
20938 w->base_line_pos = Qnil;
20939 w->base_line_number = Qnil;
20940 goto no_value;
20941 }
20942
20943 if (INTEGERP (w->base_line_number)
20944 && INTEGERP (w->base_line_pos)
20945 && XFASTINT (w->base_line_pos) <= startpos)
20946 {
20947 line = XFASTINT (w->base_line_number);
20948 linepos = XFASTINT (w->base_line_pos);
20949 linepos_byte = buf_charpos_to_bytepos (b, linepos);
20950 }
20951 else
20952 {
20953 line = 1;
20954 linepos = BUF_BEGV (b);
20955 linepos_byte = BUF_BEGV_BYTE (b);
20956 }
20957
20958 /* Count lines from base line to window start position. */
20959 nlines = display_count_lines (linepos_byte,
20960 startpos_byte,
20961 startpos, &junk);
20962
20963 topline = nlines + line;
20964
20965 /* Determine a new base line, if the old one is too close
20966 or too far away, or if we did not have one.
20967 "Too close" means it's plausible a scroll-down would
20968 go back past it. */
20969 if (startpos == BUF_BEGV (b))
20970 {
20971 w->base_line_number = make_number (topline);
20972 w->base_line_pos = make_number (BUF_BEGV (b));
20973 }
20974 else if (nlines < height + 25 || nlines > height * 3 + 50
20975 || linepos == BUF_BEGV (b))
20976 {
20977 ptrdiff_t limit = BUF_BEGV (b);
20978 ptrdiff_t limit_byte = BUF_BEGV_BYTE (b);
20979 ptrdiff_t position;
20980 ptrdiff_t distance =
20981 (height * 2 + 30) * line_number_display_limit_width;
20982
20983 if (startpos - distance > limit)
20984 {
20985 limit = startpos - distance;
20986 limit_byte = CHAR_TO_BYTE (limit);
20987 }
20988
20989 nlines = display_count_lines (startpos_byte,
20990 limit_byte,
20991 - (height * 2 + 30),
20992 &position);
20993 /* If we couldn't find the lines we wanted within
20994 line_number_display_limit_width chars per line,
20995 give up on line numbers for this window. */
20996 if (position == limit_byte && limit == startpos - distance)
20997 {
20998 w->base_line_pos = w->buffer;
20999 w->base_line_number = Qnil;
21000 goto no_value;
21001 }
21002
21003 w->base_line_number = make_number (topline - nlines);
21004 w->base_line_pos = make_number (BYTE_TO_CHAR (position));
21005 }
21006
21007 /* Now count lines from the start pos to point. */
21008 nlines = display_count_lines (startpos_byte,
21009 PT_BYTE, PT, &junk);
21010
21011 /* Record that we did display the line number. */
21012 line_number_displayed = 1;
21013
21014 /* Make the string to show. */
21015 pint2str (decode_mode_spec_buf, field_width, topline + nlines);
21016 return decode_mode_spec_buf;
21017 no_value:
21018 {
21019 char* p = decode_mode_spec_buf;
21020 int pad = field_width - 2;
21021 while (pad-- > 0)
21022 *p++ = ' ';
21023 *p++ = '?';
21024 *p++ = '?';
21025 *p = '\0';
21026 return decode_mode_spec_buf;
21027 }
21028 }
21029 break;
21030
21031 case 'm':
21032 obj = BVAR (b, mode_name);
21033 break;
21034
21035 case 'n':
21036 if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b))
21037 return " Narrow";
21038 break;
21039
21040 case 'p':
21041 {
21042 ptrdiff_t pos = marker_position (w->start);
21043 ptrdiff_t total = BUF_ZV (b) - BUF_BEGV (b);
21044
21045 if (XFASTINT (w->window_end_pos) <= BUF_Z (b) - BUF_ZV (b))
21046 {
21047 if (pos <= BUF_BEGV (b))
21048 return "All";
21049 else
21050 return "Bottom";
21051 }
21052 else if (pos <= BUF_BEGV (b))
21053 return "Top";
21054 else
21055 {
21056 if (total > 1000000)
21057 /* Do it differently for a large value, to avoid overflow. */
21058 total = ((pos - BUF_BEGV (b)) + (total / 100) - 1) / (total / 100);
21059 else
21060 total = ((pos - BUF_BEGV (b)) * 100 + total - 1) / total;
21061 /* We can't normally display a 3-digit number,
21062 so get us a 2-digit number that is close. */
21063 if (total == 100)
21064 total = 99;
21065 sprintf (decode_mode_spec_buf, "%2"pD"d%%", total);
21066 return decode_mode_spec_buf;
21067 }
21068 }
21069
21070 /* Display percentage of size above the bottom of the screen. */
21071 case 'P':
21072 {
21073 ptrdiff_t toppos = marker_position (w->start);
21074 ptrdiff_t botpos = BUF_Z (b) - XFASTINT (w->window_end_pos);
21075 ptrdiff_t total = BUF_ZV (b) - BUF_BEGV (b);
21076
21077 if (botpos >= BUF_ZV (b))
21078 {
21079 if (toppos <= BUF_BEGV (b))
21080 return "All";
21081 else
21082 return "Bottom";
21083 }
21084 else
21085 {
21086 if (total > 1000000)
21087 /* Do it differently for a large value, to avoid overflow. */
21088 total = ((botpos - BUF_BEGV (b)) + (total / 100) - 1) / (total / 100);
21089 else
21090 total = ((botpos - BUF_BEGV (b)) * 100 + total - 1) / total;
21091 /* We can't normally display a 3-digit number,
21092 so get us a 2-digit number that is close. */
21093 if (total == 100)
21094 total = 99;
21095 if (toppos <= BUF_BEGV (b))
21096 sprintf (decode_mode_spec_buf, "Top%2"pD"d%%", total);
21097 else
21098 sprintf (decode_mode_spec_buf, "%2"pD"d%%", total);
21099 return decode_mode_spec_buf;
21100 }
21101 }
21102
21103 case 's':
21104 /* status of process */
21105 obj = Fget_buffer_process (Fcurrent_buffer ());
21106 if (NILP (obj))
21107 return "no process";
21108 #ifndef MSDOS
21109 obj = Fsymbol_name (Fprocess_status (obj));
21110 #endif
21111 break;
21112
21113 case '@':
21114 {
21115 ptrdiff_t count = inhibit_garbage_collection ();
21116 Lisp_Object val = call1 (intern ("file-remote-p"),
21117 BVAR (current_buffer, directory));
21118 unbind_to (count, Qnil);
21119
21120 if (NILP (val))
21121 return "-";
21122 else
21123 return "@";
21124 }
21125
21126 case 't': /* indicate TEXT or BINARY */
21127 return "T";
21128
21129 case 'z':
21130 /* coding-system (not including end-of-line format) */
21131 case 'Z':
21132 /* coding-system (including end-of-line type) */
21133 {
21134 int eol_flag = (c == 'Z');
21135 char *p = decode_mode_spec_buf;
21136
21137 if (! FRAME_WINDOW_P (f))
21138 {
21139 /* No need to mention EOL here--the terminal never needs
21140 to do EOL conversion. */
21141 p = decode_mode_spec_coding (CODING_ID_NAME
21142 (FRAME_KEYBOARD_CODING (f)->id),
21143 p, 0);
21144 p = decode_mode_spec_coding (CODING_ID_NAME
21145 (FRAME_TERMINAL_CODING (f)->id),
21146 p, 0);
21147 }
21148 p = decode_mode_spec_coding (BVAR (b, buffer_file_coding_system),
21149 p, eol_flag);
21150
21151 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
21152 #ifdef subprocesses
21153 obj = Fget_buffer_process (Fcurrent_buffer ());
21154 if (PROCESSP (obj))
21155 {
21156 p = decode_mode_spec_coding (XPROCESS (obj)->decode_coding_system,
21157 p, eol_flag);
21158 p = decode_mode_spec_coding (XPROCESS (obj)->encode_coding_system,
21159 p, eol_flag);
21160 }
21161 #endif /* subprocesses */
21162 #endif /* 0 */
21163 *p = 0;
21164 return decode_mode_spec_buf;
21165 }
21166 }
21167
21168 if (STRINGP (obj))
21169 {
21170 *string = obj;
21171 return SSDATA (obj);
21172 }
21173 else
21174 return "";
21175 }
21176
21177
21178 /* Count up to COUNT lines starting from START_BYTE.
21179 But don't go beyond LIMIT_BYTE.
21180 Return the number of lines thus found (always nonnegative).
21181
21182 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
21183
21184 static ptrdiff_t
21185 display_count_lines (ptrdiff_t start_byte,
21186 ptrdiff_t limit_byte, ptrdiff_t count,
21187 ptrdiff_t *byte_pos_ptr)
21188 {
21189 register unsigned char *cursor;
21190 unsigned char *base;
21191
21192 register ptrdiff_t ceiling;
21193 register unsigned char *ceiling_addr;
21194 ptrdiff_t orig_count = count;
21195
21196 /* If we are not in selective display mode,
21197 check only for newlines. */
21198 int selective_display = (!NILP (BVAR (current_buffer, selective_display))
21199 && !INTEGERP (BVAR (current_buffer, selective_display)));
21200
21201 if (count > 0)
21202 {
21203 while (start_byte < limit_byte)
21204 {
21205 ceiling = BUFFER_CEILING_OF (start_byte);
21206 ceiling = min (limit_byte - 1, ceiling);
21207 ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
21208 base = (cursor = BYTE_POS_ADDR (start_byte));
21209 while (1)
21210 {
21211 if (selective_display)
21212 while (*cursor != '\n' && *cursor != 015 && ++cursor != ceiling_addr)
21213 ;
21214 else
21215 while (*cursor != '\n' && ++cursor != ceiling_addr)
21216 ;
21217
21218 if (cursor != ceiling_addr)
21219 {
21220 if (--count == 0)
21221 {
21222 start_byte += cursor - base + 1;
21223 *byte_pos_ptr = start_byte;
21224 return orig_count;
21225 }
21226 else
21227 if (++cursor == ceiling_addr)
21228 break;
21229 }
21230 else
21231 break;
21232 }
21233 start_byte += cursor - base;
21234 }
21235 }
21236 else
21237 {
21238 while (start_byte > limit_byte)
21239 {
21240 ceiling = BUFFER_FLOOR_OF (start_byte - 1);
21241 ceiling = max (limit_byte, ceiling);
21242 ceiling_addr = BYTE_POS_ADDR (ceiling) - 1;
21243 base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
21244 while (1)
21245 {
21246 if (selective_display)
21247 while (--cursor != ceiling_addr
21248 && *cursor != '\n' && *cursor != 015)
21249 ;
21250 else
21251 while (--cursor != ceiling_addr && *cursor != '\n')
21252 ;
21253
21254 if (cursor != ceiling_addr)
21255 {
21256 if (++count == 0)
21257 {
21258 start_byte += cursor - base + 1;
21259 *byte_pos_ptr = start_byte;
21260 /* When scanning backwards, we should
21261 not count the newline posterior to which we stop. */
21262 return - orig_count - 1;
21263 }
21264 }
21265 else
21266 break;
21267 }
21268 /* Here we add 1 to compensate for the last decrement
21269 of CURSOR, which took it past the valid range. */
21270 start_byte += cursor - base + 1;
21271 }
21272 }
21273
21274 *byte_pos_ptr = limit_byte;
21275
21276 if (count < 0)
21277 return - orig_count + count;
21278 return orig_count - count;
21279
21280 }
21281
21282
21283 \f
21284 /***********************************************************************
21285 Displaying strings
21286 ***********************************************************************/
21287
21288 /* Display a NUL-terminated string, starting with index START.
21289
21290 If STRING is non-null, display that C string. Otherwise, the Lisp
21291 string LISP_STRING is displayed. There's a case that STRING is
21292 non-null and LISP_STRING is not nil. It means STRING is a string
21293 data of LISP_STRING. In that case, we display LISP_STRING while
21294 ignoring its text properties.
21295
21296 If FACE_STRING is not nil, FACE_STRING_POS is a position in
21297 FACE_STRING. Display STRING or LISP_STRING with the face at
21298 FACE_STRING_POS in FACE_STRING:
21299
21300 Display the string in the environment given by IT, but use the
21301 standard display table, temporarily.
21302
21303 FIELD_WIDTH is the minimum number of output glyphs to produce.
21304 If STRING has fewer characters than FIELD_WIDTH, pad to the right
21305 with spaces. If STRING has more characters, more than FIELD_WIDTH
21306 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
21307
21308 PRECISION is the maximum number of characters to output from
21309 STRING. PRECISION < 0 means don't truncate the string.
21310
21311 This is roughly equivalent to printf format specifiers:
21312
21313 FIELD_WIDTH PRECISION PRINTF
21314 ----------------------------------------
21315 -1 -1 %s
21316 -1 10 %.10s
21317 10 -1 %10s
21318 20 10 %20.10s
21319
21320 MULTIBYTE zero means do not display multibyte chars, > 0 means do
21321 display them, and < 0 means obey the current buffer's value of
21322 enable_multibyte_characters.
21323
21324 Value is the number of columns displayed. */
21325
21326 static int
21327 display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_string,
21328 ptrdiff_t face_string_pos, ptrdiff_t start, struct it *it,
21329 int field_width, int precision, int max_x, int multibyte)
21330 {
21331 int hpos_at_start = it->hpos;
21332 int saved_face_id = it->face_id;
21333 struct glyph_row *row = it->glyph_row;
21334 ptrdiff_t it_charpos;
21335
21336 /* Initialize the iterator IT for iteration over STRING beginning
21337 with index START. */
21338 reseat_to_string (it, NILP (lisp_string) ? string : NULL, lisp_string, start,
21339 precision, field_width, multibyte);
21340 if (string && STRINGP (lisp_string))
21341 /* LISP_STRING is the one returned by decode_mode_spec. We should
21342 ignore its text properties. */
21343 it->stop_charpos = it->end_charpos;
21344
21345 /* If displaying STRING, set up the face of the iterator from
21346 FACE_STRING, if that's given. */
21347 if (STRINGP (face_string))
21348 {
21349 ptrdiff_t endptr;
21350 struct face *face;
21351
21352 it->face_id
21353 = face_at_string_position (it->w, face_string, face_string_pos,
21354 0, it->region_beg_charpos,
21355 it->region_end_charpos,
21356 &endptr, it->base_face_id, 0);
21357 face = FACE_FROM_ID (it->f, it->face_id);
21358 it->face_box_p = face->box != FACE_NO_BOX;
21359 }
21360
21361 /* Set max_x to the maximum allowed X position. Don't let it go
21362 beyond the right edge of the window. */
21363 if (max_x <= 0)
21364 max_x = it->last_visible_x;
21365 else
21366 max_x = min (max_x, it->last_visible_x);
21367
21368 /* Skip over display elements that are not visible. because IT->w is
21369 hscrolled. */
21370 if (it->current_x < it->first_visible_x)
21371 move_it_in_display_line_to (it, 100000, it->first_visible_x,
21372 MOVE_TO_POS | MOVE_TO_X);
21373
21374 row->ascent = it->max_ascent;
21375 row->height = it->max_ascent + it->max_descent;
21376 row->phys_ascent = it->max_phys_ascent;
21377 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
21378 row->extra_line_spacing = it->max_extra_line_spacing;
21379
21380 if (STRINGP (it->string))
21381 it_charpos = IT_STRING_CHARPOS (*it);
21382 else
21383 it_charpos = IT_CHARPOS (*it);
21384
21385 /* This condition is for the case that we are called with current_x
21386 past last_visible_x. */
21387 while (it->current_x < max_x)
21388 {
21389 int x_before, x, n_glyphs_before, i, nglyphs;
21390
21391 /* Get the next display element. */
21392 if (!get_next_display_element (it))
21393 break;
21394
21395 /* Produce glyphs. */
21396 x_before = it->current_x;
21397 n_glyphs_before = row->used[TEXT_AREA];
21398 PRODUCE_GLYPHS (it);
21399
21400 nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
21401 i = 0;
21402 x = x_before;
21403 while (i < nglyphs)
21404 {
21405 struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
21406
21407 if (it->line_wrap != TRUNCATE
21408 && x + glyph->pixel_width > max_x)
21409 {
21410 /* End of continued line or max_x reached. */
21411 if (CHAR_GLYPH_PADDING_P (*glyph))
21412 {
21413 /* A wide character is unbreakable. */
21414 if (row->reversed_p)
21415 unproduce_glyphs (it, row->used[TEXT_AREA]
21416 - n_glyphs_before);
21417 row->used[TEXT_AREA] = n_glyphs_before;
21418 it->current_x = x_before;
21419 }
21420 else
21421 {
21422 if (row->reversed_p)
21423 unproduce_glyphs (it, row->used[TEXT_AREA]
21424 - (n_glyphs_before + i));
21425 row->used[TEXT_AREA] = n_glyphs_before + i;
21426 it->current_x = x;
21427 }
21428 break;
21429 }
21430 else if (x + glyph->pixel_width >= it->first_visible_x)
21431 {
21432 /* Glyph is at least partially visible. */
21433 ++it->hpos;
21434 if (x < it->first_visible_x)
21435 row->x = x - it->first_visible_x;
21436 }
21437 else
21438 {
21439 /* Glyph is off the left margin of the display area.
21440 Should not happen. */
21441 abort ();
21442 }
21443
21444 row->ascent = max (row->ascent, it->max_ascent);
21445 row->height = max (row->height, it->max_ascent + it->max_descent);
21446 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
21447 row->phys_height = max (row->phys_height,
21448 it->max_phys_ascent + it->max_phys_descent);
21449 row->extra_line_spacing = max (row->extra_line_spacing,
21450 it->max_extra_line_spacing);
21451 x += glyph->pixel_width;
21452 ++i;
21453 }
21454
21455 /* Stop if max_x reached. */
21456 if (i < nglyphs)
21457 break;
21458
21459 /* Stop at line ends. */
21460 if (ITERATOR_AT_END_OF_LINE_P (it))
21461 {
21462 it->continuation_lines_width = 0;
21463 break;
21464 }
21465
21466 set_iterator_to_next (it, 1);
21467 if (STRINGP (it->string))
21468 it_charpos = IT_STRING_CHARPOS (*it);
21469 else
21470 it_charpos = IT_CHARPOS (*it);
21471
21472 /* Stop if truncating at the right edge. */
21473 if (it->line_wrap == TRUNCATE
21474 && it->current_x >= it->last_visible_x)
21475 {
21476 /* Add truncation mark, but don't do it if the line is
21477 truncated at a padding space. */
21478 if (it_charpos < it->string_nchars)
21479 {
21480 if (!FRAME_WINDOW_P (it->f))
21481 {
21482 int ii, n;
21483
21484 if (it->current_x > it->last_visible_x)
21485 {
21486 if (!row->reversed_p)
21487 {
21488 for (ii = row->used[TEXT_AREA] - 1; ii > 0; --ii)
21489 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
21490 break;
21491 }
21492 else
21493 {
21494 for (ii = 0; ii < row->used[TEXT_AREA]; ii++)
21495 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
21496 break;
21497 unproduce_glyphs (it, ii + 1);
21498 ii = row->used[TEXT_AREA] - (ii + 1);
21499 }
21500 for (n = row->used[TEXT_AREA]; ii < n; ++ii)
21501 {
21502 row->used[TEXT_AREA] = ii;
21503 produce_special_glyphs (it, IT_TRUNCATION);
21504 }
21505 }
21506 produce_special_glyphs (it, IT_TRUNCATION);
21507 }
21508 row->truncated_on_right_p = 1;
21509 }
21510 break;
21511 }
21512 }
21513
21514 /* Maybe insert a truncation at the left. */
21515 if (it->first_visible_x
21516 && it_charpos > 0)
21517 {
21518 if (!FRAME_WINDOW_P (it->f))
21519 insert_left_trunc_glyphs (it);
21520 row->truncated_on_left_p = 1;
21521 }
21522
21523 it->face_id = saved_face_id;
21524
21525 /* Value is number of columns displayed. */
21526 return it->hpos - hpos_at_start;
21527 }
21528
21529
21530 \f
21531 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
21532 appears as an element of LIST or as the car of an element of LIST.
21533 If PROPVAL is a list, compare each element against LIST in that
21534 way, and return 1/2 if any element of PROPVAL is found in LIST.
21535 Otherwise return 0. This function cannot quit.
21536 The return value is 2 if the text is invisible but with an ellipsis
21537 and 1 if it's invisible and without an ellipsis. */
21538
21539 int
21540 invisible_p (register Lisp_Object propval, Lisp_Object list)
21541 {
21542 register Lisp_Object tail, proptail;
21543
21544 for (tail = list; CONSP (tail); tail = XCDR (tail))
21545 {
21546 register Lisp_Object tem;
21547 tem = XCAR (tail);
21548 if (EQ (propval, tem))
21549 return 1;
21550 if (CONSP (tem) && EQ (propval, XCAR (tem)))
21551 return NILP (XCDR (tem)) ? 1 : 2;
21552 }
21553
21554 if (CONSP (propval))
21555 {
21556 for (proptail = propval; CONSP (proptail); proptail = XCDR (proptail))
21557 {
21558 Lisp_Object propelt;
21559 propelt = XCAR (proptail);
21560 for (tail = list; CONSP (tail); tail = XCDR (tail))
21561 {
21562 register Lisp_Object tem;
21563 tem = XCAR (tail);
21564 if (EQ (propelt, tem))
21565 return 1;
21566 if (CONSP (tem) && EQ (propelt, XCAR (tem)))
21567 return NILP (XCDR (tem)) ? 1 : 2;
21568 }
21569 }
21570 }
21571
21572 return 0;
21573 }
21574
21575 DEFUN ("invisible-p", Finvisible_p, Sinvisible_p, 1, 1, 0,
21576 doc: /* Non-nil if the property makes the text invisible.
21577 POS-OR-PROP can be a marker or number, in which case it is taken to be
21578 a position in the current buffer and the value of the `invisible' property
21579 is checked; or it can be some other value, which is then presumed to be the
21580 value of the `invisible' property of the text of interest.
21581 The non-nil value returned can be t for truly invisible text or something
21582 else if the text is replaced by an ellipsis. */)
21583 (Lisp_Object pos_or_prop)
21584 {
21585 Lisp_Object prop
21586 = (NATNUMP (pos_or_prop) || MARKERP (pos_or_prop)
21587 ? Fget_char_property (pos_or_prop, Qinvisible, Qnil)
21588 : pos_or_prop);
21589 int invis = TEXT_PROP_MEANS_INVISIBLE (prop);
21590 return (invis == 0 ? Qnil
21591 : invis == 1 ? Qt
21592 : make_number (invis));
21593 }
21594
21595 /* Calculate a width or height in pixels from a specification using
21596 the following elements:
21597
21598 SPEC ::=
21599 NUM - a (fractional) multiple of the default font width/height
21600 (NUM) - specifies exactly NUM pixels
21601 UNIT - a fixed number of pixels, see below.
21602 ELEMENT - size of a display element in pixels, see below.
21603 (NUM . SPEC) - equals NUM * SPEC
21604 (+ SPEC SPEC ...) - add pixel values
21605 (- SPEC SPEC ...) - subtract pixel values
21606 (- SPEC) - negate pixel value
21607
21608 NUM ::=
21609 INT or FLOAT - a number constant
21610 SYMBOL - use symbol's (buffer local) variable binding.
21611
21612 UNIT ::=
21613 in - pixels per inch *)
21614 mm - pixels per 1/1000 meter *)
21615 cm - pixels per 1/100 meter *)
21616 width - width of current font in pixels.
21617 height - height of current font in pixels.
21618
21619 *) using the ratio(s) defined in display-pixels-per-inch.
21620
21621 ELEMENT ::=
21622
21623 left-fringe - left fringe width in pixels
21624 right-fringe - right fringe width in pixels
21625
21626 left-margin - left margin width in pixels
21627 right-margin - right margin width in pixels
21628
21629 scroll-bar - scroll-bar area width in pixels
21630
21631 Examples:
21632
21633 Pixels corresponding to 5 inches:
21634 (5 . in)
21635
21636 Total width of non-text areas on left side of window (if scroll-bar is on left):
21637 '(space :width (+ left-fringe left-margin scroll-bar))
21638
21639 Align to first text column (in header line):
21640 '(space :align-to 0)
21641
21642 Align to middle of text area minus half the width of variable `my-image'
21643 containing a loaded image:
21644 '(space :align-to (0.5 . (- text my-image)))
21645
21646 Width of left margin minus width of 1 character in the default font:
21647 '(space :width (- left-margin 1))
21648
21649 Width of left margin minus width of 2 characters in the current font:
21650 '(space :width (- left-margin (2 . width)))
21651
21652 Center 1 character over left-margin (in header line):
21653 '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
21654
21655 Different ways to express width of left fringe plus left margin minus one pixel:
21656 '(space :width (- (+ left-fringe left-margin) (1)))
21657 '(space :width (+ left-fringe left-margin (- (1))))
21658 '(space :width (+ left-fringe left-margin (-1)))
21659
21660 */
21661
21662 #define NUMVAL(X) \
21663 ((INTEGERP (X) || FLOATP (X)) \
21664 ? XFLOATINT (X) \
21665 : - 1)
21666
21667 static int
21668 calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
21669 struct font *font, int width_p, int *align_to)
21670 {
21671 double pixels;
21672
21673 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
21674 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
21675
21676 if (NILP (prop))
21677 return OK_PIXELS (0);
21678
21679 xassert (FRAME_LIVE_P (it->f));
21680
21681 if (SYMBOLP (prop))
21682 {
21683 if (SCHARS (SYMBOL_NAME (prop)) == 2)
21684 {
21685 char *unit = SSDATA (SYMBOL_NAME (prop));
21686
21687 if (unit[0] == 'i' && unit[1] == 'n')
21688 pixels = 1.0;
21689 else if (unit[0] == 'm' && unit[1] == 'm')
21690 pixels = 25.4;
21691 else if (unit[0] == 'c' && unit[1] == 'm')
21692 pixels = 2.54;
21693 else
21694 pixels = 0;
21695 if (pixels > 0)
21696 {
21697 double ppi;
21698 #ifdef HAVE_WINDOW_SYSTEM
21699 if (FRAME_WINDOW_P (it->f)
21700 && (ppi = (width_p
21701 ? FRAME_X_DISPLAY_INFO (it->f)->resx
21702 : FRAME_X_DISPLAY_INFO (it->f)->resy),
21703 ppi > 0))
21704 return OK_PIXELS (ppi / pixels);
21705 #endif
21706
21707 if ((ppi = NUMVAL (Vdisplay_pixels_per_inch), ppi > 0)
21708 || (CONSP (Vdisplay_pixels_per_inch)
21709 && (ppi = (width_p
21710 ? NUMVAL (XCAR (Vdisplay_pixels_per_inch))
21711 : NUMVAL (XCDR (Vdisplay_pixels_per_inch))),
21712 ppi > 0)))
21713 return OK_PIXELS (ppi / pixels);
21714
21715 return 0;
21716 }
21717 }
21718
21719 #ifdef HAVE_WINDOW_SYSTEM
21720 if (EQ (prop, Qheight))
21721 return OK_PIXELS (font ? FONT_HEIGHT (font) : FRAME_LINE_HEIGHT (it->f));
21722 if (EQ (prop, Qwidth))
21723 return OK_PIXELS (font ? FONT_WIDTH (font) : FRAME_COLUMN_WIDTH (it->f));
21724 #else
21725 if (EQ (prop, Qheight) || EQ (prop, Qwidth))
21726 return OK_PIXELS (1);
21727 #endif
21728
21729 if (EQ (prop, Qtext))
21730 return OK_PIXELS (width_p
21731 ? window_box_width (it->w, TEXT_AREA)
21732 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w));
21733
21734 if (align_to && *align_to < 0)
21735 {
21736 *res = 0;
21737 if (EQ (prop, Qleft))
21738 return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA));
21739 if (EQ (prop, Qright))
21740 return OK_ALIGN_TO (window_box_right_offset (it->w, TEXT_AREA));
21741 if (EQ (prop, Qcenter))
21742 return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
21743 + window_box_width (it->w, TEXT_AREA) / 2);
21744 if (EQ (prop, Qleft_fringe))
21745 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
21746 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it->w)
21747 : window_box_right_offset (it->w, LEFT_MARGIN_AREA));
21748 if (EQ (prop, Qright_fringe))
21749 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
21750 ? window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
21751 : window_box_right_offset (it->w, TEXT_AREA));
21752 if (EQ (prop, Qleft_margin))
21753 return OK_ALIGN_TO (window_box_left_offset (it->w, LEFT_MARGIN_AREA));
21754 if (EQ (prop, Qright_margin))
21755 return OK_ALIGN_TO (window_box_left_offset (it->w, RIGHT_MARGIN_AREA));
21756 if (EQ (prop, Qscroll_bar))
21757 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it->w)
21758 ? 0
21759 : (window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
21760 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
21761 ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
21762 : 0)));
21763 }
21764 else
21765 {
21766 if (EQ (prop, Qleft_fringe))
21767 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it->w));
21768 if (EQ (prop, Qright_fringe))
21769 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it->w));
21770 if (EQ (prop, Qleft_margin))
21771 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it->w));
21772 if (EQ (prop, Qright_margin))
21773 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it->w));
21774 if (EQ (prop, Qscroll_bar))
21775 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
21776 }
21777
21778 prop = Fbuffer_local_value (prop, it->w->buffer);
21779 }
21780
21781 if (INTEGERP (prop) || FLOATP (prop))
21782 {
21783 int base_unit = (width_p
21784 ? FRAME_COLUMN_WIDTH (it->f)
21785 : FRAME_LINE_HEIGHT (it->f));
21786 return OK_PIXELS (XFLOATINT (prop) * base_unit);
21787 }
21788
21789 if (CONSP (prop))
21790 {
21791 Lisp_Object car = XCAR (prop);
21792 Lisp_Object cdr = XCDR (prop);
21793
21794 if (SYMBOLP (car))
21795 {
21796 #ifdef HAVE_WINDOW_SYSTEM
21797 if (FRAME_WINDOW_P (it->f)
21798 && valid_image_p (prop))
21799 {
21800 ptrdiff_t id = lookup_image (it->f, prop);
21801 struct image *img = IMAGE_FROM_ID (it->f, id);
21802
21803 return OK_PIXELS (width_p ? img->width : img->height);
21804 }
21805 #endif
21806 if (EQ (car, Qplus) || EQ (car, Qminus))
21807 {
21808 int first = 1;
21809 double px;
21810
21811 pixels = 0;
21812 while (CONSP (cdr))
21813 {
21814 if (!calc_pixel_width_or_height (&px, it, XCAR (cdr),
21815 font, width_p, align_to))
21816 return 0;
21817 if (first)
21818 pixels = (EQ (car, Qplus) ? px : -px), first = 0;
21819 else
21820 pixels += px;
21821 cdr = XCDR (cdr);
21822 }
21823 if (EQ (car, Qminus))
21824 pixels = -pixels;
21825 return OK_PIXELS (pixels);
21826 }
21827
21828 car = Fbuffer_local_value (car, it->w->buffer);
21829 }
21830
21831 if (INTEGERP (car) || FLOATP (car))
21832 {
21833 double fact;
21834 pixels = XFLOATINT (car);
21835 if (NILP (cdr))
21836 return OK_PIXELS (pixels);
21837 if (calc_pixel_width_or_height (&fact, it, cdr,
21838 font, width_p, align_to))
21839 return OK_PIXELS (pixels * fact);
21840 return 0;
21841 }
21842
21843 return 0;
21844 }
21845
21846 return 0;
21847 }
21848
21849 \f
21850 /***********************************************************************
21851 Glyph Display
21852 ***********************************************************************/
21853
21854 #ifdef HAVE_WINDOW_SYSTEM
21855
21856 #if GLYPH_DEBUG
21857
21858 void
21859 dump_glyph_string (struct glyph_string *s)
21860 {
21861 fprintf (stderr, "glyph string\n");
21862 fprintf (stderr, " x, y, w, h = %d, %d, %d, %d\n",
21863 s->x, s->y, s->width, s->height);
21864 fprintf (stderr, " ybase = %d\n", s->ybase);
21865 fprintf (stderr, " hl = %d\n", s->hl);
21866 fprintf (stderr, " left overhang = %d, right = %d\n",
21867 s->left_overhang, s->right_overhang);
21868 fprintf (stderr, " nchars = %d\n", s->nchars);
21869 fprintf (stderr, " extends to end of line = %d\n",
21870 s->extends_to_end_of_line_p);
21871 fprintf (stderr, " font height = %d\n", FONT_HEIGHT (s->font));
21872 fprintf (stderr, " bg width = %d\n", s->background_width);
21873 }
21874
21875 #endif /* GLYPH_DEBUG */
21876
21877 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
21878 of XChar2b structures for S; it can't be allocated in
21879 init_glyph_string because it must be allocated via `alloca'. W
21880 is the window on which S is drawn. ROW and AREA are the glyph row
21881 and area within the row from which S is constructed. START is the
21882 index of the first glyph structure covered by S. HL is a
21883 face-override for drawing S. */
21884
21885 #ifdef HAVE_NTGUI
21886 #define OPTIONAL_HDC(hdc) HDC hdc,
21887 #define DECLARE_HDC(hdc) HDC hdc;
21888 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
21889 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
21890 #endif
21891
21892 #ifndef OPTIONAL_HDC
21893 #define OPTIONAL_HDC(hdc)
21894 #define DECLARE_HDC(hdc)
21895 #define ALLOCATE_HDC(hdc, f)
21896 #define RELEASE_HDC(hdc, f)
21897 #endif
21898
21899 static void
21900 init_glyph_string (struct glyph_string *s,
21901 OPTIONAL_HDC (hdc)
21902 XChar2b *char2b, struct window *w, struct glyph_row *row,
21903 enum glyph_row_area area, int start, enum draw_glyphs_face hl)
21904 {
21905 memset (s, 0, sizeof *s);
21906 s->w = w;
21907 s->f = XFRAME (w->frame);
21908 #ifdef HAVE_NTGUI
21909 s->hdc = hdc;
21910 #endif
21911 s->display = FRAME_X_DISPLAY (s->f);
21912 s->window = FRAME_X_WINDOW (s->f);
21913 s->char2b = char2b;
21914 s->hl = hl;
21915 s->row = row;
21916 s->area = area;
21917 s->first_glyph = row->glyphs[area] + start;
21918 s->height = row->height;
21919 s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
21920 s->ybase = s->y + row->ascent;
21921 }
21922
21923
21924 /* Append the list of glyph strings with head H and tail T to the list
21925 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
21926
21927 static inline void
21928 append_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
21929 struct glyph_string *h, struct glyph_string *t)
21930 {
21931 if (h)
21932 {
21933 if (*head)
21934 (*tail)->next = h;
21935 else
21936 *head = h;
21937 h->prev = *tail;
21938 *tail = t;
21939 }
21940 }
21941
21942
21943 /* Prepend the list of glyph strings with head H and tail T to the
21944 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
21945 result. */
21946
21947 static inline void
21948 prepend_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
21949 struct glyph_string *h, struct glyph_string *t)
21950 {
21951 if (h)
21952 {
21953 if (*head)
21954 (*head)->prev = t;
21955 else
21956 *tail = t;
21957 t->next = *head;
21958 *head = h;
21959 }
21960 }
21961
21962
21963 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
21964 Set *HEAD and *TAIL to the resulting list. */
21965
21966 static inline void
21967 append_glyph_string (struct glyph_string **head, struct glyph_string **tail,
21968 struct glyph_string *s)
21969 {
21970 s->next = s->prev = NULL;
21971 append_glyph_string_lists (head, tail, s, s);
21972 }
21973
21974
21975 /* Get face and two-byte form of character C in face FACE_ID on frame F.
21976 The encoding of C is returned in *CHAR2B. DISPLAY_P non-zero means
21977 make sure that X resources for the face returned are allocated.
21978 Value is a pointer to a realized face that is ready for display if
21979 DISPLAY_P is non-zero. */
21980
21981 static inline struct face *
21982 get_char_face_and_encoding (struct frame *f, int c, int face_id,
21983 XChar2b *char2b, int display_p)
21984 {
21985 struct face *face = FACE_FROM_ID (f, face_id);
21986
21987 if (face->font)
21988 {
21989 unsigned code = face->font->driver->encode_char (face->font, c);
21990
21991 if (code != FONT_INVALID_CODE)
21992 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
21993 else
21994 STORE_XCHAR2B (char2b, 0, 0);
21995 }
21996
21997 /* Make sure X resources of the face are allocated. */
21998 #ifdef HAVE_X_WINDOWS
21999 if (display_p)
22000 #endif
22001 {
22002 xassert (face != NULL);
22003 PREPARE_FACE_FOR_DISPLAY (f, face);
22004 }
22005
22006 return face;
22007 }
22008
22009
22010 /* Get face and two-byte form of character glyph GLYPH on frame F.
22011 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
22012 a pointer to a realized face that is ready for display. */
22013
22014 static inline struct face *
22015 get_glyph_face_and_encoding (struct frame *f, struct glyph *glyph,
22016 XChar2b *char2b, int *two_byte_p)
22017 {
22018 struct face *face;
22019
22020 xassert (glyph->type == CHAR_GLYPH);
22021 face = FACE_FROM_ID (f, glyph->face_id);
22022
22023 if (two_byte_p)
22024 *two_byte_p = 0;
22025
22026 if (face->font)
22027 {
22028 unsigned code;
22029
22030 if (CHAR_BYTE8_P (glyph->u.ch))
22031 code = CHAR_TO_BYTE8 (glyph->u.ch);
22032 else
22033 code = face->font->driver->encode_char (face->font, glyph->u.ch);
22034
22035 if (code != FONT_INVALID_CODE)
22036 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
22037 else
22038 STORE_XCHAR2B (char2b, 0, 0);
22039 }
22040
22041 /* Make sure X resources of the face are allocated. */
22042 xassert (face != NULL);
22043 PREPARE_FACE_FOR_DISPLAY (f, face);
22044 return face;
22045 }
22046
22047
22048 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
22049 Retunr 1 if FONT has a glyph for C, otherwise return 0. */
22050
22051 static inline int
22052 get_char_glyph_code (int c, struct font *font, XChar2b *char2b)
22053 {
22054 unsigned code;
22055
22056 if (CHAR_BYTE8_P (c))
22057 code = CHAR_TO_BYTE8 (c);
22058 else
22059 code = font->driver->encode_char (font, c);
22060
22061 if (code == FONT_INVALID_CODE)
22062 return 0;
22063 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
22064 return 1;
22065 }
22066
22067
22068 /* Fill glyph string S with composition components specified by S->cmp.
22069
22070 BASE_FACE is the base face of the composition.
22071 S->cmp_from is the index of the first component for S.
22072
22073 OVERLAPS non-zero means S should draw the foreground only, and use
22074 its physical height for clipping. See also draw_glyphs.
22075
22076 Value is the index of a component not in S. */
22077
22078 static int
22079 fill_composite_glyph_string (struct glyph_string *s, struct face *base_face,
22080 int overlaps)
22081 {
22082 int i;
22083 /* For all glyphs of this composition, starting at the offset
22084 S->cmp_from, until we reach the end of the definition or encounter a
22085 glyph that requires the different face, add it to S. */
22086 struct face *face;
22087
22088 xassert (s);
22089
22090 s->for_overlaps = overlaps;
22091 s->face = NULL;
22092 s->font = NULL;
22093 for (i = s->cmp_from; i < s->cmp->glyph_len; i++)
22094 {
22095 int c = COMPOSITION_GLYPH (s->cmp, i);
22096
22097 /* TAB in a composition means display glyphs with padding space
22098 on the left or right. */
22099 if (c != '\t')
22100 {
22101 int face_id = FACE_FOR_CHAR (s->f, base_face->ascii_face, c,
22102 -1, Qnil);
22103
22104 face = get_char_face_and_encoding (s->f, c, face_id,
22105 s->char2b + i, 1);
22106 if (face)
22107 {
22108 if (! s->face)
22109 {
22110 s->face = face;
22111 s->font = s->face->font;
22112 }
22113 else if (s->face != face)
22114 break;
22115 }
22116 }
22117 ++s->nchars;
22118 }
22119 s->cmp_to = i;
22120
22121 /* All glyph strings for the same composition has the same width,
22122 i.e. the width set for the first component of the composition. */
22123 s->width = s->first_glyph->pixel_width;
22124
22125 /* If the specified font could not be loaded, use the frame's
22126 default font, but record the fact that we couldn't load it in
22127 the glyph string so that we can draw rectangles for the
22128 characters of the glyph string. */
22129 if (s->font == NULL)
22130 {
22131 s->font_not_found_p = 1;
22132 s->font = FRAME_FONT (s->f);
22133 }
22134
22135 /* Adjust base line for subscript/superscript text. */
22136 s->ybase += s->first_glyph->voffset;
22137
22138 /* This glyph string must always be drawn with 16-bit functions. */
22139 s->two_byte_p = 1;
22140
22141 return s->cmp_to;
22142 }
22143
22144 static int
22145 fill_gstring_glyph_string (struct glyph_string *s, int face_id,
22146 int start, int end, int overlaps)
22147 {
22148 struct glyph *glyph, *last;
22149 Lisp_Object lgstring;
22150 int i;
22151
22152 s->for_overlaps = overlaps;
22153 glyph = s->row->glyphs[s->area] + start;
22154 last = s->row->glyphs[s->area] + end;
22155 s->cmp_id = glyph->u.cmp.id;
22156 s->cmp_from = glyph->slice.cmp.from;
22157 s->cmp_to = glyph->slice.cmp.to + 1;
22158 s->face = FACE_FROM_ID (s->f, face_id);
22159 lgstring = composition_gstring_from_id (s->cmp_id);
22160 s->font = XFONT_OBJECT (LGSTRING_FONT (lgstring));
22161 glyph++;
22162 while (glyph < last
22163 && glyph->u.cmp.automatic
22164 && glyph->u.cmp.id == s->cmp_id
22165 && s->cmp_to == glyph->slice.cmp.from)
22166 s->cmp_to = (glyph++)->slice.cmp.to + 1;
22167
22168 for (i = s->cmp_from; i < s->cmp_to; i++)
22169 {
22170 Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
22171 unsigned code = LGLYPH_CODE (lglyph);
22172
22173 STORE_XCHAR2B ((s->char2b + i), code >> 8, code & 0xFF);
22174 }
22175 s->width = composition_gstring_width (lgstring, s->cmp_from, s->cmp_to, NULL);
22176 return glyph - s->row->glyphs[s->area];
22177 }
22178
22179
22180 /* Fill glyph string S from a sequence glyphs for glyphless characters.
22181 See the comment of fill_glyph_string for arguments.
22182 Value is the index of the first glyph not in S. */
22183
22184
22185 static int
22186 fill_glyphless_glyph_string (struct glyph_string *s, int face_id,
22187 int start, int end, int overlaps)
22188 {
22189 struct glyph *glyph, *last;
22190 int voffset;
22191
22192 xassert (s->first_glyph->type == GLYPHLESS_GLYPH);
22193 s->for_overlaps = overlaps;
22194 glyph = s->row->glyphs[s->area] + start;
22195 last = s->row->glyphs[s->area] + end;
22196 voffset = glyph->voffset;
22197 s->face = FACE_FROM_ID (s->f, face_id);
22198 s->font = s->face->font;
22199 s->nchars = 1;
22200 s->width = glyph->pixel_width;
22201 glyph++;
22202 while (glyph < last
22203 && glyph->type == GLYPHLESS_GLYPH
22204 && glyph->voffset == voffset
22205 && glyph->face_id == face_id)
22206 {
22207 s->nchars++;
22208 s->width += glyph->pixel_width;
22209 glyph++;
22210 }
22211 s->ybase += voffset;
22212 return glyph - s->row->glyphs[s->area];
22213 }
22214
22215
22216 /* Fill glyph string S from a sequence of character glyphs.
22217
22218 FACE_ID is the face id of the string. START is the index of the
22219 first glyph to consider, END is the index of the last + 1.
22220 OVERLAPS non-zero means S should draw the foreground only, and use
22221 its physical height for clipping. See also draw_glyphs.
22222
22223 Value is the index of the first glyph not in S. */
22224
22225 static int
22226 fill_glyph_string (struct glyph_string *s, int face_id,
22227 int start, int end, int overlaps)
22228 {
22229 struct glyph *glyph, *last;
22230 int voffset;
22231 int glyph_not_available_p;
22232
22233 xassert (s->f == XFRAME (s->w->frame));
22234 xassert (s->nchars == 0);
22235 xassert (start >= 0 && end > start);
22236
22237 s->for_overlaps = overlaps;
22238 glyph = s->row->glyphs[s->area] + start;
22239 last = s->row->glyphs[s->area] + end;
22240 voffset = glyph->voffset;
22241 s->padding_p = glyph->padding_p;
22242 glyph_not_available_p = glyph->glyph_not_available_p;
22243
22244 while (glyph < last
22245 && glyph->type == CHAR_GLYPH
22246 && glyph->voffset == voffset
22247 /* Same face id implies same font, nowadays. */
22248 && glyph->face_id == face_id
22249 && glyph->glyph_not_available_p == glyph_not_available_p)
22250 {
22251 int two_byte_p;
22252
22253 s->face = get_glyph_face_and_encoding (s->f, glyph,
22254 s->char2b + s->nchars,
22255 &two_byte_p);
22256 s->two_byte_p = two_byte_p;
22257 ++s->nchars;
22258 xassert (s->nchars <= end - start);
22259 s->width += glyph->pixel_width;
22260 if (glyph++->padding_p != s->padding_p)
22261 break;
22262 }
22263
22264 s->font = s->face->font;
22265
22266 /* If the specified font could not be loaded, use the frame's font,
22267 but record the fact that we couldn't load it in
22268 S->font_not_found_p so that we can draw rectangles for the
22269 characters of the glyph string. */
22270 if (s->font == NULL || glyph_not_available_p)
22271 {
22272 s->font_not_found_p = 1;
22273 s->font = FRAME_FONT (s->f);
22274 }
22275
22276 /* Adjust base line for subscript/superscript text. */
22277 s->ybase += voffset;
22278
22279 xassert (s->face && s->face->gc);
22280 return glyph - s->row->glyphs[s->area];
22281 }
22282
22283
22284 /* Fill glyph string S from image glyph S->first_glyph. */
22285
22286 static void
22287 fill_image_glyph_string (struct glyph_string *s)
22288 {
22289 xassert (s->first_glyph->type == IMAGE_GLYPH);
22290 s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
22291 xassert (s->img);
22292 s->slice = s->first_glyph->slice.img;
22293 s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
22294 s->font = s->face->font;
22295 s->width = s->first_glyph->pixel_width;
22296
22297 /* Adjust base line for subscript/superscript text. */
22298 s->ybase += s->first_glyph->voffset;
22299 }
22300
22301
22302 /* Fill glyph string S from a sequence of stretch glyphs.
22303
22304 START is the index of the first glyph to consider,
22305 END is the index of the last + 1.
22306
22307 Value is the index of the first glyph not in S. */
22308
22309 static int
22310 fill_stretch_glyph_string (struct glyph_string *s, int start, int end)
22311 {
22312 struct glyph *glyph, *last;
22313 int voffset, face_id;
22314
22315 xassert (s->first_glyph->type == STRETCH_GLYPH);
22316
22317 glyph = s->row->glyphs[s->area] + start;
22318 last = s->row->glyphs[s->area] + end;
22319 face_id = glyph->face_id;
22320 s->face = FACE_FROM_ID (s->f, face_id);
22321 s->font = s->face->font;
22322 s->width = glyph->pixel_width;
22323 s->nchars = 1;
22324 voffset = glyph->voffset;
22325
22326 for (++glyph;
22327 (glyph < last
22328 && glyph->type == STRETCH_GLYPH
22329 && glyph->voffset == voffset
22330 && glyph->face_id == face_id);
22331 ++glyph)
22332 s->width += glyph->pixel_width;
22333
22334 /* Adjust base line for subscript/superscript text. */
22335 s->ybase += voffset;
22336
22337 /* The case that face->gc == 0 is handled when drawing the glyph
22338 string by calling PREPARE_FACE_FOR_DISPLAY. */
22339 xassert (s->face);
22340 return glyph - s->row->glyphs[s->area];
22341 }
22342
22343 static struct font_metrics *
22344 get_per_char_metric (struct font *font, XChar2b *char2b)
22345 {
22346 static struct font_metrics metrics;
22347 unsigned code = (XCHAR2B_BYTE1 (char2b) << 8) | XCHAR2B_BYTE2 (char2b);
22348
22349 if (! font || code == FONT_INVALID_CODE)
22350 return NULL;
22351 font->driver->text_extents (font, &code, 1, &metrics);
22352 return &metrics;
22353 }
22354
22355 /* EXPORT for RIF:
22356 Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
22357 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
22358 assumed to be zero. */
22359
22360 void
22361 x_get_glyph_overhangs (struct glyph *glyph, struct frame *f, int *left, int *right)
22362 {
22363 *left = *right = 0;
22364
22365 if (glyph->type == CHAR_GLYPH)
22366 {
22367 struct face *face;
22368 XChar2b char2b;
22369 struct font_metrics *pcm;
22370
22371 face = get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
22372 if (face->font && (pcm = get_per_char_metric (face->font, &char2b)))
22373 {
22374 if (pcm->rbearing > pcm->width)
22375 *right = pcm->rbearing - pcm->width;
22376 if (pcm->lbearing < 0)
22377 *left = -pcm->lbearing;
22378 }
22379 }
22380 else if (glyph->type == COMPOSITE_GLYPH)
22381 {
22382 if (! glyph->u.cmp.automatic)
22383 {
22384 struct composition *cmp = composition_table[glyph->u.cmp.id];
22385
22386 if (cmp->rbearing > cmp->pixel_width)
22387 *right = cmp->rbearing - cmp->pixel_width;
22388 if (cmp->lbearing < 0)
22389 *left = - cmp->lbearing;
22390 }
22391 else
22392 {
22393 Lisp_Object gstring = composition_gstring_from_id (glyph->u.cmp.id);
22394 struct font_metrics metrics;
22395
22396 composition_gstring_width (gstring, glyph->slice.cmp.from,
22397 glyph->slice.cmp.to + 1, &metrics);
22398 if (metrics.rbearing > metrics.width)
22399 *right = metrics.rbearing - metrics.width;
22400 if (metrics.lbearing < 0)
22401 *left = - metrics.lbearing;
22402 }
22403 }
22404 }
22405
22406
22407 /* Return the index of the first glyph preceding glyph string S that
22408 is overwritten by S because of S's left overhang. Value is -1
22409 if no glyphs are overwritten. */
22410
22411 static int
22412 left_overwritten (struct glyph_string *s)
22413 {
22414 int k;
22415
22416 if (s->left_overhang)
22417 {
22418 int x = 0, i;
22419 struct glyph *glyphs = s->row->glyphs[s->area];
22420 int first = s->first_glyph - glyphs;
22421
22422 for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
22423 x -= glyphs[i].pixel_width;
22424
22425 k = i + 1;
22426 }
22427 else
22428 k = -1;
22429
22430 return k;
22431 }
22432
22433
22434 /* Return the index of the first glyph preceding glyph string S that
22435 is overwriting S because of its right overhang. Value is -1 if no
22436 glyph in front of S overwrites S. */
22437
22438 static int
22439 left_overwriting (struct glyph_string *s)
22440 {
22441 int i, k, x;
22442 struct glyph *glyphs = s->row->glyphs[s->area];
22443 int first = s->first_glyph - glyphs;
22444
22445 k = -1;
22446 x = 0;
22447 for (i = first - 1; i >= 0; --i)
22448 {
22449 int left, right;
22450 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
22451 if (x + right > 0)
22452 k = i;
22453 x -= glyphs[i].pixel_width;
22454 }
22455
22456 return k;
22457 }
22458
22459
22460 /* Return the index of the last glyph following glyph string S that is
22461 overwritten by S because of S's right overhang. Value is -1 if
22462 no such glyph is found. */
22463
22464 static int
22465 right_overwritten (struct glyph_string *s)
22466 {
22467 int k = -1;
22468
22469 if (s->right_overhang)
22470 {
22471 int x = 0, i;
22472 struct glyph *glyphs = s->row->glyphs[s->area];
22473 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
22474 int end = s->row->used[s->area];
22475
22476 for (i = first; i < end && s->right_overhang > x; ++i)
22477 x += glyphs[i].pixel_width;
22478
22479 k = i;
22480 }
22481
22482 return k;
22483 }
22484
22485
22486 /* Return the index of the last glyph following glyph string S that
22487 overwrites S because of its left overhang. Value is negative
22488 if no such glyph is found. */
22489
22490 static int
22491 right_overwriting (struct glyph_string *s)
22492 {
22493 int i, k, x;
22494 int end = s->row->used[s->area];
22495 struct glyph *glyphs = s->row->glyphs[s->area];
22496 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
22497
22498 k = -1;
22499 x = 0;
22500 for (i = first; i < end; ++i)
22501 {
22502 int left, right;
22503 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
22504 if (x - left < 0)
22505 k = i;
22506 x += glyphs[i].pixel_width;
22507 }
22508
22509 return k;
22510 }
22511
22512
22513 /* Set background width of glyph string S. START is the index of the
22514 first glyph following S. LAST_X is the right-most x-position + 1
22515 in the drawing area. */
22516
22517 static inline void
22518 set_glyph_string_background_width (struct glyph_string *s, int start, int last_x)
22519 {
22520 /* If the face of this glyph string has to be drawn to the end of
22521 the drawing area, set S->extends_to_end_of_line_p. */
22522
22523 if (start == s->row->used[s->area]
22524 && s->area == TEXT_AREA
22525 && ((s->row->fill_line_p
22526 && (s->hl == DRAW_NORMAL_TEXT
22527 || s->hl == DRAW_IMAGE_RAISED
22528 || s->hl == DRAW_IMAGE_SUNKEN))
22529 || s->hl == DRAW_MOUSE_FACE))
22530 s->extends_to_end_of_line_p = 1;
22531
22532 /* If S extends its face to the end of the line, set its
22533 background_width to the distance to the right edge of the drawing
22534 area. */
22535 if (s->extends_to_end_of_line_p)
22536 s->background_width = last_x - s->x + 1;
22537 else
22538 s->background_width = s->width;
22539 }
22540
22541
22542 /* Compute overhangs and x-positions for glyph string S and its
22543 predecessors, or successors. X is the starting x-position for S.
22544 BACKWARD_P non-zero means process predecessors. */
22545
22546 static void
22547 compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p)
22548 {
22549 if (backward_p)
22550 {
22551 while (s)
22552 {
22553 if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
22554 FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
22555 x -= s->width;
22556 s->x = x;
22557 s = s->prev;
22558 }
22559 }
22560 else
22561 {
22562 while (s)
22563 {
22564 if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
22565 FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
22566 s->x = x;
22567 x += s->width;
22568 s = s->next;
22569 }
22570 }
22571 }
22572
22573
22574
22575 /* The following macros are only called from draw_glyphs below.
22576 They reference the following parameters of that function directly:
22577 `w', `row', `area', and `overlap_p'
22578 as well as the following local variables:
22579 `s', `f', and `hdc' (in W32) */
22580
22581 #ifdef HAVE_NTGUI
22582 /* On W32, silently add local `hdc' variable to argument list of
22583 init_glyph_string. */
22584 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
22585 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
22586 #else
22587 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
22588 init_glyph_string (s, char2b, w, row, area, start, hl)
22589 #endif
22590
22591 /* Add a glyph string for a stretch glyph to the list of strings
22592 between HEAD and TAIL. START is the index of the stretch glyph in
22593 row area AREA of glyph row ROW. END is the index of the last glyph
22594 in that glyph row area. X is the current output position assigned
22595 to the new glyph string constructed. HL overrides that face of the
22596 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
22597 is the right-most x-position of the drawing area. */
22598
22599 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
22600 and below -- keep them on one line. */
22601 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22602 do \
22603 { \
22604 s = (struct glyph_string *) alloca (sizeof *s); \
22605 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
22606 START = fill_stretch_glyph_string (s, START, END); \
22607 append_glyph_string (&HEAD, &TAIL, s); \
22608 s->x = (X); \
22609 } \
22610 while (0)
22611
22612
22613 /* Add a glyph string for an image glyph to the list of strings
22614 between HEAD and TAIL. START is the index of the image glyph in
22615 row area AREA of glyph row ROW. END is the index of the last glyph
22616 in that glyph row area. X is the current output position assigned
22617 to the new glyph string constructed. HL overrides that face of the
22618 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
22619 is the right-most x-position of the drawing area. */
22620
22621 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22622 do \
22623 { \
22624 s = (struct glyph_string *) alloca (sizeof *s); \
22625 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
22626 fill_image_glyph_string (s); \
22627 append_glyph_string (&HEAD, &TAIL, s); \
22628 ++START; \
22629 s->x = (X); \
22630 } \
22631 while (0)
22632
22633
22634 /* Add a glyph string for a sequence of character glyphs to the list
22635 of strings between HEAD and TAIL. START is the index of the first
22636 glyph in row area AREA of glyph row ROW that is part of the new
22637 glyph string. END is the index of the last glyph in that glyph row
22638 area. X is the current output position assigned to the new glyph
22639 string constructed. HL overrides that face of the glyph; e.g. it
22640 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
22641 right-most x-position of the drawing area. */
22642
22643 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
22644 do \
22645 { \
22646 int face_id; \
22647 XChar2b *char2b; \
22648 \
22649 face_id = (row)->glyphs[area][START].face_id; \
22650 \
22651 s = (struct glyph_string *) alloca (sizeof *s); \
22652 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
22653 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
22654 append_glyph_string (&HEAD, &TAIL, s); \
22655 s->x = (X); \
22656 START = fill_glyph_string (s, face_id, START, END, overlaps); \
22657 } \
22658 while (0)
22659
22660
22661 /* Add a glyph string for a composite sequence to the list of strings
22662 between HEAD and TAIL. START is the index of the first glyph in
22663 row area AREA of glyph row ROW that is part of the new glyph
22664 string. END is the index of the last glyph in that glyph row area.
22665 X is the current output position assigned to the new glyph string
22666 constructed. HL overrides that face of the glyph; e.g. it is
22667 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
22668 x-position of the drawing area. */
22669
22670 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22671 do { \
22672 int face_id = (row)->glyphs[area][START].face_id; \
22673 struct face *base_face = FACE_FROM_ID (f, face_id); \
22674 ptrdiff_t cmp_id = (row)->glyphs[area][START].u.cmp.id; \
22675 struct composition *cmp = composition_table[cmp_id]; \
22676 XChar2b *char2b; \
22677 struct glyph_string *first_s IF_LINT (= NULL); \
22678 int n; \
22679 \
22680 char2b = (XChar2b *) alloca ((sizeof *char2b) * cmp->glyph_len); \
22681 \
22682 /* Make glyph_strings for each glyph sequence that is drawable by \
22683 the same face, and append them to HEAD/TAIL. */ \
22684 for (n = 0; n < cmp->glyph_len;) \
22685 { \
22686 s = (struct glyph_string *) alloca (sizeof *s); \
22687 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
22688 append_glyph_string (&(HEAD), &(TAIL), s); \
22689 s->cmp = cmp; \
22690 s->cmp_from = n; \
22691 s->x = (X); \
22692 if (n == 0) \
22693 first_s = s; \
22694 n = fill_composite_glyph_string (s, base_face, overlaps); \
22695 } \
22696 \
22697 ++START; \
22698 s = first_s; \
22699 } while (0)
22700
22701
22702 /* Add a glyph string for a glyph-string sequence to the list of strings
22703 between HEAD and TAIL. */
22704
22705 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22706 do { \
22707 int face_id; \
22708 XChar2b *char2b; \
22709 Lisp_Object gstring; \
22710 \
22711 face_id = (row)->glyphs[area][START].face_id; \
22712 gstring = (composition_gstring_from_id \
22713 ((row)->glyphs[area][START].u.cmp.id)); \
22714 s = (struct glyph_string *) alloca (sizeof *s); \
22715 char2b = (XChar2b *) alloca ((sizeof *char2b) \
22716 * LGSTRING_GLYPH_LEN (gstring)); \
22717 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
22718 append_glyph_string (&(HEAD), &(TAIL), s); \
22719 s->x = (X); \
22720 START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
22721 } while (0)
22722
22723
22724 /* Add a glyph string for a sequence of glyphless character's glyphs
22725 to the list of strings between HEAD and TAIL. The meanings of
22726 arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS. */
22727
22728 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22729 do \
22730 { \
22731 int face_id; \
22732 \
22733 face_id = (row)->glyphs[area][START].face_id; \
22734 \
22735 s = (struct glyph_string *) alloca (sizeof *s); \
22736 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
22737 append_glyph_string (&HEAD, &TAIL, s); \
22738 s->x = (X); \
22739 START = fill_glyphless_glyph_string (s, face_id, START, END, \
22740 overlaps); \
22741 } \
22742 while (0)
22743
22744
22745 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
22746 of AREA of glyph row ROW on window W between indices START and END.
22747 HL overrides the face for drawing glyph strings, e.g. it is
22748 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
22749 x-positions of the drawing area.
22750
22751 This is an ugly monster macro construct because we must use alloca
22752 to allocate glyph strings (because draw_glyphs can be called
22753 asynchronously). */
22754
22755 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
22756 do \
22757 { \
22758 HEAD = TAIL = NULL; \
22759 while (START < END) \
22760 { \
22761 struct glyph *first_glyph = (row)->glyphs[area] + START; \
22762 switch (first_glyph->type) \
22763 { \
22764 case CHAR_GLYPH: \
22765 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
22766 HL, X, LAST_X); \
22767 break; \
22768 \
22769 case COMPOSITE_GLYPH: \
22770 if (first_glyph->u.cmp.automatic) \
22771 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL, \
22772 HL, X, LAST_X); \
22773 else \
22774 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
22775 HL, X, LAST_X); \
22776 break; \
22777 \
22778 case STRETCH_GLYPH: \
22779 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
22780 HL, X, LAST_X); \
22781 break; \
22782 \
22783 case IMAGE_GLYPH: \
22784 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
22785 HL, X, LAST_X); \
22786 break; \
22787 \
22788 case GLYPHLESS_GLYPH: \
22789 BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL, \
22790 HL, X, LAST_X); \
22791 break; \
22792 \
22793 default: \
22794 abort (); \
22795 } \
22796 \
22797 if (s) \
22798 { \
22799 set_glyph_string_background_width (s, START, LAST_X); \
22800 (X) += s->width; \
22801 } \
22802 } \
22803 } while (0)
22804
22805
22806 /* Draw glyphs between START and END in AREA of ROW on window W,
22807 starting at x-position X. X is relative to AREA in W. HL is a
22808 face-override with the following meaning:
22809
22810 DRAW_NORMAL_TEXT draw normally
22811 DRAW_CURSOR draw in cursor face
22812 DRAW_MOUSE_FACE draw in mouse face.
22813 DRAW_INVERSE_VIDEO draw in mode line face
22814 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
22815 DRAW_IMAGE_RAISED draw an image with a raised relief around it
22816
22817 If OVERLAPS is non-zero, draw only the foreground of characters and
22818 clip to the physical height of ROW. Non-zero value also defines
22819 the overlapping part to be drawn:
22820
22821 OVERLAPS_PRED overlap with preceding rows
22822 OVERLAPS_SUCC overlap with succeeding rows
22823 OVERLAPS_BOTH overlap with both preceding/succeeding rows
22824 OVERLAPS_ERASED_CURSOR overlap with erased cursor area
22825
22826 Value is the x-position reached, relative to AREA of W. */
22827
22828 static int
22829 draw_glyphs (struct window *w, int x, struct glyph_row *row,
22830 enum glyph_row_area area, ptrdiff_t start, ptrdiff_t end,
22831 enum draw_glyphs_face hl, int overlaps)
22832 {
22833 struct glyph_string *head, *tail;
22834 struct glyph_string *s;
22835 struct glyph_string *clip_head = NULL, *clip_tail = NULL;
22836 int i, j, x_reached, last_x, area_left = 0;
22837 struct frame *f = XFRAME (WINDOW_FRAME (w));
22838 DECLARE_HDC (hdc);
22839
22840 ALLOCATE_HDC (hdc, f);
22841
22842 /* Let's rather be paranoid than getting a SEGV. */
22843 end = min (end, row->used[area]);
22844 start = max (0, start);
22845 start = min (end, start);
22846
22847 /* Translate X to frame coordinates. Set last_x to the right
22848 end of the drawing area. */
22849 if (row->full_width_p)
22850 {
22851 /* X is relative to the left edge of W, without scroll bars
22852 or fringes. */
22853 area_left = WINDOW_LEFT_EDGE_X (w);
22854 last_x = WINDOW_LEFT_EDGE_X (w) + WINDOW_TOTAL_WIDTH (w);
22855 }
22856 else
22857 {
22858 area_left = window_box_left (w, area);
22859 last_x = area_left + window_box_width (w, area);
22860 }
22861 x += area_left;
22862
22863 /* Build a doubly-linked list of glyph_string structures between
22864 head and tail from what we have to draw. Note that the macro
22865 BUILD_GLYPH_STRINGS will modify its start parameter. That's
22866 the reason we use a separate variable `i'. */
22867 i = start;
22868 BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
22869 if (tail)
22870 x_reached = tail->x + tail->background_width;
22871 else
22872 x_reached = x;
22873
22874 /* If there are any glyphs with lbearing < 0 or rbearing > width in
22875 the row, redraw some glyphs in front or following the glyph
22876 strings built above. */
22877 if (head && !overlaps && row->contains_overlapping_glyphs_p)
22878 {
22879 struct glyph_string *h, *t;
22880 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
22881 int mouse_beg_col IF_LINT (= 0), mouse_end_col IF_LINT (= 0);
22882 int check_mouse_face = 0;
22883 int dummy_x = 0;
22884
22885 /* If mouse highlighting is on, we may need to draw adjacent
22886 glyphs using mouse-face highlighting. */
22887 if (area == TEXT_AREA && row->mouse_face_p)
22888 {
22889 struct glyph_row *mouse_beg_row, *mouse_end_row;
22890
22891 mouse_beg_row = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_beg_row);
22892 mouse_end_row = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_end_row);
22893
22894 if (row >= mouse_beg_row && row <= mouse_end_row)
22895 {
22896 check_mouse_face = 1;
22897 mouse_beg_col = (row == mouse_beg_row)
22898 ? hlinfo->mouse_face_beg_col : 0;
22899 mouse_end_col = (row == mouse_end_row)
22900 ? hlinfo->mouse_face_end_col
22901 : row->used[TEXT_AREA];
22902 }
22903 }
22904
22905 /* Compute overhangs for all glyph strings. */
22906 if (FRAME_RIF (f)->compute_glyph_string_overhangs)
22907 for (s = head; s; s = s->next)
22908 FRAME_RIF (f)->compute_glyph_string_overhangs (s);
22909
22910 /* Prepend glyph strings for glyphs in front of the first glyph
22911 string that are overwritten because of the first glyph
22912 string's left overhang. The background of all strings
22913 prepended must be drawn because the first glyph string
22914 draws over it. */
22915 i = left_overwritten (head);
22916 if (i >= 0)
22917 {
22918 enum draw_glyphs_face overlap_hl;
22919
22920 /* If this row contains mouse highlighting, attempt to draw
22921 the overlapped glyphs with the correct highlight. This
22922 code fails if the overlap encompasses more than one glyph
22923 and mouse-highlight spans only some of these glyphs.
22924 However, making it work perfectly involves a lot more
22925 code, and I don't know if the pathological case occurs in
22926 practice, so we'll stick to this for now. --- cyd */
22927 if (check_mouse_face
22928 && mouse_beg_col < start && mouse_end_col > i)
22929 overlap_hl = DRAW_MOUSE_FACE;
22930 else
22931 overlap_hl = DRAW_NORMAL_TEXT;
22932
22933 j = i;
22934 BUILD_GLYPH_STRINGS (j, start, h, t,
22935 overlap_hl, dummy_x, last_x);
22936 start = i;
22937 compute_overhangs_and_x (t, head->x, 1);
22938 prepend_glyph_string_lists (&head, &tail, h, t);
22939 clip_head = head;
22940 }
22941
22942 /* Prepend glyph strings for glyphs in front of the first glyph
22943 string that overwrite that glyph string because of their
22944 right overhang. For these strings, only the foreground must
22945 be drawn, because it draws over the glyph string at `head'.
22946 The background must not be drawn because this would overwrite
22947 right overhangs of preceding glyphs for which no glyph
22948 strings exist. */
22949 i = left_overwriting (head);
22950 if (i >= 0)
22951 {
22952 enum draw_glyphs_face overlap_hl;
22953
22954 if (check_mouse_face
22955 && mouse_beg_col < start && mouse_end_col > i)
22956 overlap_hl = DRAW_MOUSE_FACE;
22957 else
22958 overlap_hl = DRAW_NORMAL_TEXT;
22959
22960 clip_head = head;
22961 BUILD_GLYPH_STRINGS (i, start, h, t,
22962 overlap_hl, dummy_x, last_x);
22963 for (s = h; s; s = s->next)
22964 s->background_filled_p = 1;
22965 compute_overhangs_and_x (t, head->x, 1);
22966 prepend_glyph_string_lists (&head, &tail, h, t);
22967 }
22968
22969 /* Append glyphs strings for glyphs following the last glyph
22970 string tail that are overwritten by tail. The background of
22971 these strings has to be drawn because tail's foreground draws
22972 over it. */
22973 i = right_overwritten (tail);
22974 if (i >= 0)
22975 {
22976 enum draw_glyphs_face overlap_hl;
22977
22978 if (check_mouse_face
22979 && mouse_beg_col < i && mouse_end_col > end)
22980 overlap_hl = DRAW_MOUSE_FACE;
22981 else
22982 overlap_hl = DRAW_NORMAL_TEXT;
22983
22984 BUILD_GLYPH_STRINGS (end, i, h, t,
22985 overlap_hl, x, last_x);
22986 /* Because BUILD_GLYPH_STRINGS updates the first argument,
22987 we don't have `end = i;' here. */
22988 compute_overhangs_and_x (h, tail->x + tail->width, 0);
22989 append_glyph_string_lists (&head, &tail, h, t);
22990 clip_tail = tail;
22991 }
22992
22993 /* Append glyph strings for glyphs following the last glyph
22994 string tail that overwrite tail. The foreground of such
22995 glyphs has to be drawn because it writes into the background
22996 of tail. The background must not be drawn because it could
22997 paint over the foreground of following glyphs. */
22998 i = right_overwriting (tail);
22999 if (i >= 0)
23000 {
23001 enum draw_glyphs_face overlap_hl;
23002 if (check_mouse_face
23003 && mouse_beg_col < i && mouse_end_col > end)
23004 overlap_hl = DRAW_MOUSE_FACE;
23005 else
23006 overlap_hl = DRAW_NORMAL_TEXT;
23007
23008 clip_tail = tail;
23009 i++; /* We must include the Ith glyph. */
23010 BUILD_GLYPH_STRINGS (end, i, h, t,
23011 overlap_hl, x, last_x);
23012 for (s = h; s; s = s->next)
23013 s->background_filled_p = 1;
23014 compute_overhangs_and_x (h, tail->x + tail->width, 0);
23015 append_glyph_string_lists (&head, &tail, h, t);
23016 }
23017 if (clip_head || clip_tail)
23018 for (s = head; s; s = s->next)
23019 {
23020 s->clip_head = clip_head;
23021 s->clip_tail = clip_tail;
23022 }
23023 }
23024
23025 /* Draw all strings. */
23026 for (s = head; s; s = s->next)
23027 FRAME_RIF (f)->draw_glyph_string (s);
23028
23029 #ifndef HAVE_NS
23030 /* When focus a sole frame and move horizontally, this sets on_p to 0
23031 causing a failure to erase prev cursor position. */
23032 if (area == TEXT_AREA
23033 && !row->full_width_p
23034 /* When drawing overlapping rows, only the glyph strings'
23035 foreground is drawn, which doesn't erase a cursor
23036 completely. */
23037 && !overlaps)
23038 {
23039 int x0 = clip_head ? clip_head->x : (head ? head->x : x);
23040 int x1 = (clip_tail ? clip_tail->x + clip_tail->background_width
23041 : (tail ? tail->x + tail->background_width : x));
23042 x0 -= area_left;
23043 x1 -= area_left;
23044
23045 notice_overwritten_cursor (w, TEXT_AREA, x0, x1,
23046 row->y, MATRIX_ROW_BOTTOM_Y (row));
23047 }
23048 #endif
23049
23050 /* Value is the x-position up to which drawn, relative to AREA of W.
23051 This doesn't include parts drawn because of overhangs. */
23052 if (row->full_width_p)
23053 x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
23054 else
23055 x_reached -= area_left;
23056
23057 RELEASE_HDC (hdc, f);
23058
23059 return x_reached;
23060 }
23061
23062 /* Expand row matrix if too narrow. Don't expand if area
23063 is not present. */
23064
23065 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
23066 { \
23067 if (!fonts_changed_p \
23068 && (it->glyph_row->glyphs[area] \
23069 < it->glyph_row->glyphs[area + 1])) \
23070 { \
23071 it->w->ncols_scale_factor++; \
23072 fonts_changed_p = 1; \
23073 } \
23074 }
23075
23076 /* Store one glyph for IT->char_to_display in IT->glyph_row.
23077 Called from x_produce_glyphs when IT->glyph_row is non-null. */
23078
23079 static inline void
23080 append_glyph (struct it *it)
23081 {
23082 struct glyph *glyph;
23083 enum glyph_row_area area = it->area;
23084
23085 xassert (it->glyph_row);
23086 xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
23087
23088 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
23089 if (glyph < it->glyph_row->glyphs[area + 1])
23090 {
23091 /* If the glyph row is reversed, we need to prepend the glyph
23092 rather than append it. */
23093 if (it->glyph_row->reversed_p && area == TEXT_AREA)
23094 {
23095 struct glyph *g;
23096
23097 /* Make room for the additional glyph. */
23098 for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
23099 g[1] = *g;
23100 glyph = it->glyph_row->glyphs[area];
23101 }
23102 glyph->charpos = CHARPOS (it->position);
23103 glyph->object = it->object;
23104 if (it->pixel_width > 0)
23105 {
23106 glyph->pixel_width = it->pixel_width;
23107 glyph->padding_p = 0;
23108 }
23109 else
23110 {
23111 /* Assure at least 1-pixel width. Otherwise, cursor can't
23112 be displayed correctly. */
23113 glyph->pixel_width = 1;
23114 glyph->padding_p = 1;
23115 }
23116 glyph->ascent = it->ascent;
23117 glyph->descent = it->descent;
23118 glyph->voffset = it->voffset;
23119 glyph->type = CHAR_GLYPH;
23120 glyph->avoid_cursor_p = it->avoid_cursor_p;
23121 glyph->multibyte_p = it->multibyte_p;
23122 glyph->left_box_line_p = it->start_of_box_run_p;
23123 glyph->right_box_line_p = it->end_of_box_run_p;
23124 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
23125 || it->phys_descent > it->descent);
23126 glyph->glyph_not_available_p = it->glyph_not_available_p;
23127 glyph->face_id = it->face_id;
23128 glyph->u.ch = it->char_to_display;
23129 glyph->slice.img = null_glyph_slice;
23130 glyph->font_type = FONT_TYPE_UNKNOWN;
23131 if (it->bidi_p)
23132 {
23133 glyph->resolved_level = it->bidi_it.resolved_level;
23134 if ((it->bidi_it.type & 7) != it->bidi_it.type)
23135 abort ();
23136 glyph->bidi_type = it->bidi_it.type;
23137 }
23138 else
23139 {
23140 glyph->resolved_level = 0;
23141 glyph->bidi_type = UNKNOWN_BT;
23142 }
23143 ++it->glyph_row->used[area];
23144 }
23145 else
23146 IT_EXPAND_MATRIX_WIDTH (it, area);
23147 }
23148
23149 /* Store one glyph for the composition IT->cmp_it.id in
23150 IT->glyph_row. Called from x_produce_glyphs when IT->glyph_row is
23151 non-null. */
23152
23153 static inline void
23154 append_composite_glyph (struct it *it)
23155 {
23156 struct glyph *glyph;
23157 enum glyph_row_area area = it->area;
23158
23159 xassert (it->glyph_row);
23160
23161 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
23162 if (glyph < it->glyph_row->glyphs[area + 1])
23163 {
23164 /* If the glyph row is reversed, we need to prepend the glyph
23165 rather than append it. */
23166 if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
23167 {
23168 struct glyph *g;
23169
23170 /* Make room for the new glyph. */
23171 for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
23172 g[1] = *g;
23173 glyph = it->glyph_row->glyphs[it->area];
23174 }
23175 glyph->charpos = it->cmp_it.charpos;
23176 glyph->object = it->object;
23177 glyph->pixel_width = it->pixel_width;
23178 glyph->ascent = it->ascent;
23179 glyph->descent = it->descent;
23180 glyph->voffset = it->voffset;
23181 glyph->type = COMPOSITE_GLYPH;
23182 if (it->cmp_it.ch < 0)
23183 {
23184 glyph->u.cmp.automatic = 0;
23185 glyph->u.cmp.id = it->cmp_it.id;
23186 glyph->slice.cmp.from = glyph->slice.cmp.to = 0;
23187 }
23188 else
23189 {
23190 glyph->u.cmp.automatic = 1;
23191 glyph->u.cmp.id = it->cmp_it.id;
23192 glyph->slice.cmp.from = it->cmp_it.from;
23193 glyph->slice.cmp.to = it->cmp_it.to - 1;
23194 }
23195 glyph->avoid_cursor_p = it->avoid_cursor_p;
23196 glyph->multibyte_p = it->multibyte_p;
23197 glyph->left_box_line_p = it->start_of_box_run_p;
23198 glyph->right_box_line_p = it->end_of_box_run_p;
23199 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
23200 || it->phys_descent > it->descent);
23201 glyph->padding_p = 0;
23202 glyph->glyph_not_available_p = 0;
23203 glyph->face_id = it->face_id;
23204 glyph->font_type = FONT_TYPE_UNKNOWN;
23205 if (it->bidi_p)
23206 {
23207 glyph->resolved_level = it->bidi_it.resolved_level;
23208 if ((it->bidi_it.type & 7) != it->bidi_it.type)
23209 abort ();
23210 glyph->bidi_type = it->bidi_it.type;
23211 }
23212 ++it->glyph_row->used[area];
23213 }
23214 else
23215 IT_EXPAND_MATRIX_WIDTH (it, area);
23216 }
23217
23218
23219 /* Change IT->ascent and IT->height according to the setting of
23220 IT->voffset. */
23221
23222 static inline void
23223 take_vertical_position_into_account (struct it *it)
23224 {
23225 if (it->voffset)
23226 {
23227 if (it->voffset < 0)
23228 /* Increase the ascent so that we can display the text higher
23229 in the line. */
23230 it->ascent -= it->voffset;
23231 else
23232 /* Increase the descent so that we can display the text lower
23233 in the line. */
23234 it->descent += it->voffset;
23235 }
23236 }
23237
23238
23239 /* Produce glyphs/get display metrics for the image IT is loaded with.
23240 See the description of struct display_iterator in dispextern.h for
23241 an overview of struct display_iterator. */
23242
23243 static void
23244 produce_image_glyph (struct it *it)
23245 {
23246 struct image *img;
23247 struct face *face;
23248 int glyph_ascent, crop;
23249 struct glyph_slice slice;
23250
23251 xassert (it->what == IT_IMAGE);
23252
23253 face = FACE_FROM_ID (it->f, it->face_id);
23254 xassert (face);
23255 /* Make sure X resources of the face is loaded. */
23256 PREPARE_FACE_FOR_DISPLAY (it->f, face);
23257
23258 if (it->image_id < 0)
23259 {
23260 /* Fringe bitmap. */
23261 it->ascent = it->phys_ascent = 0;
23262 it->descent = it->phys_descent = 0;
23263 it->pixel_width = 0;
23264 it->nglyphs = 0;
23265 return;
23266 }
23267
23268 img = IMAGE_FROM_ID (it->f, it->image_id);
23269 xassert (img);
23270 /* Make sure X resources of the image is loaded. */
23271 prepare_image_for_display (it->f, img);
23272
23273 slice.x = slice.y = 0;
23274 slice.width = img->width;
23275 slice.height = img->height;
23276
23277 if (INTEGERP (it->slice.x))
23278 slice.x = XINT (it->slice.x);
23279 else if (FLOATP (it->slice.x))
23280 slice.x = XFLOAT_DATA (it->slice.x) * img->width;
23281
23282 if (INTEGERP (it->slice.y))
23283 slice.y = XINT (it->slice.y);
23284 else if (FLOATP (it->slice.y))
23285 slice.y = XFLOAT_DATA (it->slice.y) * img->height;
23286
23287 if (INTEGERP (it->slice.width))
23288 slice.width = XINT (it->slice.width);
23289 else if (FLOATP (it->slice.width))
23290 slice.width = XFLOAT_DATA (it->slice.width) * img->width;
23291
23292 if (INTEGERP (it->slice.height))
23293 slice.height = XINT (it->slice.height);
23294 else if (FLOATP (it->slice.height))
23295 slice.height = XFLOAT_DATA (it->slice.height) * img->height;
23296
23297 if (slice.x >= img->width)
23298 slice.x = img->width;
23299 if (slice.y >= img->height)
23300 slice.y = img->height;
23301 if (slice.x + slice.width >= img->width)
23302 slice.width = img->width - slice.x;
23303 if (slice.y + slice.height > img->height)
23304 slice.height = img->height - slice.y;
23305
23306 if (slice.width == 0 || slice.height == 0)
23307 return;
23308
23309 it->ascent = it->phys_ascent = glyph_ascent = image_ascent (img, face, &slice);
23310
23311 it->descent = slice.height - glyph_ascent;
23312 if (slice.y == 0)
23313 it->descent += img->vmargin;
23314 if (slice.y + slice.height == img->height)
23315 it->descent += img->vmargin;
23316 it->phys_descent = it->descent;
23317
23318 it->pixel_width = slice.width;
23319 if (slice.x == 0)
23320 it->pixel_width += img->hmargin;
23321 if (slice.x + slice.width == img->width)
23322 it->pixel_width += img->hmargin;
23323
23324 /* It's quite possible for images to have an ascent greater than
23325 their height, so don't get confused in that case. */
23326 if (it->descent < 0)
23327 it->descent = 0;
23328
23329 it->nglyphs = 1;
23330
23331 if (face->box != FACE_NO_BOX)
23332 {
23333 if (face->box_line_width > 0)
23334 {
23335 if (slice.y == 0)
23336 it->ascent += face->box_line_width;
23337 if (slice.y + slice.height == img->height)
23338 it->descent += face->box_line_width;
23339 }
23340
23341 if (it->start_of_box_run_p && slice.x == 0)
23342 it->pixel_width += eabs (face->box_line_width);
23343 if (it->end_of_box_run_p && slice.x + slice.width == img->width)
23344 it->pixel_width += eabs (face->box_line_width);
23345 }
23346
23347 take_vertical_position_into_account (it);
23348
23349 /* Automatically crop wide image glyphs at right edge so we can
23350 draw the cursor on same display row. */
23351 if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0)
23352 && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
23353 {
23354 it->pixel_width -= crop;
23355 slice.width -= crop;
23356 }
23357
23358 if (it->glyph_row)
23359 {
23360 struct glyph *glyph;
23361 enum glyph_row_area area = it->area;
23362
23363 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
23364 if (glyph < it->glyph_row->glyphs[area + 1])
23365 {
23366 glyph->charpos = CHARPOS (it->position);
23367 glyph->object = it->object;
23368 glyph->pixel_width = it->pixel_width;
23369 glyph->ascent = glyph_ascent;
23370 glyph->descent = it->descent;
23371 glyph->voffset = it->voffset;
23372 glyph->type = IMAGE_GLYPH;
23373 glyph->avoid_cursor_p = it->avoid_cursor_p;
23374 glyph->multibyte_p = it->multibyte_p;
23375 glyph->left_box_line_p = it->start_of_box_run_p;
23376 glyph->right_box_line_p = it->end_of_box_run_p;
23377 glyph->overlaps_vertically_p = 0;
23378 glyph->padding_p = 0;
23379 glyph->glyph_not_available_p = 0;
23380 glyph->face_id = it->face_id;
23381 glyph->u.img_id = img->id;
23382 glyph->slice.img = slice;
23383 glyph->font_type = FONT_TYPE_UNKNOWN;
23384 if (it->bidi_p)
23385 {
23386 glyph->resolved_level = it->bidi_it.resolved_level;
23387 if ((it->bidi_it.type & 7) != it->bidi_it.type)
23388 abort ();
23389 glyph->bidi_type = it->bidi_it.type;
23390 }
23391 ++it->glyph_row->used[area];
23392 }
23393 else
23394 IT_EXPAND_MATRIX_WIDTH (it, area);
23395 }
23396 }
23397
23398
23399 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
23400 of the glyph, WIDTH and HEIGHT are the width and height of the
23401 stretch. ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT). */
23402
23403 static void
23404 append_stretch_glyph (struct it *it, Lisp_Object object,
23405 int width, int height, int ascent)
23406 {
23407 struct glyph *glyph;
23408 enum glyph_row_area area = it->area;
23409
23410 xassert (ascent >= 0 && ascent <= height);
23411
23412 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
23413 if (glyph < it->glyph_row->glyphs[area + 1])
23414 {
23415 /* If the glyph row is reversed, we need to prepend the glyph
23416 rather than append it. */
23417 if (it->glyph_row->reversed_p && area == TEXT_AREA)
23418 {
23419 struct glyph *g;
23420
23421 /* Make room for the additional glyph. */
23422 for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
23423 g[1] = *g;
23424 glyph = it->glyph_row->glyphs[area];
23425 }
23426 glyph->charpos = CHARPOS (it->position);
23427 glyph->object = object;
23428 glyph->pixel_width = width;
23429 glyph->ascent = ascent;
23430 glyph->descent = height - ascent;
23431 glyph->voffset = it->voffset;
23432 glyph->type = STRETCH_GLYPH;
23433 glyph->avoid_cursor_p = it->avoid_cursor_p;
23434 glyph->multibyte_p = it->multibyte_p;
23435 glyph->left_box_line_p = it->start_of_box_run_p;
23436 glyph->right_box_line_p = it->end_of_box_run_p;
23437 glyph->overlaps_vertically_p = 0;
23438 glyph->padding_p = 0;
23439 glyph->glyph_not_available_p = 0;
23440 glyph->face_id = it->face_id;
23441 glyph->u.stretch.ascent = ascent;
23442 glyph->u.stretch.height = height;
23443 glyph->slice.img = null_glyph_slice;
23444 glyph->font_type = FONT_TYPE_UNKNOWN;
23445 if (it->bidi_p)
23446 {
23447 glyph->resolved_level = it->bidi_it.resolved_level;
23448 if ((it->bidi_it.type & 7) != it->bidi_it.type)
23449 abort ();
23450 glyph->bidi_type = it->bidi_it.type;
23451 }
23452 else
23453 {
23454 glyph->resolved_level = 0;
23455 glyph->bidi_type = UNKNOWN_BT;
23456 }
23457 ++it->glyph_row->used[area];
23458 }
23459 else
23460 IT_EXPAND_MATRIX_WIDTH (it, area);
23461 }
23462
23463 #endif /* HAVE_WINDOW_SYSTEM */
23464
23465 /* Produce a stretch glyph for iterator IT. IT->object is the value
23466 of the glyph property displayed. The value must be a list
23467 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
23468 being recognized:
23469
23470 1. `:width WIDTH' specifies that the space should be WIDTH *
23471 canonical char width wide. WIDTH may be an integer or floating
23472 point number.
23473
23474 2. `:relative-width FACTOR' specifies that the width of the stretch
23475 should be computed from the width of the first character having the
23476 `glyph' property, and should be FACTOR times that width.
23477
23478 3. `:align-to HPOS' specifies that the space should be wide enough
23479 to reach HPOS, a value in canonical character units.
23480
23481 Exactly one of the above pairs must be present.
23482
23483 4. `:height HEIGHT' specifies that the height of the stretch produced
23484 should be HEIGHT, measured in canonical character units.
23485
23486 5. `:relative-height FACTOR' specifies that the height of the
23487 stretch should be FACTOR times the height of the characters having
23488 the glyph property.
23489
23490 Either none or exactly one of 4 or 5 must be present.
23491
23492 6. `:ascent ASCENT' specifies that ASCENT percent of the height
23493 of the stretch should be used for the ascent of the stretch.
23494 ASCENT must be in the range 0 <= ASCENT <= 100. */
23495
23496 void
23497 produce_stretch_glyph (struct it *it)
23498 {
23499 /* (space :width WIDTH :height HEIGHT ...) */
23500 Lisp_Object prop, plist;
23501 int width = 0, height = 0, align_to = -1;
23502 int zero_width_ok_p = 0;
23503 int ascent = 0;
23504 double tem;
23505 struct face *face = NULL;
23506 struct font *font = NULL;
23507
23508 #ifdef HAVE_WINDOW_SYSTEM
23509 int zero_height_ok_p = 0;
23510
23511 if (FRAME_WINDOW_P (it->f))
23512 {
23513 face = FACE_FROM_ID (it->f, it->face_id);
23514 font = face->font ? face->font : FRAME_FONT (it->f);
23515 PREPARE_FACE_FOR_DISPLAY (it->f, face);
23516 }
23517 #endif
23518
23519 /* List should start with `space'. */
23520 xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
23521 plist = XCDR (it->object);
23522
23523 /* Compute the width of the stretch. */
23524 if ((prop = Fplist_get (plist, QCwidth), !NILP (prop))
23525 && calc_pixel_width_or_height (&tem, it, prop, font, 1, 0))
23526 {
23527 /* Absolute width `:width WIDTH' specified and valid. */
23528 zero_width_ok_p = 1;
23529 width = (int)tem;
23530 }
23531 #ifdef HAVE_WINDOW_SYSTEM
23532 else if (FRAME_WINDOW_P (it->f)
23533 && (prop = Fplist_get (plist, QCrelative_width), NUMVAL (prop) > 0))
23534 {
23535 /* Relative width `:relative-width FACTOR' specified and valid.
23536 Compute the width of the characters having the `glyph'
23537 property. */
23538 struct it it2;
23539 unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
23540
23541 it2 = *it;
23542 if (it->multibyte_p)
23543 it2.c = it2.char_to_display = STRING_CHAR_AND_LENGTH (p, it2.len);
23544 else
23545 {
23546 it2.c = it2.char_to_display = *p, it2.len = 1;
23547 if (! ASCII_CHAR_P (it2.c))
23548 it2.char_to_display = BYTE8_TO_CHAR (it2.c);
23549 }
23550
23551 it2.glyph_row = NULL;
23552 it2.what = IT_CHARACTER;
23553 x_produce_glyphs (&it2);
23554 width = NUMVAL (prop) * it2.pixel_width;
23555 }
23556 #endif /* HAVE_WINDOW_SYSTEM */
23557 else if ((prop = Fplist_get (plist, QCalign_to), !NILP (prop))
23558 && calc_pixel_width_or_height (&tem, it, prop, font, 1, &align_to))
23559 {
23560 if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
23561 align_to = (align_to < 0
23562 ? 0
23563 : align_to - window_box_left_offset (it->w, TEXT_AREA));
23564 else if (align_to < 0)
23565 align_to = window_box_left_offset (it->w, TEXT_AREA);
23566 width = max (0, (int)tem + align_to - it->current_x);
23567 zero_width_ok_p = 1;
23568 }
23569 else
23570 /* Nothing specified -> width defaults to canonical char width. */
23571 width = FRAME_COLUMN_WIDTH (it->f);
23572
23573 if (width <= 0 && (width < 0 || !zero_width_ok_p))
23574 width = 1;
23575
23576 #ifdef HAVE_WINDOW_SYSTEM
23577 /* Compute height. */
23578 if (FRAME_WINDOW_P (it->f))
23579 {
23580 if ((prop = Fplist_get (plist, QCheight), !NILP (prop))
23581 && calc_pixel_width_or_height (&tem, it, prop, font, 0, 0))
23582 {
23583 height = (int)tem;
23584 zero_height_ok_p = 1;
23585 }
23586 else if (prop = Fplist_get (plist, QCrelative_height),
23587 NUMVAL (prop) > 0)
23588 height = FONT_HEIGHT (font) * NUMVAL (prop);
23589 else
23590 height = FONT_HEIGHT (font);
23591
23592 if (height <= 0 && (height < 0 || !zero_height_ok_p))
23593 height = 1;
23594
23595 /* Compute percentage of height used for ascent. If
23596 `:ascent ASCENT' is present and valid, use that. Otherwise,
23597 derive the ascent from the font in use. */
23598 if (prop = Fplist_get (plist, QCascent),
23599 NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
23600 ascent = height * NUMVAL (prop) / 100.0;
23601 else if (!NILP (prop)
23602 && calc_pixel_width_or_height (&tem, it, prop, font, 0, 0))
23603 ascent = min (max (0, (int)tem), height);
23604 else
23605 ascent = (height * FONT_BASE (font)) / FONT_HEIGHT (font);
23606 }
23607 else
23608 #endif /* HAVE_WINDOW_SYSTEM */
23609 height = 1;
23610
23611 if (width > 0 && it->line_wrap != TRUNCATE
23612 && it->current_x + width > it->last_visible_x)
23613 {
23614 width = it->last_visible_x - it->current_x;
23615 #ifdef HAVE_WINDOW_SYSTEM
23616 /* Subtact one more pixel from the stretch width, but only on
23617 GUI frames, since on a TTY each glyph is one "pixel" wide. */
23618 width -= FRAME_WINDOW_P (it->f);
23619 #endif
23620 }
23621
23622 if (width > 0 && height > 0 && it->glyph_row)
23623 {
23624 Lisp_Object o_object = it->object;
23625 Lisp_Object object = it->stack[it->sp - 1].string;
23626 int n = width;
23627
23628 if (!STRINGP (object))
23629 object = it->w->buffer;
23630 #ifdef HAVE_WINDOW_SYSTEM
23631 if (FRAME_WINDOW_P (it->f))
23632 append_stretch_glyph (it, object, width, height, ascent);
23633 else
23634 #endif
23635 {
23636 it->object = object;
23637 it->char_to_display = ' ';
23638 it->pixel_width = it->len = 1;
23639 while (n--)
23640 tty_append_glyph (it);
23641 it->object = o_object;
23642 }
23643 }
23644
23645 it->pixel_width = width;
23646 #ifdef HAVE_WINDOW_SYSTEM
23647 if (FRAME_WINDOW_P (it->f))
23648 {
23649 it->ascent = it->phys_ascent = ascent;
23650 it->descent = it->phys_descent = height - it->ascent;
23651 it->nglyphs = width > 0 && height > 0 ? 1 : 0;
23652 take_vertical_position_into_account (it);
23653 }
23654 else
23655 #endif
23656 it->nglyphs = width;
23657 }
23658
23659 #ifdef HAVE_WINDOW_SYSTEM
23660
23661 /* Calculate line-height and line-spacing properties.
23662 An integer value specifies explicit pixel value.
23663 A float value specifies relative value to current face height.
23664 A cons (float . face-name) specifies relative value to
23665 height of specified face font.
23666
23667 Returns height in pixels, or nil. */
23668
23669
23670 static Lisp_Object
23671 calc_line_height_property (struct it *it, Lisp_Object val, struct font *font,
23672 int boff, int override)
23673 {
23674 Lisp_Object face_name = Qnil;
23675 int ascent, descent, height;
23676
23677 if (NILP (val) || INTEGERP (val) || (override && EQ (val, Qt)))
23678 return val;
23679
23680 if (CONSP (val))
23681 {
23682 face_name = XCAR (val);
23683 val = XCDR (val);
23684 if (!NUMBERP (val))
23685 val = make_number (1);
23686 if (NILP (face_name))
23687 {
23688 height = it->ascent + it->descent;
23689 goto scale;
23690 }
23691 }
23692
23693 if (NILP (face_name))
23694 {
23695 font = FRAME_FONT (it->f);
23696 boff = FRAME_BASELINE_OFFSET (it->f);
23697 }
23698 else if (EQ (face_name, Qt))
23699 {
23700 override = 0;
23701 }
23702 else
23703 {
23704 int face_id;
23705 struct face *face;
23706
23707 face_id = lookup_named_face (it->f, face_name, 0);
23708 if (face_id < 0)
23709 return make_number (-1);
23710
23711 face = FACE_FROM_ID (it->f, face_id);
23712 font = face->font;
23713 if (font == NULL)
23714 return make_number (-1);
23715 boff = font->baseline_offset;
23716 if (font->vertical_centering)
23717 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
23718 }
23719
23720 ascent = FONT_BASE (font) + boff;
23721 descent = FONT_DESCENT (font) - boff;
23722
23723 if (override)
23724 {
23725 it->override_ascent = ascent;
23726 it->override_descent = descent;
23727 it->override_boff = boff;
23728 }
23729
23730 height = ascent + descent;
23731
23732 scale:
23733 if (FLOATP (val))
23734 height = (int)(XFLOAT_DATA (val) * height);
23735 else if (INTEGERP (val))
23736 height *= XINT (val);
23737
23738 return make_number (height);
23739 }
23740
23741
23742 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
23743 is a face ID to be used for the glyph. FOR_NO_FONT is nonzero if
23744 and only if this is for a character for which no font was found.
23745
23746 If the display method (it->glyphless_method) is
23747 GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
23748 length of the acronym or the hexadecimal string, UPPER_XOFF and
23749 UPPER_YOFF are pixel offsets for the upper part of the string,
23750 LOWER_XOFF and LOWER_YOFF are for the lower part.
23751
23752 For the other display methods, LEN through LOWER_YOFF are zero. */
23753
23754 static void
23755 append_glyphless_glyph (struct it *it, int face_id, int for_no_font, int len,
23756 short upper_xoff, short upper_yoff,
23757 short lower_xoff, short lower_yoff)
23758 {
23759 struct glyph *glyph;
23760 enum glyph_row_area area = it->area;
23761
23762 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
23763 if (glyph < it->glyph_row->glyphs[area + 1])
23764 {
23765 /* If the glyph row is reversed, we need to prepend the glyph
23766 rather than append it. */
23767 if (it->glyph_row->reversed_p && area == TEXT_AREA)
23768 {
23769 struct glyph *g;
23770
23771 /* Make room for the additional glyph. */
23772 for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
23773 g[1] = *g;
23774 glyph = it->glyph_row->glyphs[area];
23775 }
23776 glyph->charpos = CHARPOS (it->position);
23777 glyph->object = it->object;
23778 glyph->pixel_width = it->pixel_width;
23779 glyph->ascent = it->ascent;
23780 glyph->descent = it->descent;
23781 glyph->voffset = it->voffset;
23782 glyph->type = GLYPHLESS_GLYPH;
23783 glyph->u.glyphless.method = it->glyphless_method;
23784 glyph->u.glyphless.for_no_font = for_no_font;
23785 glyph->u.glyphless.len = len;
23786 glyph->u.glyphless.ch = it->c;
23787 glyph->slice.glyphless.upper_xoff = upper_xoff;
23788 glyph->slice.glyphless.upper_yoff = upper_yoff;
23789 glyph->slice.glyphless.lower_xoff = lower_xoff;
23790 glyph->slice.glyphless.lower_yoff = lower_yoff;
23791 glyph->avoid_cursor_p = it->avoid_cursor_p;
23792 glyph->multibyte_p = it->multibyte_p;
23793 glyph->left_box_line_p = it->start_of_box_run_p;
23794 glyph->right_box_line_p = it->end_of_box_run_p;
23795 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
23796 || it->phys_descent > it->descent);
23797 glyph->padding_p = 0;
23798 glyph->glyph_not_available_p = 0;
23799 glyph->face_id = face_id;
23800 glyph->font_type = FONT_TYPE_UNKNOWN;
23801 if (it->bidi_p)
23802 {
23803 glyph->resolved_level = it->bidi_it.resolved_level;
23804 if ((it->bidi_it.type & 7) != it->bidi_it.type)
23805 abort ();
23806 glyph->bidi_type = it->bidi_it.type;
23807 }
23808 ++it->glyph_row->used[area];
23809 }
23810 else
23811 IT_EXPAND_MATRIX_WIDTH (it, area);
23812 }
23813
23814
23815 /* Produce a glyph for a glyphless character for iterator IT.
23816 IT->glyphless_method specifies which method to use for displaying
23817 the character. See the description of enum
23818 glyphless_display_method in dispextern.h for the detail.
23819
23820 FOR_NO_FONT is nonzero if and only if this is for a character for
23821 which no font was found. ACRONYM, if non-nil, is an acronym string
23822 for the character. */
23823
23824 static void
23825 produce_glyphless_glyph (struct it *it, int for_no_font, Lisp_Object acronym)
23826 {
23827 int face_id;
23828 struct face *face;
23829 struct font *font;
23830 int base_width, base_height, width, height;
23831 short upper_xoff, upper_yoff, lower_xoff, lower_yoff;
23832 int len;
23833
23834 /* Get the metrics of the base font. We always refer to the current
23835 ASCII face. */
23836 face = FACE_FROM_ID (it->f, it->face_id)->ascii_face;
23837 font = face->font ? face->font : FRAME_FONT (it->f);
23838 it->ascent = FONT_BASE (font) + font->baseline_offset;
23839 it->descent = FONT_DESCENT (font) - font->baseline_offset;
23840 base_height = it->ascent + it->descent;
23841 base_width = font->average_width;
23842
23843 /* Get a face ID for the glyph by utilizing a cache (the same way as
23844 done for `escape-glyph' in get_next_display_element). */
23845 if (it->f == last_glyphless_glyph_frame
23846 && it->face_id == last_glyphless_glyph_face_id)
23847 {
23848 face_id = last_glyphless_glyph_merged_face_id;
23849 }
23850 else
23851 {
23852 /* Merge the `glyphless-char' face into the current face. */
23853 face_id = merge_faces (it->f, Qglyphless_char, 0, it->face_id);
23854 last_glyphless_glyph_frame = it->f;
23855 last_glyphless_glyph_face_id = it->face_id;
23856 last_glyphless_glyph_merged_face_id = face_id;
23857 }
23858
23859 if (it->glyphless_method == GLYPHLESS_DISPLAY_THIN_SPACE)
23860 {
23861 it->pixel_width = THIN_SPACE_WIDTH;
23862 len = 0;
23863 upper_xoff = upper_yoff = lower_xoff = lower_yoff = 0;
23864 }
23865 else if (it->glyphless_method == GLYPHLESS_DISPLAY_EMPTY_BOX)
23866 {
23867 width = CHAR_WIDTH (it->c);
23868 if (width == 0)
23869 width = 1;
23870 else if (width > 4)
23871 width = 4;
23872 it->pixel_width = base_width * width;
23873 len = 0;
23874 upper_xoff = upper_yoff = lower_xoff = lower_yoff = 0;
23875 }
23876 else
23877 {
23878 char buf[7];
23879 const char *str;
23880 unsigned int code[6];
23881 int upper_len;
23882 int ascent, descent;
23883 struct font_metrics metrics_upper, metrics_lower;
23884
23885 face = FACE_FROM_ID (it->f, face_id);
23886 font = face->font ? face->font : FRAME_FONT (it->f);
23887 PREPARE_FACE_FOR_DISPLAY (it->f, face);
23888
23889 if (it->glyphless_method == GLYPHLESS_DISPLAY_ACRONYM)
23890 {
23891 if (! STRINGP (acronym) && CHAR_TABLE_P (Vglyphless_char_display))
23892 acronym = CHAR_TABLE_REF (Vglyphless_char_display, it->c);
23893 if (CONSP (acronym))
23894 acronym = XCAR (acronym);
23895 str = STRINGP (acronym) ? SSDATA (acronym) : "";
23896 }
23897 else
23898 {
23899 xassert (it->glyphless_method == GLYPHLESS_DISPLAY_HEX_CODE);
23900 sprintf (buf, "%0*X", it->c < 0x10000 ? 4 : 6, it->c);
23901 str = buf;
23902 }
23903 for (len = 0; str[len] && ASCII_BYTE_P (str[len]); len++)
23904 code[len] = font->driver->encode_char (font, str[len]);
23905 upper_len = (len + 1) / 2;
23906 font->driver->text_extents (font, code, upper_len,
23907 &metrics_upper);
23908 font->driver->text_extents (font, code + upper_len, len - upper_len,
23909 &metrics_lower);
23910
23911
23912
23913 /* +4 is for vertical bars of a box plus 1-pixel spaces at both side. */
23914 width = max (metrics_upper.width, metrics_lower.width) + 4;
23915 upper_xoff = upper_yoff = 2; /* the typical case */
23916 if (base_width >= width)
23917 {
23918 /* Align the upper to the left, the lower to the right. */
23919 it->pixel_width = base_width;
23920 lower_xoff = base_width - 2 - metrics_lower.width;
23921 }
23922 else
23923 {
23924 /* Center the shorter one. */
23925 it->pixel_width = width;
23926 if (metrics_upper.width >= metrics_lower.width)
23927 lower_xoff = (width - metrics_lower.width) / 2;
23928 else
23929 {
23930 /* FIXME: This code doesn't look right. It formerly was
23931 missing the "lower_xoff = 0;", which couldn't have
23932 been right since it left lower_xoff uninitialized. */
23933 lower_xoff = 0;
23934 upper_xoff = (width - metrics_upper.width) / 2;
23935 }
23936 }
23937
23938 /* +5 is for horizontal bars of a box plus 1-pixel spaces at
23939 top, bottom, and between upper and lower strings. */
23940 height = (metrics_upper.ascent + metrics_upper.descent
23941 + metrics_lower.ascent + metrics_lower.descent) + 5;
23942 /* Center vertically.
23943 H:base_height, D:base_descent
23944 h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
23945
23946 ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
23947 descent = D - H/2 + h/2;
23948 lower_yoff = descent - 2 - ld;
23949 upper_yoff = lower_yoff - la - 1 - ud; */
23950 ascent = - (it->descent - (base_height + height + 1) / 2);
23951 descent = it->descent - (base_height - height) / 2;
23952 lower_yoff = descent - 2 - metrics_lower.descent;
23953 upper_yoff = (lower_yoff - metrics_lower.ascent - 1
23954 - metrics_upper.descent);
23955 /* Don't make the height shorter than the base height. */
23956 if (height > base_height)
23957 {
23958 it->ascent = ascent;
23959 it->descent = descent;
23960 }
23961 }
23962
23963 it->phys_ascent = it->ascent;
23964 it->phys_descent = it->descent;
23965 if (it->glyph_row)
23966 append_glyphless_glyph (it, face_id, for_no_font, len,
23967 upper_xoff, upper_yoff,
23968 lower_xoff, lower_yoff);
23969 it->nglyphs = 1;
23970 take_vertical_position_into_account (it);
23971 }
23972
23973
23974 /* RIF:
23975 Produce glyphs/get display metrics for the display element IT is
23976 loaded with. See the description of struct it in dispextern.h
23977 for an overview of struct it. */
23978
23979 void
23980 x_produce_glyphs (struct it *it)
23981 {
23982 int extra_line_spacing = it->extra_line_spacing;
23983
23984 it->glyph_not_available_p = 0;
23985
23986 if (it->what == IT_CHARACTER)
23987 {
23988 XChar2b char2b;
23989 struct face *face = FACE_FROM_ID (it->f, it->face_id);
23990 struct font *font = face->font;
23991 struct font_metrics *pcm = NULL;
23992 int boff; /* baseline offset */
23993
23994 if (font == NULL)
23995 {
23996 /* When no suitable font is found, display this character by
23997 the method specified in the first extra slot of
23998 Vglyphless_char_display. */
23999 Lisp_Object acronym = lookup_glyphless_char_display (-1, it);
24000
24001 xassert (it->what == IT_GLYPHLESS);
24002 produce_glyphless_glyph (it, 1, STRINGP (acronym) ? acronym : Qnil);
24003 goto done;
24004 }
24005
24006 boff = font->baseline_offset;
24007 if (font->vertical_centering)
24008 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
24009
24010 if (it->char_to_display != '\n' && it->char_to_display != '\t')
24011 {
24012 int stretched_p;
24013
24014 it->nglyphs = 1;
24015
24016 if (it->override_ascent >= 0)
24017 {
24018 it->ascent = it->override_ascent;
24019 it->descent = it->override_descent;
24020 boff = it->override_boff;
24021 }
24022 else
24023 {
24024 it->ascent = FONT_BASE (font) + boff;
24025 it->descent = FONT_DESCENT (font) - boff;
24026 }
24027
24028 if (get_char_glyph_code (it->char_to_display, font, &char2b))
24029 {
24030 pcm = get_per_char_metric (font, &char2b);
24031 if (pcm->width == 0
24032 && pcm->rbearing == 0 && pcm->lbearing == 0)
24033 pcm = NULL;
24034 }
24035
24036 if (pcm)
24037 {
24038 it->phys_ascent = pcm->ascent + boff;
24039 it->phys_descent = pcm->descent - boff;
24040 it->pixel_width = pcm->width;
24041 }
24042 else
24043 {
24044 it->glyph_not_available_p = 1;
24045 it->phys_ascent = it->ascent;
24046 it->phys_descent = it->descent;
24047 it->pixel_width = font->space_width;
24048 }
24049
24050 if (it->constrain_row_ascent_descent_p)
24051 {
24052 if (it->descent > it->max_descent)
24053 {
24054 it->ascent += it->descent - it->max_descent;
24055 it->descent = it->max_descent;
24056 }
24057 if (it->ascent > it->max_ascent)
24058 {
24059 it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
24060 it->ascent = it->max_ascent;
24061 }
24062 it->phys_ascent = min (it->phys_ascent, it->ascent);
24063 it->phys_descent = min (it->phys_descent, it->descent);
24064 extra_line_spacing = 0;
24065 }
24066
24067 /* If this is a space inside a region of text with
24068 `space-width' property, change its width. */
24069 stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
24070 if (stretched_p)
24071 it->pixel_width *= XFLOATINT (it->space_width);
24072
24073 /* If face has a box, add the box thickness to the character
24074 height. If character has a box line to the left and/or
24075 right, add the box line width to the character's width. */
24076 if (face->box != FACE_NO_BOX)
24077 {
24078 int thick = face->box_line_width;
24079
24080 if (thick > 0)
24081 {
24082 it->ascent += thick;
24083 it->descent += thick;
24084 }
24085 else
24086 thick = -thick;
24087
24088 if (it->start_of_box_run_p)
24089 it->pixel_width += thick;
24090 if (it->end_of_box_run_p)
24091 it->pixel_width += thick;
24092 }
24093
24094 /* If face has an overline, add the height of the overline
24095 (1 pixel) and a 1 pixel margin to the character height. */
24096 if (face->overline_p)
24097 it->ascent += overline_margin;
24098
24099 if (it->constrain_row_ascent_descent_p)
24100 {
24101 if (it->ascent > it->max_ascent)
24102 it->ascent = it->max_ascent;
24103 if (it->descent > it->max_descent)
24104 it->descent = it->max_descent;
24105 }
24106
24107 take_vertical_position_into_account (it);
24108
24109 /* If we have to actually produce glyphs, do it. */
24110 if (it->glyph_row)
24111 {
24112 if (stretched_p)
24113 {
24114 /* Translate a space with a `space-width' property
24115 into a stretch glyph. */
24116 int ascent = (((it->ascent + it->descent) * FONT_BASE (font))
24117 / FONT_HEIGHT (font));
24118 append_stretch_glyph (it, it->object, it->pixel_width,
24119 it->ascent + it->descent, ascent);
24120 }
24121 else
24122 append_glyph (it);
24123
24124 /* If characters with lbearing or rbearing are displayed
24125 in this line, record that fact in a flag of the
24126 glyph row. This is used to optimize X output code. */
24127 if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
24128 it->glyph_row->contains_overlapping_glyphs_p = 1;
24129 }
24130 if (! stretched_p && it->pixel_width == 0)
24131 /* We assure that all visible glyphs have at least 1-pixel
24132 width. */
24133 it->pixel_width = 1;
24134 }
24135 else if (it->char_to_display == '\n')
24136 {
24137 /* A newline has no width, but we need the height of the
24138 line. But if previous part of the line sets a height,
24139 don't increase that height */
24140
24141 Lisp_Object height;
24142 Lisp_Object total_height = Qnil;
24143
24144 it->override_ascent = -1;
24145 it->pixel_width = 0;
24146 it->nglyphs = 0;
24147
24148 height = get_it_property (it, Qline_height);
24149 /* Split (line-height total-height) list */
24150 if (CONSP (height)
24151 && CONSP (XCDR (height))
24152 && NILP (XCDR (XCDR (height))))
24153 {
24154 total_height = XCAR (XCDR (height));
24155 height = XCAR (height);
24156 }
24157 height = calc_line_height_property (it, height, font, boff, 1);
24158
24159 if (it->override_ascent >= 0)
24160 {
24161 it->ascent = it->override_ascent;
24162 it->descent = it->override_descent;
24163 boff = it->override_boff;
24164 }
24165 else
24166 {
24167 it->ascent = FONT_BASE (font) + boff;
24168 it->descent = FONT_DESCENT (font) - boff;
24169 }
24170
24171 if (EQ (height, Qt))
24172 {
24173 if (it->descent > it->max_descent)
24174 {
24175 it->ascent += it->descent - it->max_descent;
24176 it->descent = it->max_descent;
24177 }
24178 if (it->ascent > it->max_ascent)
24179 {
24180 it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
24181 it->ascent = it->max_ascent;
24182 }
24183 it->phys_ascent = min (it->phys_ascent, it->ascent);
24184 it->phys_descent = min (it->phys_descent, it->descent);
24185 it->constrain_row_ascent_descent_p = 1;
24186 extra_line_spacing = 0;
24187 }
24188 else
24189 {
24190 Lisp_Object spacing;
24191
24192 it->phys_ascent = it->ascent;
24193 it->phys_descent = it->descent;
24194
24195 if ((it->max_ascent > 0 || it->max_descent > 0)
24196 && face->box != FACE_NO_BOX
24197 && face->box_line_width > 0)
24198 {
24199 it->ascent += face->box_line_width;
24200 it->descent += face->box_line_width;
24201 }
24202 if (!NILP (height)
24203 && XINT (height) > it->ascent + it->descent)
24204 it->ascent = XINT (height) - it->descent;
24205
24206 if (!NILP (total_height))
24207 spacing = calc_line_height_property (it, total_height, font, boff, 0);
24208 else
24209 {
24210 spacing = get_it_property (it, Qline_spacing);
24211 spacing = calc_line_height_property (it, spacing, font, boff, 0);
24212 }
24213 if (INTEGERP (spacing))
24214 {
24215 extra_line_spacing = XINT (spacing);
24216 if (!NILP (total_height))
24217 extra_line_spacing -= (it->phys_ascent + it->phys_descent);
24218 }
24219 }
24220 }
24221 else /* i.e. (it->char_to_display == '\t') */
24222 {
24223 if (font->space_width > 0)
24224 {
24225 int tab_width = it->tab_width * font->space_width;
24226 int x = it->current_x + it->continuation_lines_width;
24227 int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
24228
24229 /* If the distance from the current position to the next tab
24230 stop is less than a space character width, use the
24231 tab stop after that. */
24232 if (next_tab_x - x < font->space_width)
24233 next_tab_x += tab_width;
24234
24235 it->pixel_width = next_tab_x - x;
24236 it->nglyphs = 1;
24237 it->ascent = it->phys_ascent = FONT_BASE (font) + boff;
24238 it->descent = it->phys_descent = FONT_DESCENT (font) - boff;
24239
24240 if (it->glyph_row)
24241 {
24242 append_stretch_glyph (it, it->object, it->pixel_width,
24243 it->ascent + it->descent, it->ascent);
24244 }
24245 }
24246 else
24247 {
24248 it->pixel_width = 0;
24249 it->nglyphs = 1;
24250 }
24251 }
24252 }
24253 else if (it->what == IT_COMPOSITION && it->cmp_it.ch < 0)
24254 {
24255 /* A static composition.
24256
24257 Note: A composition is represented as one glyph in the
24258 glyph matrix. There are no padding glyphs.
24259
24260 Important note: pixel_width, ascent, and descent are the
24261 values of what is drawn by draw_glyphs (i.e. the values of
24262 the overall glyphs composed). */
24263 struct face *face = FACE_FROM_ID (it->f, it->face_id);
24264 int boff; /* baseline offset */
24265 struct composition *cmp = composition_table[it->cmp_it.id];
24266 int glyph_len = cmp->glyph_len;
24267 struct font *font = face->font;
24268
24269 it->nglyphs = 1;
24270
24271 /* If we have not yet calculated pixel size data of glyphs of
24272 the composition for the current face font, calculate them
24273 now. Theoretically, we have to check all fonts for the
24274 glyphs, but that requires much time and memory space. So,
24275 here we check only the font of the first glyph. This may
24276 lead to incorrect display, but it's very rare, and C-l
24277 (recenter-top-bottom) can correct the display anyway. */
24278 if (! cmp->font || cmp->font != font)
24279 {
24280 /* Ascent and descent of the font of the first character
24281 of this composition (adjusted by baseline offset).
24282 Ascent and descent of overall glyphs should not be less
24283 than these, respectively. */
24284 int font_ascent, font_descent, font_height;
24285 /* Bounding box of the overall glyphs. */
24286 int leftmost, rightmost, lowest, highest;
24287 int lbearing, rbearing;
24288 int i, width, ascent, descent;
24289 int left_padded = 0, right_padded = 0;
24290 int c IF_LINT (= 0); /* cmp->glyph_len can't be zero; see Bug#8512 */
24291 XChar2b char2b;
24292 struct font_metrics *pcm;
24293 int font_not_found_p;
24294 ptrdiff_t pos;
24295
24296 for (glyph_len = cmp->glyph_len; glyph_len > 0; glyph_len--)
24297 if ((c = COMPOSITION_GLYPH (cmp, glyph_len - 1)) != '\t')
24298 break;
24299 if (glyph_len < cmp->glyph_len)
24300 right_padded = 1;
24301 for (i = 0; i < glyph_len; i++)
24302 {
24303 if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
24304 break;
24305 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
24306 }
24307 if (i > 0)
24308 left_padded = 1;
24309
24310 pos = (STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
24311 : IT_CHARPOS (*it));
24312 /* If no suitable font is found, use the default font. */
24313 font_not_found_p = font == NULL;
24314 if (font_not_found_p)
24315 {
24316 face = face->ascii_face;
24317 font = face->font;
24318 }
24319 boff = font->baseline_offset;
24320 if (font->vertical_centering)
24321 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
24322 font_ascent = FONT_BASE (font) + boff;
24323 font_descent = FONT_DESCENT (font) - boff;
24324 font_height = FONT_HEIGHT (font);
24325
24326 cmp->font = (void *) font;
24327
24328 pcm = NULL;
24329 if (! font_not_found_p)
24330 {
24331 get_char_face_and_encoding (it->f, c, it->face_id,
24332 &char2b, 0);
24333 pcm = get_per_char_metric (font, &char2b);
24334 }
24335
24336 /* Initialize the bounding box. */
24337 if (pcm)
24338 {
24339 width = pcm->width;
24340 ascent = pcm->ascent;
24341 descent = pcm->descent;
24342 lbearing = pcm->lbearing;
24343 rbearing = pcm->rbearing;
24344 }
24345 else
24346 {
24347 width = font->space_width;
24348 ascent = FONT_BASE (font);
24349 descent = FONT_DESCENT (font);
24350 lbearing = 0;
24351 rbearing = width;
24352 }
24353
24354 rightmost = width;
24355 leftmost = 0;
24356 lowest = - descent + boff;
24357 highest = ascent + boff;
24358
24359 if (! font_not_found_p
24360 && font->default_ascent
24361 && CHAR_TABLE_P (Vuse_default_ascent)
24362 && !NILP (Faref (Vuse_default_ascent,
24363 make_number (it->char_to_display))))
24364 highest = font->default_ascent + boff;
24365
24366 /* Draw the first glyph at the normal position. It may be
24367 shifted to right later if some other glyphs are drawn
24368 at the left. */
24369 cmp->offsets[i * 2] = 0;
24370 cmp->offsets[i * 2 + 1] = boff;
24371 cmp->lbearing = lbearing;
24372 cmp->rbearing = rbearing;
24373
24374 /* Set cmp->offsets for the remaining glyphs. */
24375 for (i++; i < glyph_len; i++)
24376 {
24377 int left, right, btm, top;
24378 int ch = COMPOSITION_GLYPH (cmp, i);
24379 int face_id;
24380 struct face *this_face;
24381
24382 if (ch == '\t')
24383 ch = ' ';
24384 face_id = FACE_FOR_CHAR (it->f, face, ch, pos, it->string);
24385 this_face = FACE_FROM_ID (it->f, face_id);
24386 font = this_face->font;
24387
24388 if (font == NULL)
24389 pcm = NULL;
24390 else
24391 {
24392 get_char_face_and_encoding (it->f, ch, face_id,
24393 &char2b, 0);
24394 pcm = get_per_char_metric (font, &char2b);
24395 }
24396 if (! pcm)
24397 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
24398 else
24399 {
24400 width = pcm->width;
24401 ascent = pcm->ascent;
24402 descent = pcm->descent;
24403 lbearing = pcm->lbearing;
24404 rbearing = pcm->rbearing;
24405 if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
24406 {
24407 /* Relative composition with or without
24408 alternate chars. */
24409 left = (leftmost + rightmost - width) / 2;
24410 btm = - descent + boff;
24411 if (font->relative_compose
24412 && (! CHAR_TABLE_P (Vignore_relative_composition)
24413 || NILP (Faref (Vignore_relative_composition,
24414 make_number (ch)))))
24415 {
24416
24417 if (- descent >= font->relative_compose)
24418 /* One extra pixel between two glyphs. */
24419 btm = highest + 1;
24420 else if (ascent <= 0)
24421 /* One extra pixel between two glyphs. */
24422 btm = lowest - 1 - ascent - descent;
24423 }
24424 }
24425 else
24426 {
24427 /* A composition rule is specified by an integer
24428 value that encodes global and new reference
24429 points (GREF and NREF). GREF and NREF are
24430 specified by numbers as below:
24431
24432 0---1---2 -- ascent
24433 | |
24434 | |
24435 | |
24436 9--10--11 -- center
24437 | |
24438 ---3---4---5--- baseline
24439 | |
24440 6---7---8 -- descent
24441 */
24442 int rule = COMPOSITION_RULE (cmp, i);
24443 int gref, nref, grefx, grefy, nrefx, nrefy, xoff, yoff;
24444
24445 COMPOSITION_DECODE_RULE (rule, gref, nref, xoff, yoff);
24446 grefx = gref % 3, nrefx = nref % 3;
24447 grefy = gref / 3, nrefy = nref / 3;
24448 if (xoff)
24449 xoff = font_height * (xoff - 128) / 256;
24450 if (yoff)
24451 yoff = font_height * (yoff - 128) / 256;
24452
24453 left = (leftmost
24454 + grefx * (rightmost - leftmost) / 2
24455 - nrefx * width / 2
24456 + xoff);
24457
24458 btm = ((grefy == 0 ? highest
24459 : grefy == 1 ? 0
24460 : grefy == 2 ? lowest
24461 : (highest + lowest) / 2)
24462 - (nrefy == 0 ? ascent + descent
24463 : nrefy == 1 ? descent - boff
24464 : nrefy == 2 ? 0
24465 : (ascent + descent) / 2)
24466 + yoff);
24467 }
24468
24469 cmp->offsets[i * 2] = left;
24470 cmp->offsets[i * 2 + 1] = btm + descent;
24471
24472 /* Update the bounding box of the overall glyphs. */
24473 if (width > 0)
24474 {
24475 right = left + width;
24476 if (left < leftmost)
24477 leftmost = left;
24478 if (right > rightmost)
24479 rightmost = right;
24480 }
24481 top = btm + descent + ascent;
24482 if (top > highest)
24483 highest = top;
24484 if (btm < lowest)
24485 lowest = btm;
24486
24487 if (cmp->lbearing > left + lbearing)
24488 cmp->lbearing = left + lbearing;
24489 if (cmp->rbearing < left + rbearing)
24490 cmp->rbearing = left + rbearing;
24491 }
24492 }
24493
24494 /* If there are glyphs whose x-offsets are negative,
24495 shift all glyphs to the right and make all x-offsets
24496 non-negative. */
24497 if (leftmost < 0)
24498 {
24499 for (i = 0; i < cmp->glyph_len; i++)
24500 cmp->offsets[i * 2] -= leftmost;
24501 rightmost -= leftmost;
24502 cmp->lbearing -= leftmost;
24503 cmp->rbearing -= leftmost;
24504 }
24505
24506 if (left_padded && cmp->lbearing < 0)
24507 {
24508 for (i = 0; i < cmp->glyph_len; i++)
24509 cmp->offsets[i * 2] -= cmp->lbearing;
24510 rightmost -= cmp->lbearing;
24511 cmp->rbearing -= cmp->lbearing;
24512 cmp->lbearing = 0;
24513 }
24514 if (right_padded && rightmost < cmp->rbearing)
24515 {
24516 rightmost = cmp->rbearing;
24517 }
24518
24519 cmp->pixel_width = rightmost;
24520 cmp->ascent = highest;
24521 cmp->descent = - lowest;
24522 if (cmp->ascent < font_ascent)
24523 cmp->ascent = font_ascent;
24524 if (cmp->descent < font_descent)
24525 cmp->descent = font_descent;
24526 }
24527
24528 if (it->glyph_row
24529 && (cmp->lbearing < 0
24530 || cmp->rbearing > cmp->pixel_width))
24531 it->glyph_row->contains_overlapping_glyphs_p = 1;
24532
24533 it->pixel_width = cmp->pixel_width;
24534 it->ascent = it->phys_ascent = cmp->ascent;
24535 it->descent = it->phys_descent = cmp->descent;
24536 if (face->box != FACE_NO_BOX)
24537 {
24538 int thick = face->box_line_width;
24539
24540 if (thick > 0)
24541 {
24542 it->ascent += thick;
24543 it->descent += thick;
24544 }
24545 else
24546 thick = - thick;
24547
24548 if (it->start_of_box_run_p)
24549 it->pixel_width += thick;
24550 if (it->end_of_box_run_p)
24551 it->pixel_width += thick;
24552 }
24553
24554 /* If face has an overline, add the height of the overline
24555 (1 pixel) and a 1 pixel margin to the character height. */
24556 if (face->overline_p)
24557 it->ascent += overline_margin;
24558
24559 take_vertical_position_into_account (it);
24560 if (it->ascent < 0)
24561 it->ascent = 0;
24562 if (it->descent < 0)
24563 it->descent = 0;
24564
24565 if (it->glyph_row)
24566 append_composite_glyph (it);
24567 }
24568 else if (it->what == IT_COMPOSITION)
24569 {
24570 /* A dynamic (automatic) composition. */
24571 struct face *face = FACE_FROM_ID (it->f, it->face_id);
24572 Lisp_Object gstring;
24573 struct font_metrics metrics;
24574
24575 it->nglyphs = 1;
24576
24577 gstring = composition_gstring_from_id (it->cmp_it.id);
24578 it->pixel_width
24579 = composition_gstring_width (gstring, it->cmp_it.from, it->cmp_it.to,
24580 &metrics);
24581 if (it->glyph_row
24582 && (metrics.lbearing < 0 || metrics.rbearing > metrics.width))
24583 it->glyph_row->contains_overlapping_glyphs_p = 1;
24584 it->ascent = it->phys_ascent = metrics.ascent;
24585 it->descent = it->phys_descent = metrics.descent;
24586 if (face->box != FACE_NO_BOX)
24587 {
24588 int thick = face->box_line_width;
24589
24590 if (thick > 0)
24591 {
24592 it->ascent += thick;
24593 it->descent += thick;
24594 }
24595 else
24596 thick = - thick;
24597
24598 if (it->start_of_box_run_p)
24599 it->pixel_width += thick;
24600 if (it->end_of_box_run_p)
24601 it->pixel_width += thick;
24602 }
24603 /* If face has an overline, add the height of the overline
24604 (1 pixel) and a 1 pixel margin to the character height. */
24605 if (face->overline_p)
24606 it->ascent += overline_margin;
24607 take_vertical_position_into_account (it);
24608 if (it->ascent < 0)
24609 it->ascent = 0;
24610 if (it->descent < 0)
24611 it->descent = 0;
24612
24613 if (it->glyph_row)
24614 append_composite_glyph (it);
24615 }
24616 else if (it->what == IT_GLYPHLESS)
24617 produce_glyphless_glyph (it, 0, Qnil);
24618 else if (it->what == IT_IMAGE)
24619 produce_image_glyph (it);
24620 else if (it->what == IT_STRETCH)
24621 produce_stretch_glyph (it);
24622
24623 done:
24624 /* Accumulate dimensions. Note: can't assume that it->descent > 0
24625 because this isn't true for images with `:ascent 100'. */
24626 xassert (it->ascent >= 0 && it->descent >= 0);
24627 if (it->area == TEXT_AREA)
24628 it->current_x += it->pixel_width;
24629
24630 if (extra_line_spacing > 0)
24631 {
24632 it->descent += extra_line_spacing;
24633 if (extra_line_spacing > it->max_extra_line_spacing)
24634 it->max_extra_line_spacing = extra_line_spacing;
24635 }
24636
24637 it->max_ascent = max (it->max_ascent, it->ascent);
24638 it->max_descent = max (it->max_descent, it->descent);
24639 it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
24640 it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
24641 }
24642
24643 /* EXPORT for RIF:
24644 Output LEN glyphs starting at START at the nominal cursor position.
24645 Advance the nominal cursor over the text. The global variable
24646 updated_window contains the window being updated, updated_row is
24647 the glyph row being updated, and updated_area is the area of that
24648 row being updated. */
24649
24650 void
24651 x_write_glyphs (struct glyph *start, int len)
24652 {
24653 int x, hpos;
24654
24655 xassert (updated_window && updated_row);
24656 BLOCK_INPUT;
24657
24658 /* Write glyphs. */
24659
24660 hpos = start - updated_row->glyphs[updated_area];
24661 x = draw_glyphs (updated_window, output_cursor.x,
24662 updated_row, updated_area,
24663 hpos, hpos + len,
24664 DRAW_NORMAL_TEXT, 0);
24665
24666 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
24667 if (updated_area == TEXT_AREA
24668 && updated_window->phys_cursor_on_p
24669 && updated_window->phys_cursor.vpos == output_cursor.vpos
24670 && updated_window->phys_cursor.hpos >= hpos
24671 && updated_window->phys_cursor.hpos < hpos + len)
24672 updated_window->phys_cursor_on_p = 0;
24673
24674 UNBLOCK_INPUT;
24675
24676 /* Advance the output cursor. */
24677 output_cursor.hpos += len;
24678 output_cursor.x = x;
24679 }
24680
24681
24682 /* EXPORT for RIF:
24683 Insert LEN glyphs from START at the nominal cursor position. */
24684
24685 void
24686 x_insert_glyphs (struct glyph *start, int len)
24687 {
24688 struct frame *f;
24689 struct window *w;
24690 int line_height, shift_by_width, shifted_region_width;
24691 struct glyph_row *row;
24692 struct glyph *glyph;
24693 int frame_x, frame_y;
24694 ptrdiff_t hpos;
24695
24696 xassert (updated_window && updated_row);
24697 BLOCK_INPUT;
24698 w = updated_window;
24699 f = XFRAME (WINDOW_FRAME (w));
24700
24701 /* Get the height of the line we are in. */
24702 row = updated_row;
24703 line_height = row->height;
24704
24705 /* Get the width of the glyphs to insert. */
24706 shift_by_width = 0;
24707 for (glyph = start; glyph < start + len; ++glyph)
24708 shift_by_width += glyph->pixel_width;
24709
24710 /* Get the width of the region to shift right. */
24711 shifted_region_width = (window_box_width (w, updated_area)
24712 - output_cursor.x
24713 - shift_by_width);
24714
24715 /* Shift right. */
24716 frame_x = window_box_left (w, updated_area) + output_cursor.x;
24717 frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
24718
24719 FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
24720 line_height, shift_by_width);
24721
24722 /* Write the glyphs. */
24723 hpos = start - row->glyphs[updated_area];
24724 draw_glyphs (w, output_cursor.x, row, updated_area,
24725 hpos, hpos + len,
24726 DRAW_NORMAL_TEXT, 0);
24727
24728 /* Advance the output cursor. */
24729 output_cursor.hpos += len;
24730 output_cursor.x += shift_by_width;
24731 UNBLOCK_INPUT;
24732 }
24733
24734
24735 /* EXPORT for RIF:
24736 Erase the current text line from the nominal cursor position
24737 (inclusive) to pixel column TO_X (exclusive). The idea is that
24738 everything from TO_X onward is already erased.
24739
24740 TO_X is a pixel position relative to updated_area of
24741 updated_window. TO_X == -1 means clear to the end of this area. */
24742
24743 void
24744 x_clear_end_of_line (int to_x)
24745 {
24746 struct frame *f;
24747 struct window *w = updated_window;
24748 int max_x, min_y, max_y;
24749 int from_x, from_y, to_y;
24750
24751 xassert (updated_window && updated_row);
24752 f = XFRAME (w->frame);
24753
24754 if (updated_row->full_width_p)
24755 max_x = WINDOW_TOTAL_WIDTH (w);
24756 else
24757 max_x = window_box_width (w, updated_area);
24758 max_y = window_text_bottom_y (w);
24759
24760 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
24761 of window. For TO_X > 0, truncate to end of drawing area. */
24762 if (to_x == 0)
24763 return;
24764 else if (to_x < 0)
24765 to_x = max_x;
24766 else
24767 to_x = min (to_x, max_x);
24768
24769 to_y = min (max_y, output_cursor.y + updated_row->height);
24770
24771 /* Notice if the cursor will be cleared by this operation. */
24772 if (!updated_row->full_width_p)
24773 notice_overwritten_cursor (w, updated_area,
24774 output_cursor.x, -1,
24775 updated_row->y,
24776 MATRIX_ROW_BOTTOM_Y (updated_row));
24777
24778 from_x = output_cursor.x;
24779
24780 /* Translate to frame coordinates. */
24781 if (updated_row->full_width_p)
24782 {
24783 from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
24784 to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
24785 }
24786 else
24787 {
24788 int area_left = window_box_left (w, updated_area);
24789 from_x += area_left;
24790 to_x += area_left;
24791 }
24792
24793 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
24794 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
24795 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
24796
24797 /* Prevent inadvertently clearing to end of the X window. */
24798 if (to_x > from_x && to_y > from_y)
24799 {
24800 BLOCK_INPUT;
24801 FRAME_RIF (f)->clear_frame_area (f, from_x, from_y,
24802 to_x - from_x, to_y - from_y);
24803 UNBLOCK_INPUT;
24804 }
24805 }
24806
24807 #endif /* HAVE_WINDOW_SYSTEM */
24808
24809
24810 \f
24811 /***********************************************************************
24812 Cursor types
24813 ***********************************************************************/
24814
24815 /* Value is the internal representation of the specified cursor type
24816 ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
24817 of the bar cursor. */
24818
24819 static enum text_cursor_kinds
24820 get_specified_cursor_type (Lisp_Object arg, int *width)
24821 {
24822 enum text_cursor_kinds type;
24823
24824 if (NILP (arg))
24825 return NO_CURSOR;
24826
24827 if (EQ (arg, Qbox))
24828 return FILLED_BOX_CURSOR;
24829
24830 if (EQ (arg, Qhollow))
24831 return HOLLOW_BOX_CURSOR;
24832
24833 if (EQ (arg, Qbar))
24834 {
24835 *width = 2;
24836 return BAR_CURSOR;
24837 }
24838
24839 if (CONSP (arg)
24840 && EQ (XCAR (arg), Qbar)
24841 && RANGED_INTEGERP (0, XCDR (arg), INT_MAX))
24842 {
24843 *width = XINT (XCDR (arg));
24844 return BAR_CURSOR;
24845 }
24846
24847 if (EQ (arg, Qhbar))
24848 {
24849 *width = 2;
24850 return HBAR_CURSOR;
24851 }
24852
24853 if (CONSP (arg)
24854 && EQ (XCAR (arg), Qhbar)
24855 && RANGED_INTEGERP (0, XCDR (arg), INT_MAX))
24856 {
24857 *width = XINT (XCDR (arg));
24858 return HBAR_CURSOR;
24859 }
24860
24861 /* Treat anything unknown as "hollow box cursor".
24862 It was bad to signal an error; people have trouble fixing
24863 .Xdefaults with Emacs, when it has something bad in it. */
24864 type = HOLLOW_BOX_CURSOR;
24865
24866 return type;
24867 }
24868
24869 /* Set the default cursor types for specified frame. */
24870 void
24871 set_frame_cursor_types (struct frame *f, Lisp_Object arg)
24872 {
24873 int width = 1;
24874 Lisp_Object tem;
24875
24876 FRAME_DESIRED_CURSOR (f) = get_specified_cursor_type (arg, &width);
24877 FRAME_CURSOR_WIDTH (f) = width;
24878
24879 /* By default, set up the blink-off state depending on the on-state. */
24880
24881 tem = Fassoc (arg, Vblink_cursor_alist);
24882 if (!NILP (tem))
24883 {
24884 FRAME_BLINK_OFF_CURSOR (f)
24885 = get_specified_cursor_type (XCDR (tem), &width);
24886 FRAME_BLINK_OFF_CURSOR_WIDTH (f) = width;
24887 }
24888 else
24889 FRAME_BLINK_OFF_CURSOR (f) = DEFAULT_CURSOR;
24890 }
24891
24892
24893 #ifdef HAVE_WINDOW_SYSTEM
24894
24895 /* Return the cursor we want to be displayed in window W. Return
24896 width of bar/hbar cursor through WIDTH arg. Return with
24897 ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
24898 (i.e. if the `system caret' should track this cursor).
24899
24900 In a mini-buffer window, we want the cursor only to appear if we
24901 are reading input from this window. For the selected window, we
24902 want the cursor type given by the frame parameter or buffer local
24903 setting of cursor-type. If explicitly marked off, draw no cursor.
24904 In all other cases, we want a hollow box cursor. */
24905
24906 static enum text_cursor_kinds
24907 get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
24908 int *active_cursor)
24909 {
24910 struct frame *f = XFRAME (w->frame);
24911 struct buffer *b = XBUFFER (w->buffer);
24912 int cursor_type = DEFAULT_CURSOR;
24913 Lisp_Object alt_cursor;
24914 int non_selected = 0;
24915
24916 *active_cursor = 1;
24917
24918 /* Echo area */
24919 if (cursor_in_echo_area
24920 && FRAME_HAS_MINIBUF_P (f)
24921 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
24922 {
24923 if (w == XWINDOW (echo_area_window))
24924 {
24925 if (EQ (BVAR (b, cursor_type), Qt) || NILP (BVAR (b, cursor_type)))
24926 {
24927 *width = FRAME_CURSOR_WIDTH (f);
24928 return FRAME_DESIRED_CURSOR (f);
24929 }
24930 else
24931 return get_specified_cursor_type (BVAR (b, cursor_type), width);
24932 }
24933
24934 *active_cursor = 0;
24935 non_selected = 1;
24936 }
24937
24938 /* Detect a nonselected window or nonselected frame. */
24939 else if (w != XWINDOW (f->selected_window)
24940 || f != FRAME_X_DISPLAY_INFO (f)->x_highlight_frame)
24941 {
24942 *active_cursor = 0;
24943
24944 if (MINI_WINDOW_P (w) && minibuf_level == 0)
24945 return NO_CURSOR;
24946
24947 non_selected = 1;
24948 }
24949
24950 /* Never display a cursor in a window in which cursor-type is nil. */
24951 if (NILP (BVAR (b, cursor_type)))
24952 return NO_CURSOR;
24953
24954 /* Get the normal cursor type for this window. */
24955 if (EQ (BVAR (b, cursor_type), Qt))
24956 {
24957 cursor_type = FRAME_DESIRED_CURSOR (f);
24958 *width = FRAME_CURSOR_WIDTH (f);
24959 }
24960 else
24961 cursor_type = get_specified_cursor_type (BVAR (b, cursor_type), width);
24962
24963 /* Use cursor-in-non-selected-windows instead
24964 for non-selected window or frame. */
24965 if (non_selected)
24966 {
24967 alt_cursor = BVAR (b, cursor_in_non_selected_windows);
24968 if (!EQ (Qt, alt_cursor))
24969 return get_specified_cursor_type (alt_cursor, width);
24970 /* t means modify the normal cursor type. */
24971 if (cursor_type == FILLED_BOX_CURSOR)
24972 cursor_type = HOLLOW_BOX_CURSOR;
24973 else if (cursor_type == BAR_CURSOR && *width > 1)
24974 --*width;
24975 return cursor_type;
24976 }
24977
24978 /* Use normal cursor if not blinked off. */
24979 if (!w->cursor_off_p)
24980 {
24981 if (glyph != NULL && glyph->type == IMAGE_GLYPH)
24982 {
24983 if (cursor_type == FILLED_BOX_CURSOR)
24984 {
24985 /* Using a block cursor on large images can be very annoying.
24986 So use a hollow cursor for "large" images.
24987 If image is not transparent (no mask), also use hollow cursor. */
24988 struct image *img = IMAGE_FROM_ID (f, glyph->u.img_id);
24989 if (img != NULL && IMAGEP (img->spec))
24990 {
24991 /* Arbitrarily, interpret "Large" as >32x32 and >NxN
24992 where N = size of default frame font size.
24993 This should cover most of the "tiny" icons people may use. */
24994 if (!img->mask
24995 || img->width > max (32, WINDOW_FRAME_COLUMN_WIDTH (w))
24996 || img->height > max (32, WINDOW_FRAME_LINE_HEIGHT (w)))
24997 cursor_type = HOLLOW_BOX_CURSOR;
24998 }
24999 }
25000 else if (cursor_type != NO_CURSOR)
25001 {
25002 /* Display current only supports BOX and HOLLOW cursors for images.
25003 So for now, unconditionally use a HOLLOW cursor when cursor is
25004 not a solid box cursor. */
25005 cursor_type = HOLLOW_BOX_CURSOR;
25006 }
25007 }
25008 return cursor_type;
25009 }
25010
25011 /* Cursor is blinked off, so determine how to "toggle" it. */
25012
25013 /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist. */
25014 if ((alt_cursor = Fassoc (BVAR (b, cursor_type), Vblink_cursor_alist), !NILP (alt_cursor)))
25015 return get_specified_cursor_type (XCDR (alt_cursor), width);
25016
25017 /* Then see if frame has specified a specific blink off cursor type. */
25018 if (FRAME_BLINK_OFF_CURSOR (f) != DEFAULT_CURSOR)
25019 {
25020 *width = FRAME_BLINK_OFF_CURSOR_WIDTH (f);
25021 return FRAME_BLINK_OFF_CURSOR (f);
25022 }
25023
25024 #if 0
25025 /* Some people liked having a permanently visible blinking cursor,
25026 while others had very strong opinions against it. So it was
25027 decided to remove it. KFS 2003-09-03 */
25028
25029 /* Finally perform built-in cursor blinking:
25030 filled box <-> hollow box
25031 wide [h]bar <-> narrow [h]bar
25032 narrow [h]bar <-> no cursor
25033 other type <-> no cursor */
25034
25035 if (cursor_type == FILLED_BOX_CURSOR)
25036 return HOLLOW_BOX_CURSOR;
25037
25038 if ((cursor_type == BAR_CURSOR || cursor_type == HBAR_CURSOR) && *width > 1)
25039 {
25040 *width = 1;
25041 return cursor_type;
25042 }
25043 #endif
25044
25045 return NO_CURSOR;
25046 }
25047
25048
25049 /* Notice when the text cursor of window W has been completely
25050 overwritten by a drawing operation that outputs glyphs in AREA
25051 starting at X0 and ending at X1 in the line starting at Y0 and
25052 ending at Y1. X coordinates are area-relative. X1 < 0 means all
25053 the rest of the line after X0 has been written. Y coordinates
25054 are window-relative. */
25055
25056 static void
25057 notice_overwritten_cursor (struct window *w, enum glyph_row_area area,
25058 int x0, int x1, int y0, int y1)
25059 {
25060 int cx0, cx1, cy0, cy1;
25061 struct glyph_row *row;
25062
25063 if (!w->phys_cursor_on_p)
25064 return;
25065 if (area != TEXT_AREA)
25066 return;
25067
25068 if (w->phys_cursor.vpos < 0
25069 || w->phys_cursor.vpos >= w->current_matrix->nrows
25070 || (row = w->current_matrix->rows + w->phys_cursor.vpos,
25071 !(row->enabled_p && row->displays_text_p)))
25072 return;
25073
25074 if (row->cursor_in_fringe_p)
25075 {
25076 row->cursor_in_fringe_p = 0;
25077 draw_fringe_bitmap (w, row, row->reversed_p);
25078 w->phys_cursor_on_p = 0;
25079 return;
25080 }
25081
25082 cx0 = w->phys_cursor.x;
25083 cx1 = cx0 + w->phys_cursor_width;
25084 if (x0 > cx0 || (x1 >= 0 && x1 < cx1))
25085 return;
25086
25087 /* The cursor image will be completely removed from the
25088 screen if the output area intersects the cursor area in
25089 y-direction. When we draw in [y0 y1[, and some part of
25090 the cursor is at y < y0, that part must have been drawn
25091 before. When scrolling, the cursor is erased before
25092 actually scrolling, so we don't come here. When not
25093 scrolling, the rows above the old cursor row must have
25094 changed, and in this case these rows must have written
25095 over the cursor image.
25096
25097 Likewise if part of the cursor is below y1, with the
25098 exception of the cursor being in the first blank row at
25099 the buffer and window end because update_text_area
25100 doesn't draw that row. (Except when it does, but
25101 that's handled in update_text_area.) */
25102
25103 cy0 = w->phys_cursor.y;
25104 cy1 = cy0 + w->phys_cursor_height;
25105 if ((y0 < cy0 || y0 >= cy1) && (y1 <= cy0 || y1 >= cy1))
25106 return;
25107
25108 w->phys_cursor_on_p = 0;
25109 }
25110
25111 #endif /* HAVE_WINDOW_SYSTEM */
25112
25113 \f
25114 /************************************************************************
25115 Mouse Face
25116 ************************************************************************/
25117
25118 #ifdef HAVE_WINDOW_SYSTEM
25119
25120 /* EXPORT for RIF:
25121 Fix the display of area AREA of overlapping row ROW in window W
25122 with respect to the overlapping part OVERLAPS. */
25123
25124 void
25125 x_fix_overlapping_area (struct window *w, struct glyph_row *row,
25126 enum glyph_row_area area, int overlaps)
25127 {
25128 int i, x;
25129
25130 BLOCK_INPUT;
25131
25132 x = 0;
25133 for (i = 0; i < row->used[area];)
25134 {
25135 if (row->glyphs[area][i].overlaps_vertically_p)
25136 {
25137 int start = i, start_x = x;
25138
25139 do
25140 {
25141 x += row->glyphs[area][i].pixel_width;
25142 ++i;
25143 }
25144 while (i < row->used[area]
25145 && row->glyphs[area][i].overlaps_vertically_p);
25146
25147 draw_glyphs (w, start_x, row, area,
25148 start, i,
25149 DRAW_NORMAL_TEXT, overlaps);
25150 }
25151 else
25152 {
25153 x += row->glyphs[area][i].pixel_width;
25154 ++i;
25155 }
25156 }
25157
25158 UNBLOCK_INPUT;
25159 }
25160
25161
25162 /* EXPORT:
25163 Draw the cursor glyph of window W in glyph row ROW. See the
25164 comment of draw_glyphs for the meaning of HL. */
25165
25166 void
25167 draw_phys_cursor_glyph (struct window *w, struct glyph_row *row,
25168 enum draw_glyphs_face hl)
25169 {
25170 /* If cursor hpos is out of bounds, don't draw garbage. This can
25171 happen in mini-buffer windows when switching between echo area
25172 glyphs and mini-buffer. */
25173 if ((row->reversed_p
25174 ? (w->phys_cursor.hpos >= 0)
25175 : (w->phys_cursor.hpos < row->used[TEXT_AREA])))
25176 {
25177 int on_p = w->phys_cursor_on_p;
25178 int x1;
25179 x1 = draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
25180 w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
25181 hl, 0);
25182 w->phys_cursor_on_p = on_p;
25183
25184 if (hl == DRAW_CURSOR)
25185 w->phys_cursor_width = x1 - w->phys_cursor.x;
25186 /* When we erase the cursor, and ROW is overlapped by other
25187 rows, make sure that these overlapping parts of other rows
25188 are redrawn. */
25189 else if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
25190 {
25191 w->phys_cursor_width = x1 - w->phys_cursor.x;
25192
25193 if (row > w->current_matrix->rows
25194 && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
25195 x_fix_overlapping_area (w, row - 1, TEXT_AREA,
25196 OVERLAPS_ERASED_CURSOR);
25197
25198 if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
25199 && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
25200 x_fix_overlapping_area (w, row + 1, TEXT_AREA,
25201 OVERLAPS_ERASED_CURSOR);
25202 }
25203 }
25204 }
25205
25206
25207 /* EXPORT:
25208 Erase the image of a cursor of window W from the screen. */
25209
25210 void
25211 erase_phys_cursor (struct window *w)
25212 {
25213 struct frame *f = XFRAME (w->frame);
25214 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
25215 int hpos = w->phys_cursor.hpos;
25216 int vpos = w->phys_cursor.vpos;
25217 int mouse_face_here_p = 0;
25218 struct glyph_matrix *active_glyphs = w->current_matrix;
25219 struct glyph_row *cursor_row;
25220 struct glyph *cursor_glyph;
25221 enum draw_glyphs_face hl;
25222
25223 /* No cursor displayed or row invalidated => nothing to do on the
25224 screen. */
25225 if (w->phys_cursor_type == NO_CURSOR)
25226 goto mark_cursor_off;
25227
25228 /* VPOS >= active_glyphs->nrows means that window has been resized.
25229 Don't bother to erase the cursor. */
25230 if (vpos >= active_glyphs->nrows)
25231 goto mark_cursor_off;
25232
25233 /* If row containing cursor is marked invalid, there is nothing we
25234 can do. */
25235 cursor_row = MATRIX_ROW (active_glyphs, vpos);
25236 if (!cursor_row->enabled_p)
25237 goto mark_cursor_off;
25238
25239 /* If line spacing is > 0, old cursor may only be partially visible in
25240 window after split-window. So adjust visible height. */
25241 cursor_row->visible_height = min (cursor_row->visible_height,
25242 window_text_bottom_y (w) - cursor_row->y);
25243
25244 /* If row is completely invisible, don't attempt to delete a cursor which
25245 isn't there. This can happen if cursor is at top of a window, and
25246 we switch to a buffer with a header line in that window. */
25247 if (cursor_row->visible_height <= 0)
25248 goto mark_cursor_off;
25249
25250 /* If cursor is in the fringe, erase by drawing actual bitmap there. */
25251 if (cursor_row->cursor_in_fringe_p)
25252 {
25253 cursor_row->cursor_in_fringe_p = 0;
25254 draw_fringe_bitmap (w, cursor_row, cursor_row->reversed_p);
25255 goto mark_cursor_off;
25256 }
25257
25258 /* This can happen when the new row is shorter than the old one.
25259 In this case, either draw_glyphs or clear_end_of_line
25260 should have cleared the cursor. Note that we wouldn't be
25261 able to erase the cursor in this case because we don't have a
25262 cursor glyph at hand. */
25263 if ((cursor_row->reversed_p
25264 ? (w->phys_cursor.hpos < 0)
25265 : (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])))
25266 goto mark_cursor_off;
25267
25268 /* If the cursor is in the mouse face area, redisplay that when
25269 we clear the cursor. */
25270 if (! NILP (hlinfo->mouse_face_window)
25271 && coords_in_mouse_face_p (w, hpos, vpos)
25272 /* Don't redraw the cursor's spot in mouse face if it is at the
25273 end of a line (on a newline). The cursor appears there, but
25274 mouse highlighting does not. */
25275 && cursor_row->used[TEXT_AREA] > hpos && hpos >= 0)
25276 mouse_face_here_p = 1;
25277
25278 /* Maybe clear the display under the cursor. */
25279 if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
25280 {
25281 int x, y, left_x;
25282 int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
25283 int width;
25284
25285 cursor_glyph = get_phys_cursor_glyph (w);
25286 if (cursor_glyph == NULL)
25287 goto mark_cursor_off;
25288
25289 width = cursor_glyph->pixel_width;
25290 left_x = window_box_left_offset (w, TEXT_AREA);
25291 x = w->phys_cursor.x;
25292 if (x < left_x)
25293 width -= left_x - x;
25294 width = min (width, window_box_width (w, TEXT_AREA) - x);
25295 y = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, cursor_row->y));
25296 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, max (x, left_x));
25297
25298 if (width > 0)
25299 FRAME_RIF (f)->clear_frame_area (f, x, y, width, cursor_row->visible_height);
25300 }
25301
25302 /* Erase the cursor by redrawing the character underneath it. */
25303 if (mouse_face_here_p)
25304 hl = DRAW_MOUSE_FACE;
25305 else
25306 hl = DRAW_NORMAL_TEXT;
25307 draw_phys_cursor_glyph (w, cursor_row, hl);
25308
25309 mark_cursor_off:
25310 w->phys_cursor_on_p = 0;
25311 w->phys_cursor_type = NO_CURSOR;
25312 }
25313
25314
25315 /* EXPORT:
25316 Display or clear cursor of window W. If ON is zero, clear the
25317 cursor. If it is non-zero, display the cursor. If ON is nonzero,
25318 where to put the cursor is specified by HPOS, VPOS, X and Y. */
25319
25320 void
25321 display_and_set_cursor (struct window *w, int on,
25322 int hpos, int vpos, int x, int y)
25323 {
25324 struct frame *f = XFRAME (w->frame);
25325 int new_cursor_type;
25326 int new_cursor_width;
25327 int active_cursor;
25328 struct glyph_row *glyph_row;
25329 struct glyph *glyph;
25330
25331 /* This is pointless on invisible frames, and dangerous on garbaged
25332 windows and frames; in the latter case, the frame or window may
25333 be in the midst of changing its size, and x and y may be off the
25334 window. */
25335 if (! FRAME_VISIBLE_P (f)
25336 || FRAME_GARBAGED_P (f)
25337 || vpos >= w->current_matrix->nrows
25338 || hpos >= w->current_matrix->matrix_w)
25339 return;
25340
25341 /* If cursor is off and we want it off, return quickly. */
25342 if (!on && !w->phys_cursor_on_p)
25343 return;
25344
25345 glyph_row = MATRIX_ROW (w->current_matrix, vpos);
25346 /* If cursor row is not enabled, we don't really know where to
25347 display the cursor. */
25348 if (!glyph_row->enabled_p)
25349 {
25350 w->phys_cursor_on_p = 0;
25351 return;
25352 }
25353
25354 glyph = NULL;
25355 if (!glyph_row->exact_window_width_line_p
25356 || (0 <= hpos && hpos < glyph_row->used[TEXT_AREA]))
25357 glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
25358
25359 xassert (interrupt_input_blocked);
25360
25361 /* Set new_cursor_type to the cursor we want to be displayed. */
25362 new_cursor_type = get_window_cursor_type (w, glyph,
25363 &new_cursor_width, &active_cursor);
25364
25365 /* If cursor is currently being shown and we don't want it to be or
25366 it is in the wrong place, or the cursor type is not what we want,
25367 erase it. */
25368 if (w->phys_cursor_on_p
25369 && (!on
25370 || w->phys_cursor.x != x
25371 || w->phys_cursor.y != y
25372 || new_cursor_type != w->phys_cursor_type
25373 || ((new_cursor_type == BAR_CURSOR || new_cursor_type == HBAR_CURSOR)
25374 && new_cursor_width != w->phys_cursor_width)))
25375 erase_phys_cursor (w);
25376
25377 /* Don't check phys_cursor_on_p here because that flag is only set
25378 to zero in some cases where we know that the cursor has been
25379 completely erased, to avoid the extra work of erasing the cursor
25380 twice. In other words, phys_cursor_on_p can be 1 and the cursor
25381 still not be visible, or it has only been partly erased. */
25382 if (on)
25383 {
25384 w->phys_cursor_ascent = glyph_row->ascent;
25385 w->phys_cursor_height = glyph_row->height;
25386
25387 /* Set phys_cursor_.* before x_draw_.* is called because some
25388 of them may need the information. */
25389 w->phys_cursor.x = x;
25390 w->phys_cursor.y = glyph_row->y;
25391 w->phys_cursor.hpos = hpos;
25392 w->phys_cursor.vpos = vpos;
25393 }
25394
25395 FRAME_RIF (f)->draw_window_cursor (w, glyph_row, x, y,
25396 new_cursor_type, new_cursor_width,
25397 on, active_cursor);
25398 }
25399
25400
25401 /* Switch the display of W's cursor on or off, according to the value
25402 of ON. */
25403
25404 static void
25405 update_window_cursor (struct window *w, int on)
25406 {
25407 /* Don't update cursor in windows whose frame is in the process
25408 of being deleted. */
25409 if (w->current_matrix)
25410 {
25411 BLOCK_INPUT;
25412 display_and_set_cursor (w, on, w->phys_cursor.hpos, w->phys_cursor.vpos,
25413 w->phys_cursor.x, w->phys_cursor.y);
25414 UNBLOCK_INPUT;
25415 }
25416 }
25417
25418
25419 /* Call update_window_cursor with parameter ON_P on all leaf windows
25420 in the window tree rooted at W. */
25421
25422 static void
25423 update_cursor_in_window_tree (struct window *w, int on_p)
25424 {
25425 while (w)
25426 {
25427 if (!NILP (w->hchild))
25428 update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
25429 else if (!NILP (w->vchild))
25430 update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
25431 else
25432 update_window_cursor (w, on_p);
25433
25434 w = NILP (w->next) ? 0 : XWINDOW (w->next);
25435 }
25436 }
25437
25438
25439 /* EXPORT:
25440 Display the cursor on window W, or clear it, according to ON_P.
25441 Don't change the cursor's position. */
25442
25443 void
25444 x_update_cursor (struct frame *f, int on_p)
25445 {
25446 update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
25447 }
25448
25449
25450 /* EXPORT:
25451 Clear the cursor of window W to background color, and mark the
25452 cursor as not shown. This is used when the text where the cursor
25453 is about to be rewritten. */
25454
25455 void
25456 x_clear_cursor (struct window *w)
25457 {
25458 if (FRAME_VISIBLE_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
25459 update_window_cursor (w, 0);
25460 }
25461
25462 #endif /* HAVE_WINDOW_SYSTEM */
25463
25464 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
25465 and MSDOS. */
25466 static void
25467 draw_row_with_mouse_face (struct window *w, int start_x, struct glyph_row *row,
25468 int start_hpos, int end_hpos,
25469 enum draw_glyphs_face draw)
25470 {
25471 #ifdef HAVE_WINDOW_SYSTEM
25472 if (FRAME_WINDOW_P (XFRAME (w->frame)))
25473 {
25474 draw_glyphs (w, start_x, row, TEXT_AREA, start_hpos, end_hpos, draw, 0);
25475 return;
25476 }
25477 #endif
25478 #if defined (HAVE_GPM) || defined (MSDOS)
25479 tty_draw_row_with_mouse_face (w, row, start_hpos, end_hpos, draw);
25480 #endif
25481 }
25482
25483 /* Display the active region described by mouse_face_* according to DRAW. */
25484
25485 static void
25486 show_mouse_face (Mouse_HLInfo *hlinfo, enum draw_glyphs_face draw)
25487 {
25488 struct window *w = XWINDOW (hlinfo->mouse_face_window);
25489 struct frame *f = XFRAME (WINDOW_FRAME (w));
25490
25491 if (/* If window is in the process of being destroyed, don't bother
25492 to do anything. */
25493 w->current_matrix != NULL
25494 /* Don't update mouse highlight if hidden */
25495 && (draw != DRAW_MOUSE_FACE || !hlinfo->mouse_face_hidden)
25496 /* Recognize when we are called to operate on rows that don't exist
25497 anymore. This can happen when a window is split. */
25498 && hlinfo->mouse_face_end_row < w->current_matrix->nrows)
25499 {
25500 int phys_cursor_on_p = w->phys_cursor_on_p;
25501 struct glyph_row *row, *first, *last;
25502
25503 first = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_beg_row);
25504 last = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_end_row);
25505
25506 for (row = first; row <= last && row->enabled_p; ++row)
25507 {
25508 int start_hpos, end_hpos, start_x;
25509
25510 /* For all but the first row, the highlight starts at column 0. */
25511 if (row == first)
25512 {
25513 /* R2L rows have BEG and END in reversed order, but the
25514 screen drawing geometry is always left to right. So
25515 we need to mirror the beginning and end of the
25516 highlighted area in R2L rows. */
25517 if (!row->reversed_p)
25518 {
25519 start_hpos = hlinfo->mouse_face_beg_col;
25520 start_x = hlinfo->mouse_face_beg_x;
25521 }
25522 else if (row == last)
25523 {
25524 start_hpos = hlinfo->mouse_face_end_col;
25525 start_x = hlinfo->mouse_face_end_x;
25526 }
25527 else
25528 {
25529 start_hpos = 0;
25530 start_x = 0;
25531 }
25532 }
25533 else if (row->reversed_p && row == last)
25534 {
25535 start_hpos = hlinfo->mouse_face_end_col;
25536 start_x = hlinfo->mouse_face_end_x;
25537 }
25538 else
25539 {
25540 start_hpos = 0;
25541 start_x = 0;
25542 }
25543
25544 if (row == last)
25545 {
25546 if (!row->reversed_p)
25547 end_hpos = hlinfo->mouse_face_end_col;
25548 else if (row == first)
25549 end_hpos = hlinfo->mouse_face_beg_col;
25550 else
25551 {
25552 end_hpos = row->used[TEXT_AREA];
25553 if (draw == DRAW_NORMAL_TEXT)
25554 row->fill_line_p = 1; /* Clear to end of line */
25555 }
25556 }
25557 else if (row->reversed_p && row == first)
25558 end_hpos = hlinfo->mouse_face_beg_col;
25559 else
25560 {
25561 end_hpos = row->used[TEXT_AREA];
25562 if (draw == DRAW_NORMAL_TEXT)
25563 row->fill_line_p = 1; /* Clear to end of line */
25564 }
25565
25566 if (end_hpos > start_hpos)
25567 {
25568 draw_row_with_mouse_face (w, start_x, row,
25569 start_hpos, end_hpos, draw);
25570
25571 row->mouse_face_p
25572 = draw == DRAW_MOUSE_FACE || draw == DRAW_IMAGE_RAISED;
25573 }
25574 }
25575
25576 #ifdef HAVE_WINDOW_SYSTEM
25577 /* When we've written over the cursor, arrange for it to
25578 be displayed again. */
25579 if (FRAME_WINDOW_P (f)
25580 && phys_cursor_on_p && !w->phys_cursor_on_p)
25581 {
25582 BLOCK_INPUT;
25583 display_and_set_cursor (w, 1,
25584 w->phys_cursor.hpos, w->phys_cursor.vpos,
25585 w->phys_cursor.x, w->phys_cursor.y);
25586 UNBLOCK_INPUT;
25587 }
25588 #endif /* HAVE_WINDOW_SYSTEM */
25589 }
25590
25591 #ifdef HAVE_WINDOW_SYSTEM
25592 /* Change the mouse cursor. */
25593 if (FRAME_WINDOW_P (f))
25594 {
25595 if (draw == DRAW_NORMAL_TEXT
25596 && !EQ (hlinfo->mouse_face_window, f->tool_bar_window))
25597 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->text_cursor);
25598 else if (draw == DRAW_MOUSE_FACE)
25599 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->hand_cursor);
25600 else
25601 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->nontext_cursor);
25602 }
25603 #endif /* HAVE_WINDOW_SYSTEM */
25604 }
25605
25606 /* EXPORT:
25607 Clear out the mouse-highlighted active region.
25608 Redraw it un-highlighted first. Value is non-zero if mouse
25609 face was actually drawn unhighlighted. */
25610
25611 int
25612 clear_mouse_face (Mouse_HLInfo *hlinfo)
25613 {
25614 int cleared = 0;
25615
25616 if (!hlinfo->mouse_face_hidden && !NILP (hlinfo->mouse_face_window))
25617 {
25618 show_mouse_face (hlinfo, DRAW_NORMAL_TEXT);
25619 cleared = 1;
25620 }
25621
25622 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
25623 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
25624 hlinfo->mouse_face_window = Qnil;
25625 hlinfo->mouse_face_overlay = Qnil;
25626 return cleared;
25627 }
25628
25629 /* Return non-zero if the coordinates HPOS and VPOS on windows W are
25630 within the mouse face on that window. */
25631 static int
25632 coords_in_mouse_face_p (struct window *w, int hpos, int vpos)
25633 {
25634 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
25635
25636 /* Quickly resolve the easy cases. */
25637 if (!(WINDOWP (hlinfo->mouse_face_window)
25638 && XWINDOW (hlinfo->mouse_face_window) == w))
25639 return 0;
25640 if (vpos < hlinfo->mouse_face_beg_row
25641 || vpos > hlinfo->mouse_face_end_row)
25642 return 0;
25643 if (vpos > hlinfo->mouse_face_beg_row
25644 && vpos < hlinfo->mouse_face_end_row)
25645 return 1;
25646
25647 if (!MATRIX_ROW (w->current_matrix, vpos)->reversed_p)
25648 {
25649 if (hlinfo->mouse_face_beg_row == hlinfo->mouse_face_end_row)
25650 {
25651 if (hlinfo->mouse_face_beg_col <= hpos && hpos < hlinfo->mouse_face_end_col)
25652 return 1;
25653 }
25654 else if ((vpos == hlinfo->mouse_face_beg_row
25655 && hpos >= hlinfo->mouse_face_beg_col)
25656 || (vpos == hlinfo->mouse_face_end_row
25657 && hpos < hlinfo->mouse_face_end_col))
25658 return 1;
25659 }
25660 else
25661 {
25662 if (hlinfo->mouse_face_beg_row == hlinfo->mouse_face_end_row)
25663 {
25664 if (hlinfo->mouse_face_end_col < hpos && hpos <= hlinfo->mouse_face_beg_col)
25665 return 1;
25666 }
25667 else if ((vpos == hlinfo->mouse_face_beg_row
25668 && hpos <= hlinfo->mouse_face_beg_col)
25669 || (vpos == hlinfo->mouse_face_end_row
25670 && hpos > hlinfo->mouse_face_end_col))
25671 return 1;
25672 }
25673 return 0;
25674 }
25675
25676
25677 /* EXPORT:
25678 Non-zero if physical cursor of window W is within mouse face. */
25679
25680 int
25681 cursor_in_mouse_face_p (struct window *w)
25682 {
25683 return coords_in_mouse_face_p (w, w->phys_cursor.hpos, w->phys_cursor.vpos);
25684 }
25685
25686
25687 \f
25688 /* Find the glyph rows START_ROW and END_ROW of window W that display
25689 characters between buffer positions START_CHARPOS and END_CHARPOS
25690 (excluding END_CHARPOS). This is similar to row_containing_pos,
25691 but is more accurate when bidi reordering makes buffer positions
25692 change non-linearly with glyph rows. */
25693 static void
25694 rows_from_pos_range (struct window *w,
25695 ptrdiff_t start_charpos, ptrdiff_t end_charpos,
25696 struct glyph_row **start, struct glyph_row **end)
25697 {
25698 struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
25699 int last_y = window_text_bottom_y (w);
25700 struct glyph_row *row;
25701
25702 *start = NULL;
25703 *end = NULL;
25704
25705 while (!first->enabled_p
25706 && first < MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w))
25707 first++;
25708
25709 /* Find the START row. */
25710 for (row = first;
25711 row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y;
25712 row++)
25713 {
25714 /* A row can potentially be the START row if the range of the
25715 characters it displays intersects the range
25716 [START_CHARPOS..END_CHARPOS). */
25717 if (! ((start_charpos < MATRIX_ROW_START_CHARPOS (row)
25718 && end_charpos < MATRIX_ROW_START_CHARPOS (row))
25719 /* See the commentary in row_containing_pos, for the
25720 explanation of the complicated way to check whether
25721 some position is beyond the end of the characters
25722 displayed by a row. */
25723 || ((start_charpos > MATRIX_ROW_END_CHARPOS (row)
25724 || (start_charpos == MATRIX_ROW_END_CHARPOS (row)
25725 && !row->ends_at_zv_p
25726 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
25727 && (end_charpos > MATRIX_ROW_END_CHARPOS (row)
25728 || (end_charpos == MATRIX_ROW_END_CHARPOS (row)
25729 && !row->ends_at_zv_p
25730 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))))))
25731 {
25732 /* Found a candidate row. Now make sure at least one of the
25733 glyphs it displays has a charpos from the range
25734 [START_CHARPOS..END_CHARPOS).
25735
25736 This is not obvious because bidi reordering could make
25737 buffer positions of a row be 1,2,3,102,101,100, and if we
25738 want to highlight characters in [50..60), we don't want
25739 this row, even though [50..60) does intersect [1..103),
25740 the range of character positions given by the row's start
25741 and end positions. */
25742 struct glyph *g = row->glyphs[TEXT_AREA];
25743 struct glyph *e = g + row->used[TEXT_AREA];
25744
25745 while (g < e)
25746 {
25747 if ((BUFFERP (g->object) || INTEGERP (g->object))
25748 && start_charpos <= g->charpos && g->charpos < end_charpos)
25749 *start = row;
25750 g++;
25751 }
25752 if (*start)
25753 break;
25754 }
25755 }
25756
25757 /* Find the END row. */
25758 if (!*start
25759 /* If the last row is partially visible, start looking for END
25760 from that row, instead of starting from FIRST. */
25761 && !(row->enabled_p
25762 && row->y < last_y && MATRIX_ROW_BOTTOM_Y (row) > last_y))
25763 row = first;
25764 for ( ; row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y; row++)
25765 {
25766 struct glyph_row *next = row + 1;
25767
25768 if (!next->enabled_p
25769 || next >= MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w)
25770 /* The first row >= START whose range of displayed characters
25771 does NOT intersect the range [START_CHARPOS..END_CHARPOS]
25772 is the row END + 1. */
25773 || (start_charpos < MATRIX_ROW_START_CHARPOS (next)
25774 && end_charpos < MATRIX_ROW_START_CHARPOS (next))
25775 || ((start_charpos > MATRIX_ROW_END_CHARPOS (next)
25776 || (start_charpos == MATRIX_ROW_END_CHARPOS (next)
25777 && !next->ends_at_zv_p
25778 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next)))
25779 && (end_charpos > MATRIX_ROW_END_CHARPOS (next)
25780 || (end_charpos == MATRIX_ROW_END_CHARPOS (next)
25781 && !next->ends_at_zv_p
25782 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next)))))
25783 {
25784 *end = row;
25785 break;
25786 }
25787 else
25788 {
25789 /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
25790 but none of the characters it displays are in the range, it is
25791 also END + 1. */
25792 struct glyph *g = next->glyphs[TEXT_AREA];
25793 struct glyph *e = g + next->used[TEXT_AREA];
25794
25795 while (g < e)
25796 {
25797 if ((BUFFERP (g->object) || INTEGERP (g->object))
25798 && start_charpos <= g->charpos && g->charpos < end_charpos)
25799 break;
25800 g++;
25801 }
25802 if (g == e)
25803 {
25804 *end = row;
25805 break;
25806 }
25807 }
25808 }
25809 }
25810
25811 /* This function sets the mouse_face_* elements of HLINFO, assuming
25812 the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
25813 window WINDOW. START_CHARPOS and END_CHARPOS are buffer positions
25814 for the overlay or run of text properties specifying the mouse
25815 face. BEFORE_STRING and AFTER_STRING, if non-nil, are a
25816 before-string and after-string that must also be highlighted.
25817 COVER_STRING, if non-nil, is a display string that may cover some
25818 or all of the highlighted text. */
25819
25820 static void
25821 mouse_face_from_buffer_pos (Lisp_Object window,
25822 Mouse_HLInfo *hlinfo,
25823 ptrdiff_t mouse_charpos,
25824 ptrdiff_t start_charpos,
25825 ptrdiff_t end_charpos,
25826 Lisp_Object before_string,
25827 Lisp_Object after_string,
25828 Lisp_Object cover_string)
25829 {
25830 struct window *w = XWINDOW (window);
25831 struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
25832 struct glyph_row *r1, *r2;
25833 struct glyph *glyph, *end;
25834 ptrdiff_t ignore, pos;
25835 int x;
25836
25837 xassert (NILP (cover_string) || STRINGP (cover_string));
25838 xassert (NILP (before_string) || STRINGP (before_string));
25839 xassert (NILP (after_string) || STRINGP (after_string));
25840
25841 /* Find the rows corresponding to START_CHARPOS and END_CHARPOS. */
25842 rows_from_pos_range (w, start_charpos, end_charpos, &r1, &r2);
25843 if (r1 == NULL)
25844 r1 = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
25845 /* If the before-string or display-string contains newlines,
25846 rows_from_pos_range skips to its last row. Move back. */
25847 if (!NILP (before_string) || !NILP (cover_string))
25848 {
25849 struct glyph_row *prev;
25850 while ((prev = r1 - 1, prev >= first)
25851 && MATRIX_ROW_END_CHARPOS (prev) == start_charpos
25852 && prev->used[TEXT_AREA] > 0)
25853 {
25854 struct glyph *beg = prev->glyphs[TEXT_AREA];
25855 glyph = beg + prev->used[TEXT_AREA];
25856 while (--glyph >= beg && INTEGERP (glyph->object));
25857 if (glyph < beg
25858 || !(EQ (glyph->object, before_string)
25859 || EQ (glyph->object, cover_string)))
25860 break;
25861 r1 = prev;
25862 }
25863 }
25864 if (r2 == NULL)
25865 {
25866 r2 = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
25867 hlinfo->mouse_face_past_end = 1;
25868 }
25869 else if (!NILP (after_string))
25870 {
25871 /* If the after-string has newlines, advance to its last row. */
25872 struct glyph_row *next;
25873 struct glyph_row *last
25874 = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
25875
25876 for (next = r2 + 1;
25877 next <= last
25878 && next->used[TEXT_AREA] > 0
25879 && EQ (next->glyphs[TEXT_AREA]->object, after_string);
25880 ++next)
25881 r2 = next;
25882 }
25883 /* The rest of the display engine assumes that mouse_face_beg_row is
25884 either above below mouse_face_end_row or identical to it. But
25885 with bidi-reordered continued lines, the row for START_CHARPOS
25886 could be below the row for END_CHARPOS. If so, swap the rows and
25887 store them in correct order. */
25888 if (r1->y > r2->y)
25889 {
25890 struct glyph_row *tem = r2;
25891
25892 r2 = r1;
25893 r1 = tem;
25894 }
25895
25896 hlinfo->mouse_face_beg_y = r1->y;
25897 hlinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (r1, w->current_matrix);
25898 hlinfo->mouse_face_end_y = r2->y;
25899 hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r2, w->current_matrix);
25900
25901 /* For a bidi-reordered row, the positions of BEFORE_STRING,
25902 AFTER_STRING, COVER_STRING, START_CHARPOS, and END_CHARPOS
25903 could be anywhere in the row and in any order. The strategy
25904 below is to find the leftmost and the rightmost glyph that
25905 belongs to either of these 3 strings, or whose position is
25906 between START_CHARPOS and END_CHARPOS, and highlight all the
25907 glyphs between those two. This may cover more than just the text
25908 between START_CHARPOS and END_CHARPOS if the range of characters
25909 strides the bidi level boundary, e.g. if the beginning is in R2L
25910 text while the end is in L2R text or vice versa. */
25911 if (!r1->reversed_p)
25912 {
25913 /* This row is in a left to right paragraph. Scan it left to
25914 right. */
25915 glyph = r1->glyphs[TEXT_AREA];
25916 end = glyph + r1->used[TEXT_AREA];
25917 x = r1->x;
25918
25919 /* Skip truncation glyphs at the start of the glyph row. */
25920 if (r1->displays_text_p)
25921 for (; glyph < end
25922 && INTEGERP (glyph->object)
25923 && glyph->charpos < 0;
25924 ++glyph)
25925 x += glyph->pixel_width;
25926
25927 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
25928 or COVER_STRING, and the first glyph from buffer whose
25929 position is between START_CHARPOS and END_CHARPOS. */
25930 for (; glyph < end
25931 && !INTEGERP (glyph->object)
25932 && !EQ (glyph->object, cover_string)
25933 && !(BUFFERP (glyph->object)
25934 && (glyph->charpos >= start_charpos
25935 && glyph->charpos < end_charpos));
25936 ++glyph)
25937 {
25938 /* BEFORE_STRING or AFTER_STRING are only relevant if they
25939 are present at buffer positions between START_CHARPOS and
25940 END_CHARPOS, or if they come from an overlay. */
25941 if (EQ (glyph->object, before_string))
25942 {
25943 pos = string_buffer_position (before_string,
25944 start_charpos);
25945 /* If pos == 0, it means before_string came from an
25946 overlay, not from a buffer position. */
25947 if (!pos || (pos >= start_charpos && pos < end_charpos))
25948 break;
25949 }
25950 else if (EQ (glyph->object, after_string))
25951 {
25952 pos = string_buffer_position (after_string, end_charpos);
25953 if (!pos || (pos >= start_charpos && pos < end_charpos))
25954 break;
25955 }
25956 x += glyph->pixel_width;
25957 }
25958 hlinfo->mouse_face_beg_x = x;
25959 hlinfo->mouse_face_beg_col = glyph - r1->glyphs[TEXT_AREA];
25960 }
25961 else
25962 {
25963 /* This row is in a right to left paragraph. Scan it right to
25964 left. */
25965 struct glyph *g;
25966
25967 end = r1->glyphs[TEXT_AREA] - 1;
25968 glyph = end + r1->used[TEXT_AREA];
25969
25970 /* Skip truncation glyphs at the start of the glyph row. */
25971 if (r1->displays_text_p)
25972 for (; glyph > end
25973 && INTEGERP (glyph->object)
25974 && glyph->charpos < 0;
25975 --glyph)
25976 ;
25977
25978 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
25979 or COVER_STRING, and the first glyph from buffer whose
25980 position is between START_CHARPOS and END_CHARPOS. */
25981 for (; glyph > end
25982 && !INTEGERP (glyph->object)
25983 && !EQ (glyph->object, cover_string)
25984 && !(BUFFERP (glyph->object)
25985 && (glyph->charpos >= start_charpos
25986 && glyph->charpos < end_charpos));
25987 --glyph)
25988 {
25989 /* BEFORE_STRING or AFTER_STRING are only relevant if they
25990 are present at buffer positions between START_CHARPOS and
25991 END_CHARPOS, or if they come from an overlay. */
25992 if (EQ (glyph->object, before_string))
25993 {
25994 pos = string_buffer_position (before_string, start_charpos);
25995 /* If pos == 0, it means before_string came from an
25996 overlay, not from a buffer position. */
25997 if (!pos || (pos >= start_charpos && pos < end_charpos))
25998 break;
25999 }
26000 else if (EQ (glyph->object, after_string))
26001 {
26002 pos = string_buffer_position (after_string, end_charpos);
26003 if (!pos || (pos >= start_charpos && pos < end_charpos))
26004 break;
26005 }
26006 }
26007
26008 glyph++; /* first glyph to the right of the highlighted area */
26009 for (g = r1->glyphs[TEXT_AREA], x = r1->x; g < glyph; g++)
26010 x += g->pixel_width;
26011 hlinfo->mouse_face_beg_x = x;
26012 hlinfo->mouse_face_beg_col = glyph - r1->glyphs[TEXT_AREA];
26013 }
26014
26015 /* If the highlight ends in a different row, compute GLYPH and END
26016 for the end row. Otherwise, reuse the values computed above for
26017 the row where the highlight begins. */
26018 if (r2 != r1)
26019 {
26020 if (!r2->reversed_p)
26021 {
26022 glyph = r2->glyphs[TEXT_AREA];
26023 end = glyph + r2->used[TEXT_AREA];
26024 x = r2->x;
26025 }
26026 else
26027 {
26028 end = r2->glyphs[TEXT_AREA] - 1;
26029 glyph = end + r2->used[TEXT_AREA];
26030 }
26031 }
26032
26033 if (!r2->reversed_p)
26034 {
26035 /* Skip truncation and continuation glyphs near the end of the
26036 row, and also blanks and stretch glyphs inserted by
26037 extend_face_to_end_of_line. */
26038 while (end > glyph
26039 && INTEGERP ((end - 1)->object)
26040 && (end - 1)->charpos <= 0)
26041 --end;
26042 /* Scan the rest of the glyph row from the end, looking for the
26043 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
26044 COVER_STRING, or whose position is between START_CHARPOS
26045 and END_CHARPOS */
26046 for (--end;
26047 end > glyph
26048 && !INTEGERP (end->object)
26049 && !EQ (end->object, cover_string)
26050 && !(BUFFERP (end->object)
26051 && (end->charpos >= start_charpos
26052 && end->charpos < end_charpos));
26053 --end)
26054 {
26055 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26056 are present at buffer positions between START_CHARPOS and
26057 END_CHARPOS, or if they come from an overlay. */
26058 if (EQ (end->object, before_string))
26059 {
26060 pos = string_buffer_position (before_string, start_charpos);
26061 if (!pos || (pos >= start_charpos && pos < end_charpos))
26062 break;
26063 }
26064 else if (EQ (end->object, after_string))
26065 {
26066 pos = string_buffer_position (after_string, end_charpos);
26067 if (!pos || (pos >= start_charpos && pos < end_charpos))
26068 break;
26069 }
26070 }
26071 /* Find the X coordinate of the last glyph to be highlighted. */
26072 for (; glyph <= end; ++glyph)
26073 x += glyph->pixel_width;
26074
26075 hlinfo->mouse_face_end_x = x;
26076 hlinfo->mouse_face_end_col = glyph - r2->glyphs[TEXT_AREA];
26077 }
26078 else
26079 {
26080 /* Skip truncation and continuation glyphs near the end of the
26081 row, and also blanks and stretch glyphs inserted by
26082 extend_face_to_end_of_line. */
26083 x = r2->x;
26084 end++;
26085 while (end < glyph
26086 && INTEGERP (end->object)
26087 && end->charpos <= 0)
26088 {
26089 x += end->pixel_width;
26090 ++end;
26091 }
26092 /* Scan the rest of the glyph row from the end, looking for the
26093 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
26094 COVER_STRING, or whose position is between START_CHARPOS
26095 and END_CHARPOS */
26096 for ( ;
26097 end < glyph
26098 && !INTEGERP (end->object)
26099 && !EQ (end->object, cover_string)
26100 && !(BUFFERP (end->object)
26101 && (end->charpos >= start_charpos
26102 && end->charpos < end_charpos));
26103 ++end)
26104 {
26105 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26106 are present at buffer positions between START_CHARPOS and
26107 END_CHARPOS, or if they come from an overlay. */
26108 if (EQ (end->object, before_string))
26109 {
26110 pos = string_buffer_position (before_string, start_charpos);
26111 if (!pos || (pos >= start_charpos && pos < end_charpos))
26112 break;
26113 }
26114 else if (EQ (end->object, after_string))
26115 {
26116 pos = string_buffer_position (after_string, end_charpos);
26117 if (!pos || (pos >= start_charpos && pos < end_charpos))
26118 break;
26119 }
26120 x += end->pixel_width;
26121 }
26122 hlinfo->mouse_face_end_x = x;
26123 hlinfo->mouse_face_end_col = end - r2->glyphs[TEXT_AREA];
26124 }
26125
26126 hlinfo->mouse_face_window = window;
26127 hlinfo->mouse_face_face_id
26128 = face_at_buffer_position (w, mouse_charpos, 0, 0, &ignore,
26129 mouse_charpos + 1,
26130 !hlinfo->mouse_face_hidden, -1);
26131 show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
26132 }
26133
26134 /* The following function is not used anymore (replaced with
26135 mouse_face_from_string_pos), but I leave it here for the time
26136 being, in case someone would. */
26137
26138 #if 0 /* not used */
26139
26140 /* Find the position of the glyph for position POS in OBJECT in
26141 window W's current matrix, and return in *X, *Y the pixel
26142 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
26143
26144 RIGHT_P non-zero means return the position of the right edge of the
26145 glyph, RIGHT_P zero means return the left edge position.
26146
26147 If no glyph for POS exists in the matrix, return the position of
26148 the glyph with the next smaller position that is in the matrix, if
26149 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
26150 exists in the matrix, return the position of the glyph with the
26151 next larger position in OBJECT.
26152
26153 Value is non-zero if a glyph was found. */
26154
26155 static int
26156 fast_find_string_pos (struct window *w, ptrdiff_t pos, Lisp_Object object,
26157 int *hpos, int *vpos, int *x, int *y, int right_p)
26158 {
26159 int yb = window_text_bottom_y (w);
26160 struct glyph_row *r;
26161 struct glyph *best_glyph = NULL;
26162 struct glyph_row *best_row = NULL;
26163 int best_x = 0;
26164
26165 for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
26166 r->enabled_p && r->y < yb;
26167 ++r)
26168 {
26169 struct glyph *g = r->glyphs[TEXT_AREA];
26170 struct glyph *e = g + r->used[TEXT_AREA];
26171 int gx;
26172
26173 for (gx = r->x; g < e; gx += g->pixel_width, ++g)
26174 if (EQ (g->object, object))
26175 {
26176 if (g->charpos == pos)
26177 {
26178 best_glyph = g;
26179 best_x = gx;
26180 best_row = r;
26181 goto found;
26182 }
26183 else if (best_glyph == NULL
26184 || ((eabs (g->charpos - pos)
26185 < eabs (best_glyph->charpos - pos))
26186 && (right_p
26187 ? g->charpos < pos
26188 : g->charpos > pos)))
26189 {
26190 best_glyph = g;
26191 best_x = gx;
26192 best_row = r;
26193 }
26194 }
26195 }
26196
26197 found:
26198
26199 if (best_glyph)
26200 {
26201 *x = best_x;
26202 *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
26203
26204 if (right_p)
26205 {
26206 *x += best_glyph->pixel_width;
26207 ++*hpos;
26208 }
26209
26210 *y = best_row->y;
26211 *vpos = best_row - w->current_matrix->rows;
26212 }
26213
26214 return best_glyph != NULL;
26215 }
26216 #endif /* not used */
26217
26218 /* Find the positions of the first and the last glyphs in window W's
26219 current matrix that occlude positions [STARTPOS..ENDPOS] in OBJECT
26220 (assumed to be a string), and return in HLINFO's mouse_face_*
26221 members the pixel and column/row coordinates of those glyphs. */
26222
26223 static void
26224 mouse_face_from_string_pos (struct window *w, Mouse_HLInfo *hlinfo,
26225 Lisp_Object object,
26226 ptrdiff_t startpos, ptrdiff_t endpos)
26227 {
26228 int yb = window_text_bottom_y (w);
26229 struct glyph_row *r;
26230 struct glyph *g, *e;
26231 int gx;
26232 int found = 0;
26233
26234 /* Find the glyph row with at least one position in the range
26235 [STARTPOS..ENDPOS], and the first glyph in that row whose
26236 position belongs to that range. */
26237 for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
26238 r->enabled_p && r->y < yb;
26239 ++r)
26240 {
26241 if (!r->reversed_p)
26242 {
26243 g = r->glyphs[TEXT_AREA];
26244 e = g + r->used[TEXT_AREA];
26245 for (gx = r->x; g < e; gx += g->pixel_width, ++g)
26246 if (EQ (g->object, object)
26247 && startpos <= g->charpos && g->charpos <= endpos)
26248 {
26249 hlinfo->mouse_face_beg_row = r - w->current_matrix->rows;
26250 hlinfo->mouse_face_beg_y = r->y;
26251 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
26252 hlinfo->mouse_face_beg_x = gx;
26253 found = 1;
26254 break;
26255 }
26256 }
26257 else
26258 {
26259 struct glyph *g1;
26260
26261 e = r->glyphs[TEXT_AREA];
26262 g = e + r->used[TEXT_AREA];
26263 for ( ; g > e; --g)
26264 if (EQ ((g-1)->object, object)
26265 && startpos <= (g-1)->charpos && (g-1)->charpos <= endpos)
26266 {
26267 hlinfo->mouse_face_beg_row = r - w->current_matrix->rows;
26268 hlinfo->mouse_face_beg_y = r->y;
26269 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
26270 for (gx = r->x, g1 = r->glyphs[TEXT_AREA]; g1 < g; ++g1)
26271 gx += g1->pixel_width;
26272 hlinfo->mouse_face_beg_x = gx;
26273 found = 1;
26274 break;
26275 }
26276 }
26277 if (found)
26278 break;
26279 }
26280
26281 if (!found)
26282 return;
26283
26284 /* Starting with the next row, look for the first row which does NOT
26285 include any glyphs whose positions are in the range. */
26286 for (++r; r->enabled_p && r->y < yb; ++r)
26287 {
26288 g = r->glyphs[TEXT_AREA];
26289 e = g + r->used[TEXT_AREA];
26290 found = 0;
26291 for ( ; g < e; ++g)
26292 if (EQ (g->object, object)
26293 && startpos <= g->charpos && g->charpos <= endpos)
26294 {
26295 found = 1;
26296 break;
26297 }
26298 if (!found)
26299 break;
26300 }
26301
26302 /* The highlighted region ends on the previous row. */
26303 r--;
26304
26305 /* Set the end row and its vertical pixel coordinate. */
26306 hlinfo->mouse_face_end_row = r - w->current_matrix->rows;
26307 hlinfo->mouse_face_end_y = r->y;
26308
26309 /* Compute and set the end column and the end column's horizontal
26310 pixel coordinate. */
26311 if (!r->reversed_p)
26312 {
26313 g = r->glyphs[TEXT_AREA];
26314 e = g + r->used[TEXT_AREA];
26315 for ( ; e > g; --e)
26316 if (EQ ((e-1)->object, object)
26317 && startpos <= (e-1)->charpos && (e-1)->charpos <= endpos)
26318 break;
26319 hlinfo->mouse_face_end_col = e - g;
26320
26321 for (gx = r->x; g < e; ++g)
26322 gx += g->pixel_width;
26323 hlinfo->mouse_face_end_x = gx;
26324 }
26325 else
26326 {
26327 e = r->glyphs[TEXT_AREA];
26328 g = e + r->used[TEXT_AREA];
26329 for (gx = r->x ; e < g; ++e)
26330 {
26331 if (EQ (e->object, object)
26332 && startpos <= e->charpos && e->charpos <= endpos)
26333 break;
26334 gx += e->pixel_width;
26335 }
26336 hlinfo->mouse_face_end_col = e - r->glyphs[TEXT_AREA];
26337 hlinfo->mouse_face_end_x = gx;
26338 }
26339 }
26340
26341 #ifdef HAVE_WINDOW_SYSTEM
26342
26343 /* See if position X, Y is within a hot-spot of an image. */
26344
26345 static int
26346 on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
26347 {
26348 if (!CONSP (hot_spot))
26349 return 0;
26350
26351 if (EQ (XCAR (hot_spot), Qrect))
26352 {
26353 /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1)) */
26354 Lisp_Object rect = XCDR (hot_spot);
26355 Lisp_Object tem;
26356 if (!CONSP (rect))
26357 return 0;
26358 if (!CONSP (XCAR (rect)))
26359 return 0;
26360 if (!CONSP (XCDR (rect)))
26361 return 0;
26362 if (!(tem = XCAR (XCAR (rect)), INTEGERP (tem) && x >= XINT (tem)))
26363 return 0;
26364 if (!(tem = XCDR (XCAR (rect)), INTEGERP (tem) && y >= XINT (tem)))
26365 return 0;
26366 if (!(tem = XCAR (XCDR (rect)), INTEGERP (tem) && x <= XINT (tem)))
26367 return 0;
26368 if (!(tem = XCDR (XCDR (rect)), INTEGERP (tem) && y <= XINT (tem)))
26369 return 0;
26370 return 1;
26371 }
26372 else if (EQ (XCAR (hot_spot), Qcircle))
26373 {
26374 /* CDR is (Center . Radius) = ((x0 . y0) . r) */
26375 Lisp_Object circ = XCDR (hot_spot);
26376 Lisp_Object lr, lx0, ly0;
26377 if (CONSP (circ)
26378 && CONSP (XCAR (circ))
26379 && (lr = XCDR (circ), INTEGERP (lr) || FLOATP (lr))
26380 && (lx0 = XCAR (XCAR (circ)), INTEGERP (lx0))
26381 && (ly0 = XCDR (XCAR (circ)), INTEGERP (ly0)))
26382 {
26383 double r = XFLOATINT (lr);
26384 double dx = XINT (lx0) - x;
26385 double dy = XINT (ly0) - y;
26386 return (dx * dx + dy * dy <= r * r);
26387 }
26388 }
26389 else if (EQ (XCAR (hot_spot), Qpoly))
26390 {
26391 /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
26392 if (VECTORP (XCDR (hot_spot)))
26393 {
26394 struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
26395 Lisp_Object *poly = v->contents;
26396 ptrdiff_t n = v->header.size;
26397 ptrdiff_t i;
26398 int inside = 0;
26399 Lisp_Object lx, ly;
26400 int x0, y0;
26401
26402 /* Need an even number of coordinates, and at least 3 edges. */
26403 if (n < 6 || n & 1)
26404 return 0;
26405
26406 /* Count edge segments intersecting line from (X,Y) to (X,infinity).
26407 If count is odd, we are inside polygon. Pixels on edges
26408 may or may not be included depending on actual geometry of the
26409 polygon. */
26410 if ((lx = poly[n-2], !INTEGERP (lx))
26411 || (ly = poly[n-1], !INTEGERP (lx)))
26412 return 0;
26413 x0 = XINT (lx), y0 = XINT (ly);
26414 for (i = 0; i < n; i += 2)
26415 {
26416 int x1 = x0, y1 = y0;
26417 if ((lx = poly[i], !INTEGERP (lx))
26418 || (ly = poly[i+1], !INTEGERP (ly)))
26419 return 0;
26420 x0 = XINT (lx), y0 = XINT (ly);
26421
26422 /* Does this segment cross the X line? */
26423 if (x0 >= x)
26424 {
26425 if (x1 >= x)
26426 continue;
26427 }
26428 else if (x1 < x)
26429 continue;
26430 if (y > y0 && y > y1)
26431 continue;
26432 if (y < y0 + ((y1 - y0) * (x - x0)) / (x1 - x0))
26433 inside = !inside;
26434 }
26435 return inside;
26436 }
26437 }
26438 return 0;
26439 }
26440
26441 Lisp_Object
26442 find_hot_spot (Lisp_Object map, int x, int y)
26443 {
26444 while (CONSP (map))
26445 {
26446 if (CONSP (XCAR (map))
26447 && on_hot_spot_p (XCAR (XCAR (map)), x, y))
26448 return XCAR (map);
26449 map = XCDR (map);
26450 }
26451
26452 return Qnil;
26453 }
26454
26455 DEFUN ("lookup-image-map", Flookup_image_map, Slookup_image_map,
26456 3, 3, 0,
26457 doc: /* Lookup in image map MAP coordinates X and Y.
26458 An image map is an alist where each element has the format (AREA ID PLIST).
26459 An AREA is specified as either a rectangle, a circle, or a polygon:
26460 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
26461 pixel coordinates of the upper left and bottom right corners.
26462 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
26463 and the radius of the circle; r may be a float or integer.
26464 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
26465 vector describes one corner in the polygon.
26466 Returns the alist element for the first matching AREA in MAP. */)
26467 (Lisp_Object map, Lisp_Object x, Lisp_Object y)
26468 {
26469 if (NILP (map))
26470 return Qnil;
26471
26472 CHECK_NUMBER (x);
26473 CHECK_NUMBER (y);
26474
26475 return find_hot_spot (map,
26476 clip_to_bounds (INT_MIN, XINT (x), INT_MAX),
26477 clip_to_bounds (INT_MIN, XINT (y), INT_MAX));
26478 }
26479
26480
26481 /* Display frame CURSOR, optionally using shape defined by POINTER. */
26482 static void
26483 define_frame_cursor1 (struct frame *f, Cursor cursor, Lisp_Object pointer)
26484 {
26485 /* Do not change cursor shape while dragging mouse. */
26486 if (!NILP (do_mouse_tracking))
26487 return;
26488
26489 if (!NILP (pointer))
26490 {
26491 if (EQ (pointer, Qarrow))
26492 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
26493 else if (EQ (pointer, Qhand))
26494 cursor = FRAME_X_OUTPUT (f)->hand_cursor;
26495 else if (EQ (pointer, Qtext))
26496 cursor = FRAME_X_OUTPUT (f)->text_cursor;
26497 else if (EQ (pointer, intern ("hdrag")))
26498 cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
26499 #ifdef HAVE_X_WINDOWS
26500 else if (EQ (pointer, intern ("vdrag")))
26501 cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
26502 #endif
26503 else if (EQ (pointer, intern ("hourglass")))
26504 cursor = FRAME_X_OUTPUT (f)->hourglass_cursor;
26505 else if (EQ (pointer, Qmodeline))
26506 cursor = FRAME_X_OUTPUT (f)->modeline_cursor;
26507 else
26508 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
26509 }
26510
26511 if (cursor != No_Cursor)
26512 FRAME_RIF (f)->define_frame_cursor (f, cursor);
26513 }
26514
26515 #endif /* HAVE_WINDOW_SYSTEM */
26516
26517 /* Take proper action when mouse has moved to the mode or header line
26518 or marginal area AREA of window W, x-position X and y-position Y.
26519 X is relative to the start of the text display area of W, so the
26520 width of bitmap areas and scroll bars must be subtracted to get a
26521 position relative to the start of the mode line. */
26522
26523 static void
26524 note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
26525 enum window_part area)
26526 {
26527 struct window *w = XWINDOW (window);
26528 struct frame *f = XFRAME (w->frame);
26529 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
26530 #ifdef HAVE_WINDOW_SYSTEM
26531 Display_Info *dpyinfo;
26532 #endif
26533 Cursor cursor = No_Cursor;
26534 Lisp_Object pointer = Qnil;
26535 int dx, dy, width, height;
26536 ptrdiff_t charpos;
26537 Lisp_Object string, object = Qnil;
26538 Lisp_Object pos, help;
26539
26540 Lisp_Object mouse_face;
26541 int original_x_pixel = x;
26542 struct glyph * glyph = NULL, * row_start_glyph = NULL;
26543 struct glyph_row *row;
26544
26545 if (area == ON_MODE_LINE || area == ON_HEADER_LINE)
26546 {
26547 int x0;
26548 struct glyph *end;
26549
26550 /* Kludge alert: mode_line_string takes X/Y in pixels, but
26551 returns them in row/column units! */
26552 string = mode_line_string (w, area, &x, &y, &charpos,
26553 &object, &dx, &dy, &width, &height);
26554
26555 row = (area == ON_MODE_LINE
26556 ? MATRIX_MODE_LINE_ROW (w->current_matrix)
26557 : MATRIX_HEADER_LINE_ROW (w->current_matrix));
26558
26559 /* Find the glyph under the mouse pointer. */
26560 if (row->mode_line_p && row->enabled_p)
26561 {
26562 glyph = row_start_glyph = row->glyphs[TEXT_AREA];
26563 end = glyph + row->used[TEXT_AREA];
26564
26565 for (x0 = original_x_pixel;
26566 glyph < end && x0 >= glyph->pixel_width;
26567 ++glyph)
26568 x0 -= glyph->pixel_width;
26569
26570 if (glyph >= end)
26571 glyph = NULL;
26572 }
26573 }
26574 else
26575 {
26576 x -= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
26577 /* Kludge alert: marginal_area_string takes X/Y in pixels, but
26578 returns them in row/column units! */
26579 string = marginal_area_string (w, area, &x, &y, &charpos,
26580 &object, &dx, &dy, &width, &height);
26581 }
26582
26583 help = Qnil;
26584
26585 #ifdef HAVE_WINDOW_SYSTEM
26586 if (IMAGEP (object))
26587 {
26588 Lisp_Object image_map, hotspot;
26589 if ((image_map = Fplist_get (XCDR (object), QCmap),
26590 !NILP (image_map))
26591 && (hotspot = find_hot_spot (image_map, dx, dy),
26592 CONSP (hotspot))
26593 && (hotspot = XCDR (hotspot), CONSP (hotspot)))
26594 {
26595 Lisp_Object plist;
26596
26597 /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
26598 If so, we could look for mouse-enter, mouse-leave
26599 properties in PLIST (and do something...). */
26600 hotspot = XCDR (hotspot);
26601 if (CONSP (hotspot)
26602 && (plist = XCAR (hotspot), CONSP (plist)))
26603 {
26604 pointer = Fplist_get (plist, Qpointer);
26605 if (NILP (pointer))
26606 pointer = Qhand;
26607 help = Fplist_get (plist, Qhelp_echo);
26608 if (!NILP (help))
26609 {
26610 help_echo_string = help;
26611 /* Is this correct? ++kfs */
26612 XSETWINDOW (help_echo_window, w);
26613 help_echo_object = w->buffer;
26614 help_echo_pos = charpos;
26615 }
26616 }
26617 }
26618 if (NILP (pointer))
26619 pointer = Fplist_get (XCDR (object), QCpointer);
26620 }
26621 #endif /* HAVE_WINDOW_SYSTEM */
26622
26623 if (STRINGP (string))
26624 {
26625 pos = make_number (charpos);
26626 /* If we're on a string with `help-echo' text property, arrange
26627 for the help to be displayed. This is done by setting the
26628 global variable help_echo_string to the help string. */
26629 if (NILP (help))
26630 {
26631 help = Fget_text_property (pos, Qhelp_echo, string);
26632 if (!NILP (help))
26633 {
26634 help_echo_string = help;
26635 XSETWINDOW (help_echo_window, w);
26636 help_echo_object = string;
26637 help_echo_pos = charpos;
26638 }
26639 }
26640
26641 #ifdef HAVE_WINDOW_SYSTEM
26642 if (FRAME_WINDOW_P (f))
26643 {
26644 dpyinfo = FRAME_X_DISPLAY_INFO (f);
26645 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
26646 if (NILP (pointer))
26647 pointer = Fget_text_property (pos, Qpointer, string);
26648
26649 /* Change the mouse pointer according to what is under X/Y. */
26650 if (NILP (pointer)
26651 && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)))
26652 {
26653 Lisp_Object map;
26654 map = Fget_text_property (pos, Qlocal_map, string);
26655 if (!KEYMAPP (map))
26656 map = Fget_text_property (pos, Qkeymap, string);
26657 if (!KEYMAPP (map))
26658 cursor = dpyinfo->vertical_scroll_bar_cursor;
26659 }
26660 }
26661 #endif
26662
26663 /* Change the mouse face according to what is under X/Y. */
26664 mouse_face = Fget_text_property (pos, Qmouse_face, string);
26665 if (!NILP (mouse_face)
26666 && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
26667 && glyph)
26668 {
26669 Lisp_Object b, e;
26670
26671 struct glyph * tmp_glyph;
26672
26673 int gpos;
26674 int gseq_length;
26675 int total_pixel_width;
26676 ptrdiff_t begpos, endpos, ignore;
26677
26678 int vpos, hpos;
26679
26680 b = Fprevious_single_property_change (make_number (charpos + 1),
26681 Qmouse_face, string, Qnil);
26682 if (NILP (b))
26683 begpos = 0;
26684 else
26685 begpos = XINT (b);
26686
26687 e = Fnext_single_property_change (pos, Qmouse_face, string, Qnil);
26688 if (NILP (e))
26689 endpos = SCHARS (string);
26690 else
26691 endpos = XINT (e);
26692
26693 /* Calculate the glyph position GPOS of GLYPH in the
26694 displayed string, relative to the beginning of the
26695 highlighted part of the string.
26696
26697 Note: GPOS is different from CHARPOS. CHARPOS is the
26698 position of GLYPH in the internal string object. A mode
26699 line string format has structures which are converted to
26700 a flattened string by the Emacs Lisp interpreter. The
26701 internal string is an element of those structures. The
26702 displayed string is the flattened string. */
26703 tmp_glyph = row_start_glyph;
26704 while (tmp_glyph < glyph
26705 && (!(EQ (tmp_glyph->object, glyph->object)
26706 && begpos <= tmp_glyph->charpos
26707 && tmp_glyph->charpos < endpos)))
26708 tmp_glyph++;
26709 gpos = glyph - tmp_glyph;
26710
26711 /* Calculate the length GSEQ_LENGTH of the glyph sequence of
26712 the highlighted part of the displayed string to which
26713 GLYPH belongs. Note: GSEQ_LENGTH is different from
26714 SCHARS (STRING), because the latter returns the length of
26715 the internal string. */
26716 for (tmp_glyph = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
26717 tmp_glyph > glyph
26718 && (!(EQ (tmp_glyph->object, glyph->object)
26719 && begpos <= tmp_glyph->charpos
26720 && tmp_glyph->charpos < endpos));
26721 tmp_glyph--)
26722 ;
26723 gseq_length = gpos + (tmp_glyph - glyph) + 1;
26724
26725 /* Calculate the total pixel width of all the glyphs between
26726 the beginning of the highlighted area and GLYPH. */
26727 total_pixel_width = 0;
26728 for (tmp_glyph = glyph - gpos; tmp_glyph != glyph; tmp_glyph++)
26729 total_pixel_width += tmp_glyph->pixel_width;
26730
26731 /* Pre calculation of re-rendering position. Note: X is in
26732 column units here, after the call to mode_line_string or
26733 marginal_area_string. */
26734 hpos = x - gpos;
26735 vpos = (area == ON_MODE_LINE
26736 ? (w->current_matrix)->nrows - 1
26737 : 0);
26738
26739 /* If GLYPH's position is included in the region that is
26740 already drawn in mouse face, we have nothing to do. */
26741 if ( EQ (window, hlinfo->mouse_face_window)
26742 && (!row->reversed_p
26743 ? (hlinfo->mouse_face_beg_col <= hpos
26744 && hpos < hlinfo->mouse_face_end_col)
26745 /* In R2L rows we swap BEG and END, see below. */
26746 : (hlinfo->mouse_face_end_col <= hpos
26747 && hpos < hlinfo->mouse_face_beg_col))
26748 && hlinfo->mouse_face_beg_row == vpos )
26749 return;
26750
26751 if (clear_mouse_face (hlinfo))
26752 cursor = No_Cursor;
26753
26754 if (!row->reversed_p)
26755 {
26756 hlinfo->mouse_face_beg_col = hpos;
26757 hlinfo->mouse_face_beg_x = original_x_pixel
26758 - (total_pixel_width + dx);
26759 hlinfo->mouse_face_end_col = hpos + gseq_length;
26760 hlinfo->mouse_face_end_x = 0;
26761 }
26762 else
26763 {
26764 /* In R2L rows, show_mouse_face expects BEG and END
26765 coordinates to be swapped. */
26766 hlinfo->mouse_face_end_col = hpos;
26767 hlinfo->mouse_face_end_x = original_x_pixel
26768 - (total_pixel_width + dx);
26769 hlinfo->mouse_face_beg_col = hpos + gseq_length;
26770 hlinfo->mouse_face_beg_x = 0;
26771 }
26772
26773 hlinfo->mouse_face_beg_row = vpos;
26774 hlinfo->mouse_face_end_row = hlinfo->mouse_face_beg_row;
26775 hlinfo->mouse_face_beg_y = 0;
26776 hlinfo->mouse_face_end_y = 0;
26777 hlinfo->mouse_face_past_end = 0;
26778 hlinfo->mouse_face_window = window;
26779
26780 hlinfo->mouse_face_face_id = face_at_string_position (w, string,
26781 charpos,
26782 0, 0, 0,
26783 &ignore,
26784 glyph->face_id,
26785 1);
26786 show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
26787
26788 if (NILP (pointer))
26789 pointer = Qhand;
26790 }
26791 else if ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
26792 clear_mouse_face (hlinfo);
26793 }
26794 #ifdef HAVE_WINDOW_SYSTEM
26795 if (FRAME_WINDOW_P (f))
26796 define_frame_cursor1 (f, cursor, pointer);
26797 #endif
26798 }
26799
26800
26801 /* EXPORT:
26802 Take proper action when the mouse has moved to position X, Y on
26803 frame F as regards highlighting characters that have mouse-face
26804 properties. Also de-highlighting chars where the mouse was before.
26805 X and Y can be negative or out of range. */
26806
26807 void
26808 note_mouse_highlight (struct frame *f, int x, int y)
26809 {
26810 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
26811 enum window_part part;
26812 Lisp_Object window;
26813 struct window *w;
26814 Cursor cursor = No_Cursor;
26815 Lisp_Object pointer = Qnil; /* Takes precedence over cursor! */
26816 struct buffer *b;
26817
26818 /* When a menu is active, don't highlight because this looks odd. */
26819 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (MSDOS)
26820 if (popup_activated ())
26821 return;
26822 #endif
26823
26824 if (NILP (Vmouse_highlight)
26825 || !f->glyphs_initialized_p
26826 || f->pointer_invisible)
26827 return;
26828
26829 hlinfo->mouse_face_mouse_x = x;
26830 hlinfo->mouse_face_mouse_y = y;
26831 hlinfo->mouse_face_mouse_frame = f;
26832
26833 if (hlinfo->mouse_face_defer)
26834 return;
26835
26836 if (gc_in_progress)
26837 {
26838 hlinfo->mouse_face_deferred_gc = 1;
26839 return;
26840 }
26841
26842 /* Which window is that in? */
26843 window = window_from_coordinates (f, x, y, &part, 1);
26844
26845 /* If we were displaying active text in another window, clear that.
26846 Also clear if we move out of text area in same window. */
26847 if (! EQ (window, hlinfo->mouse_face_window)
26848 || (part != ON_TEXT && part != ON_MODE_LINE && part != ON_HEADER_LINE
26849 && !NILP (hlinfo->mouse_face_window)))
26850 clear_mouse_face (hlinfo);
26851
26852 /* Not on a window -> return. */
26853 if (!WINDOWP (window))
26854 return;
26855
26856 /* Reset help_echo_string. It will get recomputed below. */
26857 help_echo_string = Qnil;
26858
26859 /* Convert to window-relative pixel coordinates. */
26860 w = XWINDOW (window);
26861 frame_to_window_pixel_xy (w, &x, &y);
26862
26863 #ifdef HAVE_WINDOW_SYSTEM
26864 /* Handle tool-bar window differently since it doesn't display a
26865 buffer. */
26866 if (EQ (window, f->tool_bar_window))
26867 {
26868 note_tool_bar_highlight (f, x, y);
26869 return;
26870 }
26871 #endif
26872
26873 /* Mouse is on the mode, header line or margin? */
26874 if (part == ON_MODE_LINE || part == ON_HEADER_LINE
26875 || part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
26876 {
26877 note_mode_line_or_margin_highlight (window, x, y, part);
26878 return;
26879 }
26880
26881 #ifdef HAVE_WINDOW_SYSTEM
26882 if (part == ON_VERTICAL_BORDER)
26883 {
26884 cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
26885 help_echo_string = build_string ("drag-mouse-1: resize");
26886 }
26887 else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
26888 || part == ON_SCROLL_BAR)
26889 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
26890 else
26891 cursor = FRAME_X_OUTPUT (f)->text_cursor;
26892 #endif
26893
26894 /* Are we in a window whose display is up to date?
26895 And verify the buffer's text has not changed. */
26896 b = XBUFFER (w->buffer);
26897 if (part == ON_TEXT
26898 && EQ (w->window_end_valid, w->buffer)
26899 && XFASTINT (w->last_modified) == BUF_MODIFF (b)
26900 && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
26901 {
26902 int hpos, vpos, dx, dy, area;
26903 ptrdiff_t pos;
26904 struct glyph *glyph;
26905 Lisp_Object object;
26906 Lisp_Object mouse_face = Qnil, position;
26907 Lisp_Object *overlay_vec = NULL;
26908 ptrdiff_t i, noverlays;
26909 struct buffer *obuf;
26910 ptrdiff_t obegv, ozv;
26911 int same_region;
26912
26913 /* Find the glyph under X/Y. */
26914 glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &dx, &dy, &area);
26915
26916 #ifdef HAVE_WINDOW_SYSTEM
26917 /* Look for :pointer property on image. */
26918 if (glyph != NULL && glyph->type == IMAGE_GLYPH)
26919 {
26920 struct image *img = IMAGE_FROM_ID (f, glyph->u.img_id);
26921 if (img != NULL && IMAGEP (img->spec))
26922 {
26923 Lisp_Object image_map, hotspot;
26924 if ((image_map = Fplist_get (XCDR (img->spec), QCmap),
26925 !NILP (image_map))
26926 && (hotspot = find_hot_spot (image_map,
26927 glyph->slice.img.x + dx,
26928 glyph->slice.img.y + dy),
26929 CONSP (hotspot))
26930 && (hotspot = XCDR (hotspot), CONSP (hotspot)))
26931 {
26932 Lisp_Object plist;
26933
26934 /* Could check XCAR (hotspot) to see if we enter/leave
26935 this hot-spot.
26936 If so, we could look for mouse-enter, mouse-leave
26937 properties in PLIST (and do something...). */
26938 hotspot = XCDR (hotspot);
26939 if (CONSP (hotspot)
26940 && (plist = XCAR (hotspot), CONSP (plist)))
26941 {
26942 pointer = Fplist_get (plist, Qpointer);
26943 if (NILP (pointer))
26944 pointer = Qhand;
26945 help_echo_string = Fplist_get (plist, Qhelp_echo);
26946 if (!NILP (help_echo_string))
26947 {
26948 help_echo_window = window;
26949 help_echo_object = glyph->object;
26950 help_echo_pos = glyph->charpos;
26951 }
26952 }
26953 }
26954 if (NILP (pointer))
26955 pointer = Fplist_get (XCDR (img->spec), QCpointer);
26956 }
26957 }
26958 #endif /* HAVE_WINDOW_SYSTEM */
26959
26960 /* Clear mouse face if X/Y not over text. */
26961 if (glyph == NULL
26962 || area != TEXT_AREA
26963 || !MATRIX_ROW (w->current_matrix, vpos)->displays_text_p
26964 /* Glyph's OBJECT is an integer for glyphs inserted by the
26965 display engine for its internal purposes, like truncation
26966 and continuation glyphs and blanks beyond the end of
26967 line's text on text terminals. If we are over such a
26968 glyph, we are not over any text. */
26969 || INTEGERP (glyph->object)
26970 /* R2L rows have a stretch glyph at their front, which
26971 stands for no text, whereas L2R rows have no glyphs at
26972 all beyond the end of text. Treat such stretch glyphs
26973 like we do with NULL glyphs in L2R rows. */
26974 || (MATRIX_ROW (w->current_matrix, vpos)->reversed_p
26975 && glyph == MATRIX_ROW (w->current_matrix, vpos)->glyphs[TEXT_AREA]
26976 && glyph->type == STRETCH_GLYPH
26977 && glyph->avoid_cursor_p))
26978 {
26979 if (clear_mouse_face (hlinfo))
26980 cursor = No_Cursor;
26981 #ifdef HAVE_WINDOW_SYSTEM
26982 if (FRAME_WINDOW_P (f) && NILP (pointer))
26983 {
26984 if (area != TEXT_AREA)
26985 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
26986 else
26987 pointer = Vvoid_text_area_pointer;
26988 }
26989 #endif
26990 goto set_cursor;
26991 }
26992
26993 pos = glyph->charpos;
26994 object = glyph->object;
26995 if (!STRINGP (object) && !BUFFERP (object))
26996 goto set_cursor;
26997
26998 /* If we get an out-of-range value, return now; avoid an error. */
26999 if (BUFFERP (object) && pos > BUF_Z (b))
27000 goto set_cursor;
27001
27002 /* Make the window's buffer temporarily current for
27003 overlays_at and compute_char_face. */
27004 obuf = current_buffer;
27005 current_buffer = b;
27006 obegv = BEGV;
27007 ozv = ZV;
27008 BEGV = BEG;
27009 ZV = Z;
27010
27011 /* Is this char mouse-active or does it have help-echo? */
27012 position = make_number (pos);
27013
27014 if (BUFFERP (object))
27015 {
27016 /* Put all the overlays we want in a vector in overlay_vec. */
27017 GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL, 0);
27018 /* Sort overlays into increasing priority order. */
27019 noverlays = sort_overlays (overlay_vec, noverlays, w);
27020 }
27021 else
27022 noverlays = 0;
27023
27024 same_region = coords_in_mouse_face_p (w, hpos, vpos);
27025
27026 if (same_region)
27027 cursor = No_Cursor;
27028
27029 /* Check mouse-face highlighting. */
27030 if (! same_region
27031 /* If there exists an overlay with mouse-face overlapping
27032 the one we are currently highlighting, we have to
27033 check if we enter the overlapping overlay, and then
27034 highlight only that. */
27035 || (OVERLAYP (hlinfo->mouse_face_overlay)
27036 && mouse_face_overlay_overlaps (hlinfo->mouse_face_overlay)))
27037 {
27038 /* Find the highest priority overlay with a mouse-face. */
27039 Lisp_Object overlay = Qnil;
27040 for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
27041 {
27042 mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
27043 if (!NILP (mouse_face))
27044 overlay = overlay_vec[i];
27045 }
27046
27047 /* If we're highlighting the same overlay as before, there's
27048 no need to do that again. */
27049 if (!NILP (overlay) && EQ (overlay, hlinfo->mouse_face_overlay))
27050 goto check_help_echo;
27051 hlinfo->mouse_face_overlay = overlay;
27052
27053 /* Clear the display of the old active region, if any. */
27054 if (clear_mouse_face (hlinfo))
27055 cursor = No_Cursor;
27056
27057 /* If no overlay applies, get a text property. */
27058 if (NILP (overlay))
27059 mouse_face = Fget_text_property (position, Qmouse_face, object);
27060
27061 /* Next, compute the bounds of the mouse highlighting and
27062 display it. */
27063 if (!NILP (mouse_face) && STRINGP (object))
27064 {
27065 /* The mouse-highlighting comes from a display string
27066 with a mouse-face. */
27067 Lisp_Object s, e;
27068 ptrdiff_t ignore;
27069
27070 s = Fprevious_single_property_change
27071 (make_number (pos + 1), Qmouse_face, object, Qnil);
27072 e = Fnext_single_property_change
27073 (position, Qmouse_face, object, Qnil);
27074 if (NILP (s))
27075 s = make_number (0);
27076 if (NILP (e))
27077 e = make_number (SCHARS (object) - 1);
27078 mouse_face_from_string_pos (w, hlinfo, object,
27079 XINT (s), XINT (e));
27080 hlinfo->mouse_face_past_end = 0;
27081 hlinfo->mouse_face_window = window;
27082 hlinfo->mouse_face_face_id
27083 = face_at_string_position (w, object, pos, 0, 0, 0, &ignore,
27084 glyph->face_id, 1);
27085 show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
27086 cursor = No_Cursor;
27087 }
27088 else
27089 {
27090 /* The mouse-highlighting, if any, comes from an overlay
27091 or text property in the buffer. */
27092 Lisp_Object buffer IF_LINT (= Qnil);
27093 Lisp_Object cover_string IF_LINT (= Qnil);
27094
27095 if (STRINGP (object))
27096 {
27097 /* If we are on a display string with no mouse-face,
27098 check if the text under it has one. */
27099 struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
27100 ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
27101 pos = string_buffer_position (object, start);
27102 if (pos > 0)
27103 {
27104 mouse_face = get_char_property_and_overlay
27105 (make_number (pos), Qmouse_face, w->buffer, &overlay);
27106 buffer = w->buffer;
27107 cover_string = object;
27108 }
27109 }
27110 else
27111 {
27112 buffer = object;
27113 cover_string = Qnil;
27114 }
27115
27116 if (!NILP (mouse_face))
27117 {
27118 Lisp_Object before, after;
27119 Lisp_Object before_string, after_string;
27120 /* To correctly find the limits of mouse highlight
27121 in a bidi-reordered buffer, we must not use the
27122 optimization of limiting the search in
27123 previous-single-property-change and
27124 next-single-property-change, because
27125 rows_from_pos_range needs the real start and end
27126 positions to DTRT in this case. That's because
27127 the first row visible in a window does not
27128 necessarily display the character whose position
27129 is the smallest. */
27130 Lisp_Object lim1 =
27131 NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
27132 ? Fmarker_position (w->start)
27133 : Qnil;
27134 Lisp_Object lim2 =
27135 NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
27136 ? make_number (BUF_Z (XBUFFER (buffer))
27137 - XFASTINT (w->window_end_pos))
27138 : Qnil;
27139
27140 if (NILP (overlay))
27141 {
27142 /* Handle the text property case. */
27143 before = Fprevious_single_property_change
27144 (make_number (pos + 1), Qmouse_face, buffer, lim1);
27145 after = Fnext_single_property_change
27146 (make_number (pos), Qmouse_face, buffer, lim2);
27147 before_string = after_string = Qnil;
27148 }
27149 else
27150 {
27151 /* Handle the overlay case. */
27152 before = Foverlay_start (overlay);
27153 after = Foverlay_end (overlay);
27154 before_string = Foverlay_get (overlay, Qbefore_string);
27155 after_string = Foverlay_get (overlay, Qafter_string);
27156
27157 if (!STRINGP (before_string)) before_string = Qnil;
27158 if (!STRINGP (after_string)) after_string = Qnil;
27159 }
27160
27161 mouse_face_from_buffer_pos (window, hlinfo, pos,
27162 XFASTINT (before),
27163 XFASTINT (after),
27164 before_string, after_string,
27165 cover_string);
27166 cursor = No_Cursor;
27167 }
27168 }
27169 }
27170
27171 check_help_echo:
27172
27173 /* Look for a `help-echo' property. */
27174 if (NILP (help_echo_string)) {
27175 Lisp_Object help, overlay;
27176
27177 /* Check overlays first. */
27178 help = overlay = Qnil;
27179 for (i = noverlays - 1; i >= 0 && NILP (help); --i)
27180 {
27181 overlay = overlay_vec[i];
27182 help = Foverlay_get (overlay, Qhelp_echo);
27183 }
27184
27185 if (!NILP (help))
27186 {
27187 help_echo_string = help;
27188 help_echo_window = window;
27189 help_echo_object = overlay;
27190 help_echo_pos = pos;
27191 }
27192 else
27193 {
27194 Lisp_Object obj = glyph->object;
27195 ptrdiff_t charpos = glyph->charpos;
27196
27197 /* Try text properties. */
27198 if (STRINGP (obj)
27199 && charpos >= 0
27200 && charpos < SCHARS (obj))
27201 {
27202 help = Fget_text_property (make_number (charpos),
27203 Qhelp_echo, obj);
27204 if (NILP (help))
27205 {
27206 /* If the string itself doesn't specify a help-echo,
27207 see if the buffer text ``under'' it does. */
27208 struct glyph_row *r
27209 = MATRIX_ROW (w->current_matrix, vpos);
27210 ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
27211 ptrdiff_t p = string_buffer_position (obj, start);
27212 if (p > 0)
27213 {
27214 help = Fget_char_property (make_number (p),
27215 Qhelp_echo, w->buffer);
27216 if (!NILP (help))
27217 {
27218 charpos = p;
27219 obj = w->buffer;
27220 }
27221 }
27222 }
27223 }
27224 else if (BUFFERP (obj)
27225 && charpos >= BEGV
27226 && charpos < ZV)
27227 help = Fget_text_property (make_number (charpos), Qhelp_echo,
27228 obj);
27229
27230 if (!NILP (help))
27231 {
27232 help_echo_string = help;
27233 help_echo_window = window;
27234 help_echo_object = obj;
27235 help_echo_pos = charpos;
27236 }
27237 }
27238 }
27239
27240 #ifdef HAVE_WINDOW_SYSTEM
27241 /* Look for a `pointer' property. */
27242 if (FRAME_WINDOW_P (f) && NILP (pointer))
27243 {
27244 /* Check overlays first. */
27245 for (i = noverlays - 1; i >= 0 && NILP (pointer); --i)
27246 pointer = Foverlay_get (overlay_vec[i], Qpointer);
27247
27248 if (NILP (pointer))
27249 {
27250 Lisp_Object obj = glyph->object;
27251 ptrdiff_t charpos = glyph->charpos;
27252
27253 /* Try text properties. */
27254 if (STRINGP (obj)
27255 && charpos >= 0
27256 && charpos < SCHARS (obj))
27257 {
27258 pointer = Fget_text_property (make_number (charpos),
27259 Qpointer, obj);
27260 if (NILP (pointer))
27261 {
27262 /* If the string itself doesn't specify a pointer,
27263 see if the buffer text ``under'' it does. */
27264 struct glyph_row *r
27265 = MATRIX_ROW (w->current_matrix, vpos);
27266 ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
27267 ptrdiff_t p = string_buffer_position (obj, start);
27268 if (p > 0)
27269 pointer = Fget_char_property (make_number (p),
27270 Qpointer, w->buffer);
27271 }
27272 }
27273 else if (BUFFERP (obj)
27274 && charpos >= BEGV
27275 && charpos < ZV)
27276 pointer = Fget_text_property (make_number (charpos),
27277 Qpointer, obj);
27278 }
27279 }
27280 #endif /* HAVE_WINDOW_SYSTEM */
27281
27282 BEGV = obegv;
27283 ZV = ozv;
27284 current_buffer = obuf;
27285 }
27286
27287 set_cursor:
27288
27289 #ifdef HAVE_WINDOW_SYSTEM
27290 if (FRAME_WINDOW_P (f))
27291 define_frame_cursor1 (f, cursor, pointer);
27292 #else
27293 /* This is here to prevent a compiler error, about "label at end of
27294 compound statement". */
27295 return;
27296 #endif
27297 }
27298
27299
27300 /* EXPORT for RIF:
27301 Clear any mouse-face on window W. This function is part of the
27302 redisplay interface, and is called from try_window_id and similar
27303 functions to ensure the mouse-highlight is off. */
27304
27305 void
27306 x_clear_window_mouse_face (struct window *w)
27307 {
27308 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
27309 Lisp_Object window;
27310
27311 BLOCK_INPUT;
27312 XSETWINDOW (window, w);
27313 if (EQ (window, hlinfo->mouse_face_window))
27314 clear_mouse_face (hlinfo);
27315 UNBLOCK_INPUT;
27316 }
27317
27318
27319 /* EXPORT:
27320 Just discard the mouse face information for frame F, if any.
27321 This is used when the size of F is changed. */
27322
27323 void
27324 cancel_mouse_face (struct frame *f)
27325 {
27326 Lisp_Object window;
27327 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
27328
27329 window = hlinfo->mouse_face_window;
27330 if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
27331 {
27332 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
27333 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
27334 hlinfo->mouse_face_window = Qnil;
27335 }
27336 }
27337
27338
27339 \f
27340 /***********************************************************************
27341 Exposure Events
27342 ***********************************************************************/
27343
27344 #ifdef HAVE_WINDOW_SYSTEM
27345
27346 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
27347 which intersects rectangle R. R is in window-relative coordinates. */
27348
27349 static void
27350 expose_area (struct window *w, struct glyph_row *row, XRectangle *r,
27351 enum glyph_row_area area)
27352 {
27353 struct glyph *first = row->glyphs[area];
27354 struct glyph *end = row->glyphs[area] + row->used[area];
27355 struct glyph *last;
27356 int first_x, start_x, x;
27357
27358 if (area == TEXT_AREA && row->fill_line_p)
27359 /* If row extends face to end of line write the whole line. */
27360 draw_glyphs (w, 0, row, area,
27361 0, row->used[area],
27362 DRAW_NORMAL_TEXT, 0);
27363 else
27364 {
27365 /* Set START_X to the window-relative start position for drawing glyphs of
27366 AREA. The first glyph of the text area can be partially visible.
27367 The first glyphs of other areas cannot. */
27368 start_x = window_box_left_offset (w, area);
27369 x = start_x;
27370 if (area == TEXT_AREA)
27371 x += row->x;
27372
27373 /* Find the first glyph that must be redrawn. */
27374 while (first < end
27375 && x + first->pixel_width < r->x)
27376 {
27377 x += first->pixel_width;
27378 ++first;
27379 }
27380
27381 /* Find the last one. */
27382 last = first;
27383 first_x = x;
27384 while (last < end
27385 && x < r->x + r->width)
27386 {
27387 x += last->pixel_width;
27388 ++last;
27389 }
27390
27391 /* Repaint. */
27392 if (last > first)
27393 draw_glyphs (w, first_x - start_x, row, area,
27394 first - row->glyphs[area], last - row->glyphs[area],
27395 DRAW_NORMAL_TEXT, 0);
27396 }
27397 }
27398
27399
27400 /* Redraw the parts of the glyph row ROW on window W intersecting
27401 rectangle R. R is in window-relative coordinates. Value is
27402 non-zero if mouse-face was overwritten. */
27403
27404 static int
27405 expose_line (struct window *w, struct glyph_row *row, XRectangle *r)
27406 {
27407 xassert (row->enabled_p);
27408
27409 if (row->mode_line_p || w->pseudo_window_p)
27410 draw_glyphs (w, 0, row, TEXT_AREA,
27411 0, row->used[TEXT_AREA],
27412 DRAW_NORMAL_TEXT, 0);
27413 else
27414 {
27415 if (row->used[LEFT_MARGIN_AREA])
27416 expose_area (w, row, r, LEFT_MARGIN_AREA);
27417 if (row->used[TEXT_AREA])
27418 expose_area (w, row, r, TEXT_AREA);
27419 if (row->used[RIGHT_MARGIN_AREA])
27420 expose_area (w, row, r, RIGHT_MARGIN_AREA);
27421 draw_row_fringe_bitmaps (w, row);
27422 }
27423
27424 return row->mouse_face_p;
27425 }
27426
27427
27428 /* Redraw those parts of glyphs rows during expose event handling that
27429 overlap other rows. Redrawing of an exposed line writes over parts
27430 of lines overlapping that exposed line; this function fixes that.
27431
27432 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
27433 row in W's current matrix that is exposed and overlaps other rows.
27434 LAST_OVERLAPPING_ROW is the last such row. */
27435
27436 static void
27437 expose_overlaps (struct window *w,
27438 struct glyph_row *first_overlapping_row,
27439 struct glyph_row *last_overlapping_row,
27440 XRectangle *r)
27441 {
27442 struct glyph_row *row;
27443
27444 for (row = first_overlapping_row; row <= last_overlapping_row; ++row)
27445 if (row->overlapping_p)
27446 {
27447 xassert (row->enabled_p && !row->mode_line_p);
27448
27449 row->clip = r;
27450 if (row->used[LEFT_MARGIN_AREA])
27451 x_fix_overlapping_area (w, row, LEFT_MARGIN_AREA, OVERLAPS_BOTH);
27452
27453 if (row->used[TEXT_AREA])
27454 x_fix_overlapping_area (w, row, TEXT_AREA, OVERLAPS_BOTH);
27455
27456 if (row->used[RIGHT_MARGIN_AREA])
27457 x_fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, OVERLAPS_BOTH);
27458 row->clip = NULL;
27459 }
27460 }
27461
27462
27463 /* Return non-zero if W's cursor intersects rectangle R. */
27464
27465 static int
27466 phys_cursor_in_rect_p (struct window *w, XRectangle *r)
27467 {
27468 XRectangle cr, result;
27469 struct glyph *cursor_glyph;
27470 struct glyph_row *row;
27471
27472 if (w->phys_cursor.vpos >= 0
27473 && w->phys_cursor.vpos < w->current_matrix->nrows
27474 && (row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos),
27475 row->enabled_p)
27476 && row->cursor_in_fringe_p)
27477 {
27478 /* Cursor is in the fringe. */
27479 cr.x = window_box_right_offset (w,
27480 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
27481 ? RIGHT_MARGIN_AREA
27482 : TEXT_AREA));
27483 cr.y = row->y;
27484 cr.width = WINDOW_RIGHT_FRINGE_WIDTH (w);
27485 cr.height = row->height;
27486 return x_intersect_rectangles (&cr, r, &result);
27487 }
27488
27489 cursor_glyph = get_phys_cursor_glyph (w);
27490 if (cursor_glyph)
27491 {
27492 /* r is relative to W's box, but w->phys_cursor.x is relative
27493 to left edge of W's TEXT area. Adjust it. */
27494 cr.x = window_box_left_offset (w, TEXT_AREA) + w->phys_cursor.x;
27495 cr.y = w->phys_cursor.y;
27496 cr.width = cursor_glyph->pixel_width;
27497 cr.height = w->phys_cursor_height;
27498 /* ++KFS: W32 version used W32-specific IntersectRect here, but
27499 I assume the effect is the same -- and this is portable. */
27500 return x_intersect_rectangles (&cr, r, &result);
27501 }
27502 /* If we don't understand the format, pretend we're not in the hot-spot. */
27503 return 0;
27504 }
27505
27506
27507 /* EXPORT:
27508 Draw a vertical window border to the right of window W if W doesn't
27509 have vertical scroll bars. */
27510
27511 void
27512 x_draw_vertical_border (struct window *w)
27513 {
27514 struct frame *f = XFRAME (WINDOW_FRAME (w));
27515
27516 /* We could do better, if we knew what type of scroll-bar the adjacent
27517 windows (on either side) have... But we don't :-(
27518 However, I think this works ok. ++KFS 2003-04-25 */
27519
27520 /* Redraw borders between horizontally adjacent windows. Don't
27521 do it for frames with vertical scroll bars because either the
27522 right scroll bar of a window, or the left scroll bar of its
27523 neighbor will suffice as a border. */
27524 if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w->frame)))
27525 return;
27526
27527 if (!WINDOW_RIGHTMOST_P (w)
27528 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
27529 {
27530 int x0, x1, y0, y1;
27531
27532 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
27533 y1 -= 1;
27534
27535 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
27536 x1 -= 1;
27537
27538 FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
27539 }
27540 else if (!WINDOW_LEFTMOST_P (w)
27541 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
27542 {
27543 int x0, x1, y0, y1;
27544
27545 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
27546 y1 -= 1;
27547
27548 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
27549 x0 -= 1;
27550
27551 FRAME_RIF (f)->draw_vertical_window_border (w, x0, y0, y1);
27552 }
27553 }
27554
27555
27556 /* Redraw the part of window W intersection rectangle FR. Pixel
27557 coordinates in FR are frame-relative. Call this function with
27558 input blocked. Value is non-zero if the exposure overwrites
27559 mouse-face. */
27560
27561 static int
27562 expose_window (struct window *w, XRectangle *fr)
27563 {
27564 struct frame *f = XFRAME (w->frame);
27565 XRectangle wr, r;
27566 int mouse_face_overwritten_p = 0;
27567
27568 /* If window is not yet fully initialized, do nothing. This can
27569 happen when toolkit scroll bars are used and a window is split.
27570 Reconfiguring the scroll bar will generate an expose for a newly
27571 created window. */
27572 if (w->current_matrix == NULL)
27573 return 0;
27574
27575 /* When we're currently updating the window, display and current
27576 matrix usually don't agree. Arrange for a thorough display
27577 later. */
27578 if (w == updated_window)
27579 {
27580 SET_FRAME_GARBAGED (f);
27581 return 0;
27582 }
27583
27584 /* Frame-relative pixel rectangle of W. */
27585 wr.x = WINDOW_LEFT_EDGE_X (w);
27586 wr.y = WINDOW_TOP_EDGE_Y (w);
27587 wr.width = WINDOW_TOTAL_WIDTH (w);
27588 wr.height = WINDOW_TOTAL_HEIGHT (w);
27589
27590 if (x_intersect_rectangles (fr, &wr, &r))
27591 {
27592 int yb = window_text_bottom_y (w);
27593 struct glyph_row *row;
27594 int cursor_cleared_p, phys_cursor_on_p;
27595 struct glyph_row *first_overlapping_row, *last_overlapping_row;
27596
27597 TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
27598 r.x, r.y, r.width, r.height));
27599
27600 /* Convert to window coordinates. */
27601 r.x -= WINDOW_LEFT_EDGE_X (w);
27602 r.y -= WINDOW_TOP_EDGE_Y (w);
27603
27604 /* Turn off the cursor. */
27605 if (!w->pseudo_window_p
27606 && phys_cursor_in_rect_p (w, &r))
27607 {
27608 x_clear_cursor (w);
27609 cursor_cleared_p = 1;
27610 }
27611 else
27612 cursor_cleared_p = 0;
27613
27614 /* If the row containing the cursor extends face to end of line,
27615 then expose_area might overwrite the cursor outside the
27616 rectangle and thus notice_overwritten_cursor might clear
27617 w->phys_cursor_on_p. We remember the original value and
27618 check later if it is changed. */
27619 phys_cursor_on_p = w->phys_cursor_on_p;
27620
27621 /* Update lines intersecting rectangle R. */
27622 first_overlapping_row = last_overlapping_row = NULL;
27623 for (row = w->current_matrix->rows;
27624 row->enabled_p;
27625 ++row)
27626 {
27627 int y0 = row->y;
27628 int y1 = MATRIX_ROW_BOTTOM_Y (row);
27629
27630 if ((y0 >= r.y && y0 < r.y + r.height)
27631 || (y1 > r.y && y1 < r.y + r.height)
27632 || (r.y >= y0 && r.y < y1)
27633 || (r.y + r.height > y0 && r.y + r.height < y1))
27634 {
27635 /* A header line may be overlapping, but there is no need
27636 to fix overlapping areas for them. KFS 2005-02-12 */
27637 if (row->overlapping_p && !row->mode_line_p)
27638 {
27639 if (first_overlapping_row == NULL)
27640 first_overlapping_row = row;
27641 last_overlapping_row = row;
27642 }
27643
27644 row->clip = fr;
27645 if (expose_line (w, row, &r))
27646 mouse_face_overwritten_p = 1;
27647 row->clip = NULL;
27648 }
27649 else if (row->overlapping_p)
27650 {
27651 /* We must redraw a row overlapping the exposed area. */
27652 if (y0 < r.y
27653 ? y0 + row->phys_height > r.y
27654 : y0 + row->ascent - row->phys_ascent < r.y +r.height)
27655 {
27656 if (first_overlapping_row == NULL)
27657 first_overlapping_row = row;
27658 last_overlapping_row = row;
27659 }
27660 }
27661
27662 if (y1 >= yb)
27663 break;
27664 }
27665
27666 /* Display the mode line if there is one. */
27667 if (WINDOW_WANTS_MODELINE_P (w)
27668 && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
27669 row->enabled_p)
27670 && row->y < r.y + r.height)
27671 {
27672 if (expose_line (w, row, &r))
27673 mouse_face_overwritten_p = 1;
27674 }
27675
27676 if (!w->pseudo_window_p)
27677 {
27678 /* Fix the display of overlapping rows. */
27679 if (first_overlapping_row)
27680 expose_overlaps (w, first_overlapping_row, last_overlapping_row,
27681 fr);
27682
27683 /* Draw border between windows. */
27684 x_draw_vertical_border (w);
27685
27686 /* Turn the cursor on again. */
27687 if (cursor_cleared_p
27688 || (phys_cursor_on_p && !w->phys_cursor_on_p))
27689 update_window_cursor (w, 1);
27690 }
27691 }
27692
27693 return mouse_face_overwritten_p;
27694 }
27695
27696
27697
27698 /* Redraw (parts) of all windows in the window tree rooted at W that
27699 intersect R. R contains frame pixel coordinates. Value is
27700 non-zero if the exposure overwrites mouse-face. */
27701
27702 static int
27703 expose_window_tree (struct window *w, XRectangle *r)
27704 {
27705 struct frame *f = XFRAME (w->frame);
27706 int mouse_face_overwritten_p = 0;
27707
27708 while (w && !FRAME_GARBAGED_P (f))
27709 {
27710 if (!NILP (w->hchild))
27711 mouse_face_overwritten_p
27712 |= expose_window_tree (XWINDOW (w->hchild), r);
27713 else if (!NILP (w->vchild))
27714 mouse_face_overwritten_p
27715 |= expose_window_tree (XWINDOW (w->vchild), r);
27716 else
27717 mouse_face_overwritten_p |= expose_window (w, r);
27718
27719 w = NILP (w->next) ? NULL : XWINDOW (w->next);
27720 }
27721
27722 return mouse_face_overwritten_p;
27723 }
27724
27725
27726 /* EXPORT:
27727 Redisplay an exposed area of frame F. X and Y are the upper-left
27728 corner of the exposed rectangle. W and H are width and height of
27729 the exposed area. All are pixel values. W or H zero means redraw
27730 the entire frame. */
27731
27732 void
27733 expose_frame (struct frame *f, int x, int y, int w, int h)
27734 {
27735 XRectangle r;
27736 int mouse_face_overwritten_p = 0;
27737
27738 TRACE ((stderr, "expose_frame "));
27739
27740 /* No need to redraw if frame will be redrawn soon. */
27741 if (FRAME_GARBAGED_P (f))
27742 {
27743 TRACE ((stderr, " garbaged\n"));
27744 return;
27745 }
27746
27747 /* If basic faces haven't been realized yet, there is no point in
27748 trying to redraw anything. This can happen when we get an expose
27749 event while Emacs is starting, e.g. by moving another window. */
27750 if (FRAME_FACE_CACHE (f) == NULL
27751 || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
27752 {
27753 TRACE ((stderr, " no faces\n"));
27754 return;
27755 }
27756
27757 if (w == 0 || h == 0)
27758 {
27759 r.x = r.y = 0;
27760 r.width = FRAME_COLUMN_WIDTH (f) * FRAME_COLS (f);
27761 r.height = FRAME_LINE_HEIGHT (f) * FRAME_LINES (f);
27762 }
27763 else
27764 {
27765 r.x = x;
27766 r.y = y;
27767 r.width = w;
27768 r.height = h;
27769 }
27770
27771 TRACE ((stderr, "(%d, %d, %d, %d)\n", r.x, r.y, r.width, r.height));
27772 mouse_face_overwritten_p = expose_window_tree (XWINDOW (f->root_window), &r);
27773
27774 if (WINDOWP (f->tool_bar_window))
27775 mouse_face_overwritten_p
27776 |= expose_window (XWINDOW (f->tool_bar_window), &r);
27777
27778 #ifdef HAVE_X_WINDOWS
27779 #ifndef MSDOS
27780 #ifndef USE_X_TOOLKIT
27781 if (WINDOWP (f->menu_bar_window))
27782 mouse_face_overwritten_p
27783 |= expose_window (XWINDOW (f->menu_bar_window), &r);
27784 #endif /* not USE_X_TOOLKIT */
27785 #endif
27786 #endif
27787
27788 /* Some window managers support a focus-follows-mouse style with
27789 delayed raising of frames. Imagine a partially obscured frame,
27790 and moving the mouse into partially obscured mouse-face on that
27791 frame. The visible part of the mouse-face will be highlighted,
27792 then the WM raises the obscured frame. With at least one WM, KDE
27793 2.1, Emacs is not getting any event for the raising of the frame
27794 (even tried with SubstructureRedirectMask), only Expose events.
27795 These expose events will draw text normally, i.e. not
27796 highlighted. Which means we must redo the highlight here.
27797 Subsume it under ``we love X''. --gerd 2001-08-15 */
27798 /* Included in Windows version because Windows most likely does not
27799 do the right thing if any third party tool offers
27800 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
27801 if (mouse_face_overwritten_p && !FRAME_GARBAGED_P (f))
27802 {
27803 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
27804 if (f == hlinfo->mouse_face_mouse_frame)
27805 {
27806 int mouse_x = hlinfo->mouse_face_mouse_x;
27807 int mouse_y = hlinfo->mouse_face_mouse_y;
27808 clear_mouse_face (hlinfo);
27809 note_mouse_highlight (f, mouse_x, mouse_y);
27810 }
27811 }
27812 }
27813
27814
27815 /* EXPORT:
27816 Determine the intersection of two rectangles R1 and R2. Return
27817 the intersection in *RESULT. Value is non-zero if RESULT is not
27818 empty. */
27819
27820 int
27821 x_intersect_rectangles (XRectangle *r1, XRectangle *r2, XRectangle *result)
27822 {
27823 XRectangle *left, *right;
27824 XRectangle *upper, *lower;
27825 int intersection_p = 0;
27826
27827 /* Rearrange so that R1 is the left-most rectangle. */
27828 if (r1->x < r2->x)
27829 left = r1, right = r2;
27830 else
27831 left = r2, right = r1;
27832
27833 /* X0 of the intersection is right.x0, if this is inside R1,
27834 otherwise there is no intersection. */
27835 if (right->x <= left->x + left->width)
27836 {
27837 result->x = right->x;
27838
27839 /* The right end of the intersection is the minimum of
27840 the right ends of left and right. */
27841 result->width = (min (left->x + left->width, right->x + right->width)
27842 - result->x);
27843
27844 /* Same game for Y. */
27845 if (r1->y < r2->y)
27846 upper = r1, lower = r2;
27847 else
27848 upper = r2, lower = r1;
27849
27850 /* The upper end of the intersection is lower.y0, if this is inside
27851 of upper. Otherwise, there is no intersection. */
27852 if (lower->y <= upper->y + upper->height)
27853 {
27854 result->y = lower->y;
27855
27856 /* The lower end of the intersection is the minimum of the lower
27857 ends of upper and lower. */
27858 result->height = (min (lower->y + lower->height,
27859 upper->y + upper->height)
27860 - result->y);
27861 intersection_p = 1;
27862 }
27863 }
27864
27865 return intersection_p;
27866 }
27867
27868 #endif /* HAVE_WINDOW_SYSTEM */
27869
27870 \f
27871 /***********************************************************************
27872 Initialization
27873 ***********************************************************************/
27874
27875 void
27876 syms_of_xdisp (void)
27877 {
27878 Vwith_echo_area_save_vector = Qnil;
27879 staticpro (&Vwith_echo_area_save_vector);
27880
27881 Vmessage_stack = Qnil;
27882 staticpro (&Vmessage_stack);
27883
27884 DEFSYM (Qinhibit_redisplay, "inhibit-redisplay");
27885
27886 message_dolog_marker1 = Fmake_marker ();
27887 staticpro (&message_dolog_marker1);
27888 message_dolog_marker2 = Fmake_marker ();
27889 staticpro (&message_dolog_marker2);
27890 message_dolog_marker3 = Fmake_marker ();
27891 staticpro (&message_dolog_marker3);
27892
27893 #if GLYPH_DEBUG
27894 defsubr (&Sdump_frame_glyph_matrix);
27895 defsubr (&Sdump_glyph_matrix);
27896 defsubr (&Sdump_glyph_row);
27897 defsubr (&Sdump_tool_bar_row);
27898 defsubr (&Strace_redisplay);
27899 defsubr (&Strace_to_stderr);
27900 #endif
27901 #ifdef HAVE_WINDOW_SYSTEM
27902 defsubr (&Stool_bar_lines_needed);
27903 defsubr (&Slookup_image_map);
27904 #endif
27905 defsubr (&Sformat_mode_line);
27906 defsubr (&Sinvisible_p);
27907 defsubr (&Scurrent_bidi_paragraph_direction);
27908
27909 DEFSYM (Qmenu_bar_update_hook, "menu-bar-update-hook");
27910 DEFSYM (Qoverriding_terminal_local_map, "overriding-terminal-local-map");
27911 DEFSYM (Qoverriding_local_map, "overriding-local-map");
27912 DEFSYM (Qwindow_scroll_functions, "window-scroll-functions");
27913 DEFSYM (Qwindow_text_change_functions, "window-text-change-functions");
27914 DEFSYM (Qredisplay_end_trigger_functions, "redisplay-end-trigger-functions");
27915 DEFSYM (Qinhibit_point_motion_hooks, "inhibit-point-motion-hooks");
27916 DEFSYM (Qeval, "eval");
27917 DEFSYM (QCdata, ":data");
27918 DEFSYM (Qdisplay, "display");
27919 DEFSYM (Qspace_width, "space-width");
27920 DEFSYM (Qraise, "raise");
27921 DEFSYM (Qslice, "slice");
27922 DEFSYM (Qspace, "space");
27923 DEFSYM (Qmargin, "margin");
27924 DEFSYM (Qpointer, "pointer");
27925 DEFSYM (Qleft_margin, "left-margin");
27926 DEFSYM (Qright_margin, "right-margin");
27927 DEFSYM (Qcenter, "center");
27928 DEFSYM (Qline_height, "line-height");
27929 DEFSYM (QCalign_to, ":align-to");
27930 DEFSYM (QCrelative_width, ":relative-width");
27931 DEFSYM (QCrelative_height, ":relative-height");
27932 DEFSYM (QCeval, ":eval");
27933 DEFSYM (QCpropertize, ":propertize");
27934 DEFSYM (QCfile, ":file");
27935 DEFSYM (Qfontified, "fontified");
27936 DEFSYM (Qfontification_functions, "fontification-functions");
27937 DEFSYM (Qtrailing_whitespace, "trailing-whitespace");
27938 DEFSYM (Qescape_glyph, "escape-glyph");
27939 DEFSYM (Qnobreak_space, "nobreak-space");
27940 DEFSYM (Qimage, "image");
27941 DEFSYM (Qtext, "text");
27942 DEFSYM (Qboth, "both");
27943 DEFSYM (Qboth_horiz, "both-horiz");
27944 DEFSYM (Qtext_image_horiz, "text-image-horiz");
27945 DEFSYM (QCmap, ":map");
27946 DEFSYM (QCpointer, ":pointer");
27947 DEFSYM (Qrect, "rect");
27948 DEFSYM (Qcircle, "circle");
27949 DEFSYM (Qpoly, "poly");
27950 DEFSYM (Qmessage_truncate_lines, "message-truncate-lines");
27951 DEFSYM (Qgrow_only, "grow-only");
27952 DEFSYM (Qinhibit_menubar_update, "inhibit-menubar-update");
27953 DEFSYM (Qinhibit_eval_during_redisplay, "inhibit-eval-during-redisplay");
27954 DEFSYM (Qposition, "position");
27955 DEFSYM (Qbuffer_position, "buffer-position");
27956 DEFSYM (Qobject, "object");
27957 DEFSYM (Qbar, "bar");
27958 DEFSYM (Qhbar, "hbar");
27959 DEFSYM (Qbox, "box");
27960 DEFSYM (Qhollow, "hollow");
27961 DEFSYM (Qhand, "hand");
27962 DEFSYM (Qarrow, "arrow");
27963 DEFSYM (Qtext, "text");
27964 DEFSYM (Qinhibit_free_realized_faces, "inhibit-free-realized-faces");
27965
27966 list_of_error = Fcons (Fcons (intern_c_string ("error"),
27967 Fcons (intern_c_string ("void-variable"), Qnil)),
27968 Qnil);
27969 staticpro (&list_of_error);
27970
27971 DEFSYM (Qlast_arrow_position, "last-arrow-position");
27972 DEFSYM (Qlast_arrow_string, "last-arrow-string");
27973 DEFSYM (Qoverlay_arrow_string, "overlay-arrow-string");
27974 DEFSYM (Qoverlay_arrow_bitmap, "overlay-arrow-bitmap");
27975
27976 echo_buffer[0] = echo_buffer[1] = Qnil;
27977 staticpro (&echo_buffer[0]);
27978 staticpro (&echo_buffer[1]);
27979
27980 echo_area_buffer[0] = echo_area_buffer[1] = Qnil;
27981 staticpro (&echo_area_buffer[0]);
27982 staticpro (&echo_area_buffer[1]);
27983
27984 Vmessages_buffer_name = make_pure_c_string ("*Messages*");
27985 staticpro (&Vmessages_buffer_name);
27986
27987 mode_line_proptrans_alist = Qnil;
27988 staticpro (&mode_line_proptrans_alist);
27989 mode_line_string_list = Qnil;
27990 staticpro (&mode_line_string_list);
27991 mode_line_string_face = Qnil;
27992 staticpro (&mode_line_string_face);
27993 mode_line_string_face_prop = Qnil;
27994 staticpro (&mode_line_string_face_prop);
27995 Vmode_line_unwind_vector = Qnil;
27996 staticpro (&Vmode_line_unwind_vector);
27997
27998 help_echo_string = Qnil;
27999 staticpro (&help_echo_string);
28000 help_echo_object = Qnil;
28001 staticpro (&help_echo_object);
28002 help_echo_window = Qnil;
28003 staticpro (&help_echo_window);
28004 previous_help_echo_string = Qnil;
28005 staticpro (&previous_help_echo_string);
28006 help_echo_pos = -1;
28007
28008 DEFSYM (Qright_to_left, "right-to-left");
28009 DEFSYM (Qleft_to_right, "left-to-right");
28010
28011 #ifdef HAVE_WINDOW_SYSTEM
28012 DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p,
28013 doc: /* *Non-nil means draw block cursor as wide as the glyph under it.
28014 For example, if a block cursor is over a tab, it will be drawn as
28015 wide as that tab on the display. */);
28016 x_stretch_cursor_p = 0;
28017 #endif
28018
28019 DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace,
28020 doc: /* *Non-nil means highlight trailing whitespace.
28021 The face used for trailing whitespace is `trailing-whitespace'. */);
28022 Vshow_trailing_whitespace = Qnil;
28023
28024 DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display,
28025 doc: /* Control highlighting of non-ASCII space and hyphen chars.
28026 If the value is t, Emacs highlights non-ASCII chars which have the
28027 same appearance as an ASCII space or hyphen, using the `nobreak-space'
28028 or `escape-glyph' face respectively.
28029
28030 U+00A0 (no-break space), U+00AD (soft hyphen), U+2010 (hyphen), and
28031 U+2011 (non-breaking hyphen) are affected.
28032
28033 Any other non-nil value means to display these characters as a escape
28034 glyph followed by an ordinary space or hyphen.
28035
28036 A value of nil means no special handling of these characters. */);
28037 Vnobreak_char_display = Qt;
28038
28039 DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer,
28040 doc: /* *The pointer shape to show in void text areas.
28041 A value of nil means to show the text pointer. Other options are `arrow',
28042 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'. */);
28043 Vvoid_text_area_pointer = Qarrow;
28044
28045 DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay,
28046 doc: /* Non-nil means don't actually do any redisplay.
28047 This is used for internal purposes. */);
28048 Vinhibit_redisplay = Qnil;
28049
28050 DEFVAR_LISP ("global-mode-string", Vglobal_mode_string,
28051 doc: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
28052 Vglobal_mode_string = Qnil;
28053
28054 DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position,
28055 doc: /* Marker for where to display an arrow on top of the buffer text.
28056 This must be the beginning of a line in order to work.
28057 See also `overlay-arrow-string'. */);
28058 Voverlay_arrow_position = Qnil;
28059
28060 DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string,
28061 doc: /* String to display as an arrow in non-window frames.
28062 See also `overlay-arrow-position'. */);
28063 Voverlay_arrow_string = make_pure_c_string ("=>");
28064
28065 DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list,
28066 doc: /* List of variables (symbols) which hold markers for overlay arrows.
28067 The symbols on this list are examined during redisplay to determine
28068 where to display overlay arrows. */);
28069 Voverlay_arrow_variable_list
28070 = Fcons (intern_c_string ("overlay-arrow-position"), Qnil);
28071
28072 DEFVAR_INT ("scroll-step", emacs_scroll_step,
28073 doc: /* *The number of lines to try scrolling a window by when point moves out.
28074 If that fails to bring point back on frame, point is centered instead.
28075 If this is zero, point is always centered after it moves off frame.
28076 If you want scrolling to always be a line at a time, you should set
28077 `scroll-conservatively' to a large value rather than set this to 1. */);
28078
28079 DEFVAR_INT ("scroll-conservatively", scroll_conservatively,
28080 doc: /* *Scroll up to this many lines, to bring point back on screen.
28081 If point moves off-screen, redisplay will scroll by up to
28082 `scroll-conservatively' lines in order to bring point just barely
28083 onto the screen again. If that cannot be done, then redisplay
28084 recenters point as usual.
28085
28086 If the value is greater than 100, redisplay will never recenter point,
28087 but will always scroll just enough text to bring point into view, even
28088 if you move far away.
28089
28090 A value of zero means always recenter point if it moves off screen. */);
28091 scroll_conservatively = 0;
28092
28093 DEFVAR_INT ("scroll-margin", scroll_margin,
28094 doc: /* *Number of lines of margin at the top and bottom of a window.
28095 Recenter the window whenever point gets within this many lines
28096 of the top or bottom of the window. */);
28097 scroll_margin = 0;
28098
28099 DEFVAR_LISP ("display-pixels-per-inch", Vdisplay_pixels_per_inch,
28100 doc: /* Pixels per inch value for non-window system displays.
28101 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI). */);
28102 Vdisplay_pixels_per_inch = make_float (72.0);
28103
28104 #if GLYPH_DEBUG
28105 DEFVAR_INT ("debug-end-pos", debug_end_pos, doc: /* Don't ask. */);
28106 #endif
28107
28108 DEFVAR_LISP ("truncate-partial-width-windows",
28109 Vtruncate_partial_width_windows,
28110 doc: /* Non-nil means truncate lines in windows narrower than the frame.
28111 For an integer value, truncate lines in each window narrower than the
28112 full frame width, provided the window width is less than that integer;
28113 otherwise, respect the value of `truncate-lines'.
28114
28115 For any other non-nil value, truncate lines in all windows that do
28116 not span the full frame width.
28117
28118 A value of nil means to respect the value of `truncate-lines'.
28119
28120 If `word-wrap' is enabled, you might want to reduce this. */);
28121 Vtruncate_partial_width_windows = make_number (50);
28122
28123 DEFVAR_BOOL ("mode-line-inverse-video", mode_line_inverse_video,
28124 doc: /* When nil, display the mode-line/header-line/menu-bar in the default face.
28125 Any other value means to use the appropriate face, `mode-line',
28126 `header-line', or `menu' respectively. */);
28127 mode_line_inverse_video = 1;
28128
28129 DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit,
28130 doc: /* *Maximum buffer size for which line number should be displayed.
28131 If the buffer is bigger than this, the line number does not appear
28132 in the mode line. A value of nil means no limit. */);
28133 Vline_number_display_limit = Qnil;
28134
28135 DEFVAR_INT ("line-number-display-limit-width",
28136 line_number_display_limit_width,
28137 doc: /* *Maximum line width (in characters) for line number display.
28138 If the average length of the lines near point is bigger than this, then the
28139 line number may be omitted from the mode line. */);
28140 line_number_display_limit_width = 200;
28141
28142 DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows,
28143 doc: /* *Non-nil means highlight region even in nonselected windows. */);
28144 highlight_nonselected_windows = 0;
28145
28146 DEFVAR_BOOL ("multiple-frames", multiple_frames,
28147 doc: /* Non-nil if more than one frame is visible on this display.
28148 Minibuffer-only frames don't count, but iconified frames do.
28149 This variable is not guaranteed to be accurate except while processing
28150 `frame-title-format' and `icon-title-format'. */);
28151
28152 DEFVAR_LISP ("frame-title-format", Vframe_title_format,
28153 doc: /* Template for displaying the title bar of visible frames.
28154 \(Assuming the window manager supports this feature.)
28155
28156 This variable has the same structure as `mode-line-format', except that
28157 the %c and %l constructs are ignored. It is used only on frames for
28158 which no explicit name has been set \(see `modify-frame-parameters'). */);
28159
28160 DEFVAR_LISP ("icon-title-format", Vicon_title_format,
28161 doc: /* Template for displaying the title bar of an iconified frame.
28162 \(Assuming the window manager supports this feature.)
28163 This variable has the same structure as `mode-line-format' (which see),
28164 and is used only on frames for which no explicit name has been set
28165 \(see `modify-frame-parameters'). */);
28166 Vicon_title_format
28167 = Vframe_title_format
28168 = pure_cons (intern_c_string ("multiple-frames"),
28169 pure_cons (make_pure_c_string ("%b"),
28170 pure_cons (pure_cons (empty_unibyte_string,
28171 pure_cons (intern_c_string ("invocation-name"),
28172 pure_cons (make_pure_c_string ("@"),
28173 pure_cons (intern_c_string ("system-name"),
28174 Qnil)))),
28175 Qnil)));
28176
28177 DEFVAR_LISP ("message-log-max", Vmessage_log_max,
28178 doc: /* Maximum number of lines to keep in the message log buffer.
28179 If nil, disable message logging. If t, log messages but don't truncate
28180 the buffer when it becomes large. */);
28181 Vmessage_log_max = make_number (100);
28182
28183 DEFVAR_LISP ("window-size-change-functions", Vwindow_size_change_functions,
28184 doc: /* Functions called before redisplay, if window sizes have changed.
28185 The value should be a list of functions that take one argument.
28186 Just before redisplay, for each frame, if any of its windows have changed
28187 size since the last redisplay, or have been split or deleted,
28188 all the functions in the list are called, with the frame as argument. */);
28189 Vwindow_size_change_functions = Qnil;
28190
28191 DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions,
28192 doc: /* List of functions to call before redisplaying a window with scrolling.
28193 Each function is called with two arguments, the window and its new
28194 display-start position. Note that these functions are also called by
28195 `set-window-buffer'. Also note that the value of `window-end' is not
28196 valid when these functions are called. */);
28197 Vwindow_scroll_functions = Qnil;
28198
28199 DEFVAR_LISP ("window-text-change-functions",
28200 Vwindow_text_change_functions,
28201 doc: /* Functions to call in redisplay when text in the window might change. */);
28202 Vwindow_text_change_functions = Qnil;
28203
28204 DEFVAR_LISP ("redisplay-end-trigger-functions", Vredisplay_end_trigger_functions,
28205 doc: /* Functions called when redisplay of a window reaches the end trigger.
28206 Each function is called with two arguments, the window and the end trigger value.
28207 See `set-window-redisplay-end-trigger'. */);
28208 Vredisplay_end_trigger_functions = Qnil;
28209
28210 DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window,
28211 doc: /* *Non-nil means autoselect window with mouse pointer.
28212 If nil, do not autoselect windows.
28213 A positive number means delay autoselection by that many seconds: a
28214 window is autoselected only after the mouse has remained in that
28215 window for the duration of the delay.
28216 A negative number has a similar effect, but causes windows to be
28217 autoselected only after the mouse has stopped moving. \(Because of
28218 the way Emacs compares mouse events, you will occasionally wait twice
28219 that time before the window gets selected.\)
28220 Any other value means to autoselect window instantaneously when the
28221 mouse pointer enters it.
28222
28223 Autoselection selects the minibuffer only if it is active, and never
28224 unselects the minibuffer if it is active.
28225
28226 When customizing this variable make sure that the actual value of
28227 `focus-follows-mouse' matches the behavior of your window manager. */);
28228 Vmouse_autoselect_window = Qnil;
28229
28230 DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars,
28231 doc: /* *Non-nil means automatically resize tool-bars.
28232 This dynamically changes the tool-bar's height to the minimum height
28233 that is needed to make all tool-bar items visible.
28234 If value is `grow-only', the tool-bar's height is only increased
28235 automatically; to decrease the tool-bar height, use \\[recenter]. */);
28236 Vauto_resize_tool_bars = Qt;
28237
28238 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p,
28239 doc: /* *Non-nil means raise tool-bar buttons when the mouse moves over them. */);
28240 auto_raise_tool_bar_buttons_p = 1;
28241
28242 DEFVAR_BOOL ("make-cursor-line-fully-visible", make_cursor_line_fully_visible_p,
28243 doc: /* *Non-nil means to scroll (recenter) cursor line if it is not fully visible. */);
28244 make_cursor_line_fully_visible_p = 1;
28245
28246 DEFVAR_LISP ("tool-bar-border", Vtool_bar_border,
28247 doc: /* *Border below tool-bar in pixels.
28248 If an integer, use it as the height of the border.
28249 If it is one of `internal-border-width' or `border-width', use the
28250 value of the corresponding frame parameter.
28251 Otherwise, no border is added below the tool-bar. */);
28252 Vtool_bar_border = Qinternal_border_width;
28253
28254 DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin,
28255 doc: /* *Margin around tool-bar buttons in pixels.
28256 If an integer, use that for both horizontal and vertical margins.
28257 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
28258 HORZ specifying the horizontal margin, and VERT specifying the
28259 vertical margin. */);
28260 Vtool_bar_button_margin = make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
28261
28262 DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief,
28263 doc: /* *Relief thickness of tool-bar buttons. */);
28264 tool_bar_button_relief = DEFAULT_TOOL_BAR_BUTTON_RELIEF;
28265
28266 DEFVAR_LISP ("tool-bar-style", Vtool_bar_style,
28267 doc: /* Tool bar style to use.
28268 It can be one of
28269 image - show images only
28270 text - show text only
28271 both - show both, text below image
28272 both-horiz - show text to the right of the image
28273 text-image-horiz - show text to the left of the image
28274 any other - use system default or image if no system default. */);
28275 Vtool_bar_style = Qnil;
28276
28277 DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size,
28278 doc: /* *Maximum number of characters a label can have to be shown.
28279 The tool bar style must also show labels for this to have any effect, see
28280 `tool-bar-style'. */);
28281 tool_bar_max_label_size = DEFAULT_TOOL_BAR_LABEL_SIZE;
28282
28283 DEFVAR_LISP ("fontification-functions", Vfontification_functions,
28284 doc: /* List of functions to call to fontify regions of text.
28285 Each function is called with one argument POS. Functions must
28286 fontify a region starting at POS in the current buffer, and give
28287 fontified regions the property `fontified'. */);
28288 Vfontification_functions = Qnil;
28289 Fmake_variable_buffer_local (Qfontification_functions);
28290
28291 DEFVAR_BOOL ("unibyte-display-via-language-environment",
28292 unibyte_display_via_language_environment,
28293 doc: /* *Non-nil means display unibyte text according to language environment.
28294 Specifically, this means that raw bytes in the range 160-255 decimal
28295 are displayed by converting them to the equivalent multibyte characters
28296 according to the current language environment. As a result, they are
28297 displayed according to the current fontset.
28298
28299 Note that this variable affects only how these bytes are displayed,
28300 but does not change the fact they are interpreted as raw bytes. */);
28301 unibyte_display_via_language_environment = 0;
28302
28303 DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height,
28304 doc: /* *Maximum height for resizing mini-windows (the minibuffer and the echo area).
28305 If a float, it specifies a fraction of the mini-window frame's height.
28306 If an integer, it specifies a number of lines. */);
28307 Vmax_mini_window_height = make_float (0.25);
28308
28309 DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows,
28310 doc: /* How to resize mini-windows (the minibuffer and the echo area).
28311 A value of nil means don't automatically resize mini-windows.
28312 A value of t means resize them to fit the text displayed in them.
28313 A value of `grow-only', the default, means let mini-windows grow only;
28314 they return to their normal size when the minibuffer is closed, or the
28315 echo area becomes empty. */);
28316 Vresize_mini_windows = Qgrow_only;
28317
28318 DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist,
28319 doc: /* Alist specifying how to blink the cursor off.
28320 Each element has the form (ON-STATE . OFF-STATE). Whenever the
28321 `cursor-type' frame-parameter or variable equals ON-STATE,
28322 comparing using `equal', Emacs uses OFF-STATE to specify
28323 how to blink it off. ON-STATE and OFF-STATE are values for
28324 the `cursor-type' frame parameter.
28325
28326 If a frame's ON-STATE has no entry in this list,
28327 the frame's other specifications determine how to blink the cursor off. */);
28328 Vblink_cursor_alist = Qnil;
28329
28330 DEFVAR_BOOL ("auto-hscroll-mode", automatic_hscrolling_p,
28331 doc: /* Allow or disallow automatic horizontal scrolling of windows.
28332 If non-nil, windows are automatically scrolled horizontally to make
28333 point visible. */);
28334 automatic_hscrolling_p = 1;
28335 DEFSYM (Qauto_hscroll_mode, "auto-hscroll-mode");
28336
28337 DEFVAR_INT ("hscroll-margin", hscroll_margin,
28338 doc: /* *How many columns away from the window edge point is allowed to get
28339 before automatic hscrolling will horizontally scroll the window. */);
28340 hscroll_margin = 5;
28341
28342 DEFVAR_LISP ("hscroll-step", Vhscroll_step,
28343 doc: /* *How many columns to scroll the window when point gets too close to the edge.
28344 When point is less than `hscroll-margin' columns from the window
28345 edge, automatic hscrolling will scroll the window by the amount of columns
28346 determined by this variable. If its value is a positive integer, scroll that
28347 many columns. If it's a positive floating-point number, it specifies the
28348 fraction of the window's width to scroll. If it's nil or zero, point will be
28349 centered horizontally after the scroll. Any other value, including negative
28350 numbers, are treated as if the value were zero.
28351
28352 Automatic hscrolling always moves point outside the scroll margin, so if
28353 point was more than scroll step columns inside the margin, the window will
28354 scroll more than the value given by the scroll step.
28355
28356 Note that the lower bound for automatic hscrolling specified by `scroll-left'
28357 and `scroll-right' overrides this variable's effect. */);
28358 Vhscroll_step = make_number (0);
28359
28360 DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines,
28361 doc: /* If non-nil, messages are truncated instead of resizing the echo area.
28362 Bind this around calls to `message' to let it take effect. */);
28363 message_truncate_lines = 0;
28364
28365 DEFVAR_LISP ("menu-bar-update-hook", Vmenu_bar_update_hook,
28366 doc: /* Normal hook run to update the menu bar definitions.
28367 Redisplay runs this hook before it redisplays the menu bar.
28368 This is used to update submenus such as Buffers,
28369 whose contents depend on various data. */);
28370 Vmenu_bar_update_hook = Qnil;
28371
28372 DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame,
28373 doc: /* Frame for which we are updating a menu.
28374 The enable predicate for a menu binding should check this variable. */);
28375 Vmenu_updating_frame = Qnil;
28376
28377 DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update,
28378 doc: /* Non-nil means don't update menu bars. Internal use only. */);
28379 inhibit_menubar_update = 0;
28380
28381 DEFVAR_LISP ("wrap-prefix", Vwrap_prefix,
28382 doc: /* Prefix prepended to all continuation lines at display time.
28383 The value may be a string, an image, or a stretch-glyph; it is
28384 interpreted in the same way as the value of a `display' text property.
28385
28386 This variable is overridden by any `wrap-prefix' text or overlay
28387 property.
28388
28389 To add a prefix to non-continuation lines, use `line-prefix'. */);
28390 Vwrap_prefix = Qnil;
28391 DEFSYM (Qwrap_prefix, "wrap-prefix");
28392 Fmake_variable_buffer_local (Qwrap_prefix);
28393
28394 DEFVAR_LISP ("line-prefix", Vline_prefix,
28395 doc: /* Prefix prepended to all non-continuation lines at display time.
28396 The value may be a string, an image, or a stretch-glyph; it is
28397 interpreted in the same way as the value of a `display' text property.
28398
28399 This variable is overridden by any `line-prefix' text or overlay
28400 property.
28401
28402 To add a prefix to continuation lines, use `wrap-prefix'. */);
28403 Vline_prefix = Qnil;
28404 DEFSYM (Qline_prefix, "line-prefix");
28405 Fmake_variable_buffer_local (Qline_prefix);
28406
28407 DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay,
28408 doc: /* Non-nil means don't eval Lisp during redisplay. */);
28409 inhibit_eval_during_redisplay = 0;
28410
28411 DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces,
28412 doc: /* Non-nil means don't free realized faces. Internal use only. */);
28413 inhibit_free_realized_faces = 0;
28414
28415 #if GLYPH_DEBUG
28416 DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id,
28417 doc: /* Inhibit try_window_id display optimization. */);
28418 inhibit_try_window_id = 0;
28419
28420 DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing,
28421 doc: /* Inhibit try_window_reusing display optimization. */);
28422 inhibit_try_window_reusing = 0;
28423
28424 DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement,
28425 doc: /* Inhibit try_cursor_movement display optimization. */);
28426 inhibit_try_cursor_movement = 0;
28427 #endif /* GLYPH_DEBUG */
28428
28429 DEFVAR_INT ("overline-margin", overline_margin,
28430 doc: /* *Space between overline and text, in pixels.
28431 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
28432 margin to the caracter height. */);
28433 overline_margin = 2;
28434
28435 DEFVAR_INT ("underline-minimum-offset",
28436 underline_minimum_offset,
28437 doc: /* Minimum distance between baseline and underline.
28438 This can improve legibility of underlined text at small font sizes,
28439 particularly when using variable `x-use-underline-position-properties'
28440 with fonts that specify an UNDERLINE_POSITION relatively close to the
28441 baseline. The default value is 1. */);
28442 underline_minimum_offset = 1;
28443
28444 DEFVAR_BOOL ("display-hourglass", display_hourglass_p,
28445 doc: /* Non-nil means show an hourglass pointer, when Emacs is busy.
28446 This feature only works when on a window system that can change
28447 cursor shapes. */);
28448 display_hourglass_p = 1;
28449
28450 DEFVAR_LISP ("hourglass-delay", Vhourglass_delay,
28451 doc: /* *Seconds to wait before displaying an hourglass pointer when Emacs is busy. */);
28452 Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
28453
28454 hourglass_atimer = NULL;
28455 hourglass_shown_p = 0;
28456
28457 DEFSYM (Qglyphless_char, "glyphless-char");
28458 DEFSYM (Qhex_code, "hex-code");
28459 DEFSYM (Qempty_box, "empty-box");
28460 DEFSYM (Qthin_space, "thin-space");
28461 DEFSYM (Qzero_width, "zero-width");
28462
28463 DEFSYM (Qglyphless_char_display, "glyphless-char-display");
28464 /* Intern this now in case it isn't already done.
28465 Setting this variable twice is harmless.
28466 But don't staticpro it here--that is done in alloc.c. */
28467 Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
28468 Fput (Qglyphless_char_display, Qchar_table_extra_slots, make_number (1));
28469
28470 DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display,
28471 doc: /* Char-table defining glyphless characters.
28472 Each element, if non-nil, should be one of the following:
28473 an ASCII acronym string: display this string in a box
28474 `hex-code': display the hexadecimal code of a character in a box
28475 `empty-box': display as an empty box
28476 `thin-space': display as 1-pixel width space
28477 `zero-width': don't display
28478 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
28479 display method for graphical terminals and text terminals respectively.
28480 GRAPHICAL and TEXT should each have one of the values listed above.
28481
28482 The char-table has one extra slot to control the display of a character for
28483 which no font is found. This slot only takes effect on graphical terminals.
28484 Its value should be an ASCII acronym string, `hex-code', `empty-box', or
28485 `thin-space'. The default is `empty-box'. */);
28486 Vglyphless_char_display = Fmake_char_table (Qglyphless_char_display, Qnil);
28487 Fset_char_table_extra_slot (Vglyphless_char_display, make_number (0),
28488 Qempty_box);
28489 }
28490
28491
28492 /* Initialize this module when Emacs starts. */
28493
28494 void
28495 init_xdisp (void)
28496 {
28497 current_header_line_height = current_mode_line_height = -1;
28498
28499 CHARPOS (this_line_start_pos) = 0;
28500
28501 if (!noninteractive)
28502 {
28503 struct window *m = XWINDOW (minibuf_window);
28504 Lisp_Object frame = m->frame;
28505 struct frame *f = XFRAME (frame);
28506 Lisp_Object root = FRAME_ROOT_WINDOW (f);
28507 struct window *r = XWINDOW (root);
28508 int i;
28509
28510 echo_area_window = minibuf_window;
28511
28512 XSETFASTINT (r->top_line, FRAME_TOP_MARGIN (f));
28513 XSETFASTINT (r->total_lines, FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f));
28514 XSETFASTINT (r->total_cols, FRAME_COLS (f));
28515 XSETFASTINT (m->top_line, FRAME_LINES (f) - 1);
28516 XSETFASTINT (m->total_lines, 1);
28517 XSETFASTINT (m->total_cols, FRAME_COLS (f));
28518
28519 scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
28520 scratch_glyph_row.glyphs[TEXT_AREA + 1]
28521 = scratch_glyphs + MAX_SCRATCH_GLYPHS;
28522
28523 /* The default ellipsis glyphs `...'. */
28524 for (i = 0; i < 3; ++i)
28525 default_invis_vector[i] = make_number ('.');
28526 }
28527
28528 {
28529 /* Allocate the buffer for frame titles.
28530 Also used for `format-mode-line'. */
28531 int size = 100;
28532 mode_line_noprop_buf = (char *) xmalloc (size);
28533 mode_line_noprop_buf_end = mode_line_noprop_buf + size;
28534 mode_line_noprop_ptr = mode_line_noprop_buf;
28535 mode_line_target = MODE_LINE_DISPLAY;
28536 }
28537
28538 help_echo_showing_p = 0;
28539 }
28540
28541 /* Since w32 does not support atimers, it defines its own implementation of
28542 the following three functions in w32fns.c. */
28543 #ifndef WINDOWSNT
28544
28545 /* Platform-independent portion of hourglass implementation. */
28546
28547 /* Return non-zero if houglass timer has been started or hourglass is shown. */
28548 int
28549 hourglass_started (void)
28550 {
28551 return hourglass_shown_p || hourglass_atimer != NULL;
28552 }
28553
28554 /* Cancel a currently active hourglass timer, and start a new one. */
28555 void
28556 start_hourglass (void)
28557 {
28558 #if defined (HAVE_WINDOW_SYSTEM)
28559 EMACS_TIME delay;
28560 int secs = DEFAULT_HOURGLASS_DELAY, usecs = 0;
28561
28562 cancel_hourglass ();
28563
28564 if (NUMBERP (Vhourglass_delay))
28565 {
28566 double duration = extract_float (Vhourglass_delay);
28567 if (0 < duration)
28568 duration_to_sec_usec (duration, &secs, &usecs);
28569 }
28570
28571 EMACS_SET_SECS_USECS (delay, secs, usecs);
28572 hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
28573 show_hourglass, NULL);
28574 #endif
28575 }
28576
28577
28578 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
28579 shown. */
28580 void
28581 cancel_hourglass (void)
28582 {
28583 #if defined (HAVE_WINDOW_SYSTEM)
28584 if (hourglass_atimer)
28585 {
28586 cancel_atimer (hourglass_atimer);
28587 hourglass_atimer = NULL;
28588 }
28589
28590 if (hourglass_shown_p)
28591 hide_hourglass ();
28592 #endif
28593 }
28594 #endif /* ! WINDOWSNT */