(chinese-calendar-time-zone, chinese-calendar-daylight-time-offset)
[emacs.git] / src / xdisp.c
blobb93c151ed2bd9056fac5725ae1cbdcc469ed16b8
1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
25 Redisplay.
27 Emacs separates the task of updating the display from code
28 modifying global state, e.g. buffer text. This way functions
29 operating on buffers don't also have to be concerned with updating
30 the display.
32 Updating the display is triggered by the Lisp interpreter when it
33 decides it's time to do it. This is done either automatically for
34 you as part of the interpreter's command loop or as the result of
35 calling Lisp functions like `sit-for'. The C function `redisplay'
36 in xdisp.c is the only entry into the inner redisplay code. (Or,
37 let's say almost---see the description of direct update
38 operations, below.)
40 The following diagram shows how redisplay code is invoked. As you
41 can see, Lisp calls redisplay and vice versa. Under window systems
42 like X, some portions of the redisplay code are also called
43 asynchronously during mouse movement or expose events. It is very
44 important that these code parts do NOT use the C library (malloc,
45 free) because many C libraries under Unix are not reentrant. They
46 may also NOT call functions of the Lisp interpreter which could
47 change the interpreter's state. If you don't follow these rules,
48 you will encounter bugs which are very hard to explain.
50 (Direct functions, see below)
51 direct_output_for_insert,
52 direct_forward_char (dispnew.c)
53 +---------------------------------+
54 | |
55 | V
56 +--------------+ redisplay +----------------+
57 | Lisp machine |---------------->| Redisplay code |<--+
58 +--------------+ (xdisp.c) +----------------+ |
59 ^ | |
60 +----------------------------------+ |
61 Don't use this path when called |
62 asynchronously! |
64 expose_window (asynchronous) |
66 X expose events -----+
68 What does redisplay do? Obviously, it has to figure out somehow what
69 has been changed since the last time the display has been updated,
70 and to make these changes visible. Preferably it would do that in
71 a moderately intelligent way, i.e. fast.
73 Changes in buffer text can be deduced from window and buffer
74 structures, and from some global variables like `beg_unchanged' and
75 `end_unchanged'. The contents of the display are additionally
76 recorded in a `glyph matrix', a two-dimensional matrix of glyph
77 structures. Each row in such a matrix corresponds to a line on the
78 display, and each glyph in a row corresponds to a column displaying
79 a character, an image, or what else. This matrix is called the
80 `current glyph matrix' or `current matrix' in redisplay
81 terminology.
83 For buffer parts that have been changed since the last update, a
84 second glyph matrix is constructed, the so called `desired glyph
85 matrix' or short `desired matrix'. Current and desired matrix are
86 then compared to find a cheap way to update the display, e.g. by
87 reusing part of the display by scrolling lines.
90 Direct operations.
92 You will find a lot of redisplay optimizations when you start
93 looking at the innards of redisplay. The overall goal of all these
94 optimizations is to make redisplay fast because it is done
95 frequently.
97 Two optimizations are not found in xdisp.c. These are the direct
98 operations mentioned above. As the name suggests they follow a
99 different principle than the rest of redisplay. Instead of
100 building a desired matrix and then comparing it with the current
101 display, they perform their actions directly on the display and on
102 the current matrix.
104 One direct operation updates the display after one character has
105 been entered. The other one moves the cursor by one position
106 forward or backward. You find these functions under the names
107 `direct_output_for_insert' and `direct_output_forward_char' in
108 dispnew.c.
111 Desired matrices.
113 Desired matrices are always built per Emacs window. The function
114 `display_line' is the central function to look at if you are
115 interested. It constructs one row in a desired matrix given an
116 iterator structure containing both a buffer position and a
117 description of the environment in which the text is to be
118 displayed. But this is too early, read on.
120 Characters and pixmaps displayed for a range of buffer text depend
121 on various settings of buffers and windows, on overlays and text
122 properties, on display tables, on selective display. The good news
123 is that all this hairy stuff is hidden behind a small set of
124 interface functions taking an iterator structure (struct it)
125 argument.
127 Iteration over things to be displayed is then simple. It is
128 started by initializing an iterator with a call to init_iterator.
129 Calls to get_next_display_element fill the iterator structure with
130 relevant information about the next thing to display. Calls to
131 set_iterator_to_next move the iterator to the next thing.
133 Besides this, an iterator also contains information about the
134 display environment in which glyphs for display elements are to be
135 produced. It has fields for the width and height of the display,
136 the information whether long lines are truncated or continued, a
137 current X and Y position, and lots of other stuff you can better
138 see in dispextern.h.
140 Glyphs in a desired matrix are normally constructed in a loop
141 calling get_next_display_element and then produce_glyphs. The call
142 to produce_glyphs will fill the iterator structure with pixel
143 information about the element being displayed and at the same time
144 produce glyphs for it. If the display element fits on the line
145 being displayed, set_iterator_to_next is called next, otherwise the
146 glyphs produced are discarded.
149 Frame matrices.
151 That just couldn't be all, could it? What about terminal types not
152 supporting operations on sub-windows of the screen? To update the
153 display on such a terminal, window-based glyph matrices are not
154 well suited. To be able to reuse part of the display (scrolling
155 lines up and down), we must instead have a view of the whole
156 screen. This is what `frame matrices' are for. They are a trick.
158 Frames on terminals like above have a glyph pool. Windows on such
159 a frame sub-allocate their glyph memory from their frame's glyph
160 pool. The frame itself is given its own glyph matrices. By
161 coincidence---or maybe something else---rows in window glyph
162 matrices are slices of corresponding rows in frame matrices. Thus
163 writing to window matrices implicitly updates a frame matrix which
164 provides us with the view of the whole screen that we originally
165 wanted to have without having to move many bytes around. To be
166 honest, there is a little bit more done, but not much more. If you
167 plan to extend that code, take a look at dispnew.c. The function
168 build_frame_matrix is a good starting point. */
170 #include <config.h>
171 #include <stdio.h>
173 #include "lisp.h"
174 #include "keyboard.h"
175 #include "frame.h"
176 #include "window.h"
177 #include "termchar.h"
178 #include "dispextern.h"
179 #include "buffer.h"
180 #include "character.h"
181 #include "charset.h"
182 #include "indent.h"
183 #include "commands.h"
184 #include "keymap.h"
185 #include "macros.h"
186 #include "disptab.h"
187 #include "termhooks.h"
188 #include "intervals.h"
189 #include "coding.h"
190 #include "process.h"
191 #include "region-cache.h"
192 #include "fontset.h"
193 #include "blockinput.h"
195 #ifdef HAVE_X_WINDOWS
196 #include "xterm.h"
197 #endif
198 #ifdef WINDOWSNT
199 #include "w32term.h"
200 #endif
201 #ifdef MAC_OS
202 #include "macterm.h"
203 #endif
205 #ifdef HAVE_WINDOW_SYSTEM
206 #ifdef USE_FONT_BACKEND
207 #include "font.h"
208 #endif /* USE_FONT_BACKEND */
209 #endif /* HAVE_WINDOW_SYSTEM */
211 #ifndef FRAME_X_OUTPUT
212 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
213 #endif
215 #define INFINITY 10000000
217 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
218 || defined (USE_GTK)
219 extern void set_frame_menubar P_ ((struct frame *f, int, int));
220 extern int pending_menu_activation;
221 #endif
223 extern int interrupt_input;
224 extern int command_loop_level;
226 extern Lisp_Object do_mouse_tracking;
228 extern int minibuffer_auto_raise;
229 extern Lisp_Object Vminibuffer_list;
231 extern Lisp_Object Qface;
232 extern Lisp_Object Qmode_line, Qmode_line_inactive, Qheader_line;
234 extern Lisp_Object Voverriding_local_map;
235 extern Lisp_Object Voverriding_local_map_menu_flag;
236 extern Lisp_Object Qmenu_item;
237 extern Lisp_Object Qwhen;
238 extern Lisp_Object Qhelp_echo;
240 Lisp_Object Qoverriding_local_map, Qoverriding_terminal_local_map;
241 Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
242 Lisp_Object Qwindow_text_change_functions, Vwindow_text_change_functions;
243 Lisp_Object Qredisplay_end_trigger_functions, Vredisplay_end_trigger_functions;
244 Lisp_Object Qinhibit_point_motion_hooks;
245 Lisp_Object QCeval, QCfile, QCdata, QCpropertize;
246 Lisp_Object Qfontified;
247 Lisp_Object Qgrow_only;
248 Lisp_Object Qinhibit_eval_during_redisplay;
249 Lisp_Object Qbuffer_position, Qposition, Qobject;
251 /* Cursor shapes */
252 Lisp_Object Qbar, Qhbar, Qbox, Qhollow;
254 /* Pointer shapes */
255 Lisp_Object Qarrow, Qhand, Qtext;
257 Lisp_Object Qrisky_local_variable;
259 /* Holds the list (error). */
260 Lisp_Object list_of_error;
262 /* Functions called to fontify regions of text. */
264 Lisp_Object Vfontification_functions;
265 Lisp_Object Qfontification_functions;
267 /* Non-nil means automatically select any window when the mouse
268 cursor moves into it. */
269 Lisp_Object Vmouse_autoselect_window;
271 /* Non-zero means draw tool bar buttons raised when the mouse moves
272 over them. */
274 int auto_raise_tool_bar_buttons_p;
276 /* Non-zero means to reposition window if cursor line is only partially visible. */
278 int make_cursor_line_fully_visible_p;
280 /* Margin below tool bar in pixels. 0 or nil means no margin.
281 If value is `internal-border-width' or `border-width',
282 the corresponding frame parameter is used. */
284 Lisp_Object Vtool_bar_border;
286 /* Margin around tool bar buttons in pixels. */
288 Lisp_Object Vtool_bar_button_margin;
290 /* Thickness of shadow to draw around tool bar buttons. */
292 EMACS_INT tool_bar_button_relief;
294 /* Non-nil means automatically resize tool-bars so that all tool-bar
295 items are visible, and no blank lines remain.
297 If value is `grow-only', only make tool-bar bigger. */
299 Lisp_Object Vauto_resize_tool_bars;
301 /* Non-zero means draw block and hollow cursor as wide as the glyph
302 under it. For example, if a block cursor is over a tab, it will be
303 drawn as wide as that tab on the display. */
305 int x_stretch_cursor_p;
307 /* Non-nil means don't actually do any redisplay. */
309 Lisp_Object Vinhibit_redisplay, Qinhibit_redisplay;
311 /* Non-zero means Lisp evaluation during redisplay is inhibited. */
313 int inhibit_eval_during_redisplay;
315 /* Names of text properties relevant for redisplay. */
317 Lisp_Object Qdisplay;
318 extern Lisp_Object Qface, Qinvisible, Qwidth;
320 /* Symbols used in text property values. */
322 Lisp_Object Vdisplay_pixels_per_inch;
323 Lisp_Object Qspace, QCalign_to, QCrelative_width, QCrelative_height;
324 Lisp_Object Qleft_margin, Qright_margin, Qspace_width, Qraise;
325 Lisp_Object Qslice;
326 Lisp_Object Qcenter;
327 Lisp_Object Qmargin, Qpointer;
328 Lisp_Object Qline_height;
329 extern Lisp_Object Qheight;
330 extern Lisp_Object QCwidth, QCheight, QCascent;
331 extern Lisp_Object Qscroll_bar;
332 extern Lisp_Object Qcursor;
334 /* Non-nil means highlight trailing whitespace. */
336 Lisp_Object Vshow_trailing_whitespace;
338 /* Non-nil means escape non-break space and hyphens. */
340 Lisp_Object Vnobreak_char_display;
342 #ifdef HAVE_WINDOW_SYSTEM
343 extern Lisp_Object Voverflow_newline_into_fringe;
345 /* Test if overflow newline into fringe. Called with iterator IT
346 at or past right window margin, and with IT->current_x set. */
348 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) \
349 (!NILP (Voverflow_newline_into_fringe) \
350 && FRAME_WINDOW_P (it->f) \
351 && WINDOW_RIGHT_FRINGE_WIDTH (it->w) > 0 \
352 && it->current_x == it->last_visible_x)
354 #endif /* HAVE_WINDOW_SYSTEM */
356 /* Non-nil means show the text cursor in void text areas
357 i.e. in blank areas after eol and eob. This used to be
358 the default in 21.3. */
360 Lisp_Object Vvoid_text_area_pointer;
362 /* Name of the face used to highlight trailing whitespace. */
364 Lisp_Object Qtrailing_whitespace;
366 /* Name and number of the face used to highlight escape glyphs. */
368 Lisp_Object Qescape_glyph;
370 /* Name and number of the face used to highlight non-breaking spaces. */
372 Lisp_Object Qnobreak_space;
374 /* The symbol `image' which is the car of the lists used to represent
375 images in Lisp. */
377 Lisp_Object Qimage;
379 /* The image map types. */
380 Lisp_Object QCmap, QCpointer;
381 Lisp_Object Qrect, Qcircle, Qpoly;
383 /* Non-zero means print newline to stdout before next mini-buffer
384 message. */
386 int noninteractive_need_newline;
388 /* Non-zero means print newline to message log before next message. */
390 static int message_log_need_newline;
392 /* Three markers that message_dolog uses.
393 It could allocate them itself, but that causes trouble
394 in handling memory-full errors. */
395 static Lisp_Object message_dolog_marker1;
396 static Lisp_Object message_dolog_marker2;
397 static Lisp_Object message_dolog_marker3;
399 /* The buffer position of the first character appearing entirely or
400 partially on the line of the selected window which contains the
401 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
402 redisplay optimization in redisplay_internal. */
404 static struct text_pos this_line_start_pos;
406 /* Number of characters past the end of the line above, including the
407 terminating newline. */
409 static struct text_pos this_line_end_pos;
411 /* The vertical positions and the height of this line. */
413 static int this_line_vpos;
414 static int this_line_y;
415 static int this_line_pixel_height;
417 /* X position at which this display line starts. Usually zero;
418 negative if first character is partially visible. */
420 static int this_line_start_x;
422 /* Buffer that this_line_.* variables are referring to. */
424 static struct buffer *this_line_buffer;
426 /* Nonzero means truncate lines in all windows less wide than the
427 frame. */
429 int truncate_partial_width_windows;
431 /* A flag to control how to display unibyte 8-bit character. */
433 int unibyte_display_via_language_environment;
435 /* Nonzero means we have more than one non-mini-buffer-only frame.
436 Not guaranteed to be accurate except while parsing
437 frame-title-format. */
439 int multiple_frames;
441 Lisp_Object Vglobal_mode_string;
444 /* List of variables (symbols) which hold markers for overlay arrows.
445 The symbols on this list are examined during redisplay to determine
446 where to display overlay arrows. */
448 Lisp_Object Voverlay_arrow_variable_list;
450 /* Marker for where to display an arrow on top of the buffer text. */
452 Lisp_Object Voverlay_arrow_position;
454 /* String to display for the arrow. Only used on terminal frames. */
456 Lisp_Object Voverlay_arrow_string;
458 /* Values of those variables at last redisplay are stored as
459 properties on `overlay-arrow-position' symbol. However, if
460 Voverlay_arrow_position is a marker, last-arrow-position is its
461 numerical position. */
463 Lisp_Object Qlast_arrow_position, Qlast_arrow_string;
465 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
466 properties on a symbol in overlay-arrow-variable-list. */
468 Lisp_Object Qoverlay_arrow_string, Qoverlay_arrow_bitmap;
470 /* Like mode-line-format, but for the title bar on a visible frame. */
472 Lisp_Object Vframe_title_format;
474 /* Like mode-line-format, but for the title bar on an iconified frame. */
476 Lisp_Object Vicon_title_format;
478 /* List of functions to call when a window's size changes. These
479 functions get one arg, a frame on which one or more windows' sizes
480 have changed. */
482 static Lisp_Object Vwindow_size_change_functions;
484 Lisp_Object Qmenu_bar_update_hook, Vmenu_bar_update_hook;
486 /* Nonzero if an overlay arrow has been displayed in this window. */
488 static int overlay_arrow_seen;
490 /* Nonzero means highlight the region even in nonselected windows. */
492 int highlight_nonselected_windows;
494 /* If cursor motion alone moves point off frame, try scrolling this
495 many lines up or down if that will bring it back. */
497 static EMACS_INT scroll_step;
499 /* Nonzero means scroll just far enough to bring point back on the
500 screen, when appropriate. */
502 static EMACS_INT scroll_conservatively;
504 /* Recenter the window whenever point gets within this many lines of
505 the top or bottom of the window. This value is translated into a
506 pixel value by multiplying it with FRAME_LINE_HEIGHT, which means
507 that there is really a fixed pixel height scroll margin. */
509 EMACS_INT scroll_margin;
511 /* Number of windows showing the buffer of the selected window (or
512 another buffer with the same base buffer). keyboard.c refers to
513 this. */
515 int buffer_shared;
517 /* Vector containing glyphs for an ellipsis `...'. */
519 static Lisp_Object default_invis_vector[3];
521 /* Zero means display the mode-line/header-line/menu-bar in the default face
522 (this slightly odd definition is for compatibility with previous versions
523 of emacs), non-zero means display them using their respective faces.
525 This variable is deprecated. */
527 int mode_line_inverse_video;
529 /* Prompt to display in front of the mini-buffer contents. */
531 Lisp_Object minibuf_prompt;
533 /* Width of current mini-buffer prompt. Only set after display_line
534 of the line that contains the prompt. */
536 int minibuf_prompt_width;
538 /* This is the window where the echo area message was displayed. It
539 is always a mini-buffer window, but it may not be the same window
540 currently active as a mini-buffer. */
542 Lisp_Object echo_area_window;
544 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
545 pushes the current message and the value of
546 message_enable_multibyte on the stack, the function restore_message
547 pops the stack and displays MESSAGE again. */
549 Lisp_Object Vmessage_stack;
551 /* Nonzero means multibyte characters were enabled when the echo area
552 message was specified. */
554 int message_enable_multibyte;
556 /* Nonzero if we should redraw the mode lines on the next redisplay. */
558 int update_mode_lines;
560 /* Nonzero if window sizes or contents have changed since last
561 redisplay that finished. */
563 int windows_or_buffers_changed;
565 /* Nonzero means a frame's cursor type has been changed. */
567 int cursor_type_changed;
569 /* Nonzero after display_mode_line if %l was used and it displayed a
570 line number. */
572 int line_number_displayed;
574 /* Maximum buffer size for which to display line numbers. */
576 Lisp_Object Vline_number_display_limit;
578 /* Line width to consider when repositioning for line number display. */
580 static EMACS_INT line_number_display_limit_width;
582 /* Number of lines to keep in the message log buffer. t means
583 infinite. nil means don't log at all. */
585 Lisp_Object Vmessage_log_max;
587 /* The name of the *Messages* buffer, a string. */
589 static Lisp_Object Vmessages_buffer_name;
591 /* Current, index 0, and last displayed echo area message. Either
592 buffers from echo_buffers, or nil to indicate no message. */
594 Lisp_Object echo_area_buffer[2];
596 /* The buffers referenced from echo_area_buffer. */
598 static Lisp_Object echo_buffer[2];
600 /* A vector saved used in with_area_buffer to reduce consing. */
602 static Lisp_Object Vwith_echo_area_save_vector;
604 /* Non-zero means display_echo_area should display the last echo area
605 message again. Set by redisplay_preserve_echo_area. */
607 static int display_last_displayed_message_p;
609 /* Nonzero if echo area is being used by print; zero if being used by
610 message. */
612 int message_buf_print;
614 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
616 Lisp_Object Qinhibit_menubar_update;
617 int inhibit_menubar_update;
619 /* When evaluating expressions from menu bar items (enable conditions,
620 for instance), this is the frame they are being processed for. */
622 Lisp_Object Vmenu_updating_frame;
624 /* Maximum height for resizing mini-windows. Either a float
625 specifying a fraction of the available height, or an integer
626 specifying a number of lines. */
628 Lisp_Object Vmax_mini_window_height;
630 /* Non-zero means messages should be displayed with truncated
631 lines instead of being continued. */
633 int message_truncate_lines;
634 Lisp_Object Qmessage_truncate_lines;
636 /* Set to 1 in clear_message to make redisplay_internal aware
637 of an emptied echo area. */
639 static int message_cleared_p;
641 /* How to blink the default frame cursor off. */
642 Lisp_Object Vblink_cursor_alist;
644 /* A scratch glyph row with contents used for generating truncation
645 glyphs. Also used in direct_output_for_insert. */
647 #define MAX_SCRATCH_GLYPHS 100
648 struct glyph_row scratch_glyph_row;
649 static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
651 /* Ascent and height of the last line processed by move_it_to. */
653 static int last_max_ascent, last_height;
655 /* Non-zero if there's a help-echo in the echo area. */
657 int help_echo_showing_p;
659 /* If >= 0, computed, exact values of mode-line and header-line height
660 to use in the macros CURRENT_MODE_LINE_HEIGHT and
661 CURRENT_HEADER_LINE_HEIGHT. */
663 int current_mode_line_height, current_header_line_height;
665 /* The maximum distance to look ahead for text properties. Values
666 that are too small let us call compute_char_face and similar
667 functions too often which is expensive. Values that are too large
668 let us call compute_char_face and alike too often because we
669 might not be interested in text properties that far away. */
671 #define TEXT_PROP_DISTANCE_LIMIT 100
673 #if GLYPH_DEBUG
675 /* Variables to turn off display optimizations from Lisp. */
677 int inhibit_try_window_id, inhibit_try_window_reusing;
678 int inhibit_try_cursor_movement;
680 /* Non-zero means print traces of redisplay if compiled with
681 GLYPH_DEBUG != 0. */
683 int trace_redisplay_p;
685 #endif /* GLYPH_DEBUG */
687 #ifdef DEBUG_TRACE_MOVE
688 /* Non-zero means trace with TRACE_MOVE to stderr. */
689 int trace_move;
691 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
692 #else
693 #define TRACE_MOVE(x) (void) 0
694 #endif
696 /* Non-zero means automatically scroll windows horizontally to make
697 point visible. */
699 int automatic_hscrolling_p;
700 Lisp_Object Qauto_hscroll_mode;
702 /* How close to the margin can point get before the window is scrolled
703 horizontally. */
704 EMACS_INT hscroll_margin;
706 /* How much to scroll horizontally when point is inside the above margin. */
707 Lisp_Object Vhscroll_step;
709 /* The variable `resize-mini-windows'. If nil, don't resize
710 mini-windows. If t, always resize them to fit the text they
711 display. If `grow-only', let mini-windows grow only until they
712 become empty. */
714 Lisp_Object Vresize_mini_windows;
716 /* Buffer being redisplayed -- for redisplay_window_error. */
718 struct buffer *displayed_buffer;
720 /* Space between overline and text. */
722 EMACS_INT overline_margin;
724 /* Value returned from text property handlers (see below). */
726 enum prop_handled
728 HANDLED_NORMALLY,
729 HANDLED_RECOMPUTE_PROPS,
730 HANDLED_OVERLAY_STRING_CONSUMED,
731 HANDLED_RETURN
734 /* A description of text properties that redisplay is interested
735 in. */
737 struct props
739 /* The name of the property. */
740 Lisp_Object *name;
742 /* A unique index for the property. */
743 enum prop_idx idx;
745 /* A handler function called to set up iterator IT from the property
746 at IT's current position. Value is used to steer handle_stop. */
747 enum prop_handled (*handler) P_ ((struct it *it));
750 static enum prop_handled handle_face_prop P_ ((struct it *));
751 static enum prop_handled handle_invisible_prop P_ ((struct it *));
752 static enum prop_handled handle_display_prop P_ ((struct it *));
753 static enum prop_handled handle_composition_prop P_ ((struct it *));
754 static enum prop_handled handle_overlay_change P_ ((struct it *));
755 static enum prop_handled handle_fontified_prop P_ ((struct it *));
756 static enum prop_handled handle_auto_composed_prop P_ ((struct it *));
758 /* Properties handled by iterators. */
760 static struct props it_props[] =
762 {&Qfontified, FONTIFIED_PROP_IDX, handle_fontified_prop},
763 /* Handle `face' before `display' because some sub-properties of
764 `display' need to know the face. */
765 {&Qface, FACE_PROP_IDX, handle_face_prop},
766 {&Qdisplay, DISPLAY_PROP_IDX, handle_display_prop},
767 {&Qinvisible, INVISIBLE_PROP_IDX, handle_invisible_prop},
768 {&Qauto_composed, AUTO_COMPOSED_PROP_IDX, handle_auto_composed_prop},
769 {&Qcomposition, COMPOSITION_PROP_IDX, handle_composition_prop},
770 {NULL, 0, NULL}
773 /* Value is the position described by X. If X is a marker, value is
774 the marker_position of X. Otherwise, value is X. */
776 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
778 /* Enumeration returned by some move_it_.* functions internally. */
780 enum move_it_result
782 /* Not used. Undefined value. */
783 MOVE_UNDEFINED,
785 /* Move ended at the requested buffer position or ZV. */
786 MOVE_POS_MATCH_OR_ZV,
788 /* Move ended at the requested X pixel position. */
789 MOVE_X_REACHED,
791 /* Move within a line ended at the end of a line that must be
792 continued. */
793 MOVE_LINE_CONTINUED,
795 /* Move within a line ended at the end of a line that would
796 be displayed truncated. */
797 MOVE_LINE_TRUNCATED,
799 /* Move within a line ended at a line end. */
800 MOVE_NEWLINE_OR_CR
803 /* This counter is used to clear the face cache every once in a while
804 in redisplay_internal. It is incremented for each redisplay.
805 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
806 cleared. */
808 #define CLEAR_FACE_CACHE_COUNT 500
809 static int clear_face_cache_count;
811 /* Similarly for the image cache. */
813 #ifdef HAVE_WINDOW_SYSTEM
814 #define CLEAR_IMAGE_CACHE_COUNT 101
815 static int clear_image_cache_count;
816 #endif
818 /* Non-zero while redisplay_internal is in progress. */
820 int redisplaying_p;
822 /* Non-zero means don't free realized faces. Bound while freeing
823 realized faces is dangerous because glyph matrices might still
824 reference them. */
826 int inhibit_free_realized_faces;
827 Lisp_Object Qinhibit_free_realized_faces;
829 /* If a string, XTread_socket generates an event to display that string.
830 (The display is done in read_char.) */
832 Lisp_Object help_echo_string;
833 Lisp_Object help_echo_window;
834 Lisp_Object help_echo_object;
835 int help_echo_pos;
837 /* Temporary variable for XTread_socket. */
839 Lisp_Object previous_help_echo_string;
841 /* Null glyph slice */
843 static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
846 /* Function prototypes. */
848 static void setup_for_ellipsis P_ ((struct it *, int));
849 static void mark_window_display_accurate_1 P_ ((struct window *, int));
850 static int single_display_spec_string_p P_ ((Lisp_Object, Lisp_Object));
851 static int display_prop_string_p P_ ((Lisp_Object, Lisp_Object));
852 static int cursor_row_p P_ ((struct window *, struct glyph_row *));
853 static int redisplay_mode_lines P_ ((Lisp_Object, int));
854 static char *decode_mode_spec_coding P_ ((Lisp_Object, char *, int));
856 #if 0
857 static int invisible_text_between_p P_ ((struct it *, int, int));
858 #endif
860 static void pint2str P_ ((char *, int, int));
861 static void pint2hrstr P_ ((char *, int, int));
862 static struct text_pos run_window_scroll_functions P_ ((Lisp_Object,
863 struct text_pos));
864 static void reconsider_clip_changes P_ ((struct window *, struct buffer *));
865 static int text_outside_line_unchanged_p P_ ((struct window *, int, int));
866 static void store_mode_line_noprop_char P_ ((char));
867 static int store_mode_line_noprop P_ ((const unsigned char *, int, int));
868 static void x_consider_frame_title P_ ((Lisp_Object));
869 static void handle_stop P_ ((struct it *));
870 static int tool_bar_lines_needed P_ ((struct frame *, int *));
871 static int single_display_spec_intangible_p P_ ((Lisp_Object));
872 static void ensure_echo_area_buffers P_ ((void));
873 static Lisp_Object unwind_with_echo_area_buffer P_ ((Lisp_Object));
874 static Lisp_Object with_echo_area_buffer_unwind_data P_ ((struct window *));
875 static int with_echo_area_buffer P_ ((struct window *, int,
876 int (*) (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT),
877 EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
878 static void clear_garbaged_frames P_ ((void));
879 static int current_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
880 static int truncate_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
881 static int set_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
882 static int display_echo_area P_ ((struct window *));
883 static int display_echo_area_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
884 static int resize_mini_window_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
885 static Lisp_Object unwind_redisplay P_ ((Lisp_Object));
886 static int string_char_and_length P_ ((const unsigned char *, int, int *));
887 static struct text_pos display_prop_end P_ ((struct it *, Lisp_Object,
888 struct text_pos));
889 static int compute_window_start_on_continuation_line P_ ((struct window *));
890 static Lisp_Object safe_eval_handler P_ ((Lisp_Object));
891 static void insert_left_trunc_glyphs P_ ((struct it *));
892 static struct glyph_row *get_overlay_arrow_glyph_row P_ ((struct window *,
893 Lisp_Object));
894 static void extend_face_to_end_of_line P_ ((struct it *));
895 static int append_space_for_newline P_ ((struct it *, int));
896 static int cursor_row_fully_visible_p P_ ((struct window *, int, int));
897 static int try_scrolling P_ ((Lisp_Object, int, EMACS_INT, EMACS_INT, int, int));
898 static int try_cursor_movement P_ ((Lisp_Object, struct text_pos, int *));
899 static int trailing_whitespace_p P_ ((int));
900 static int message_log_check_duplicate P_ ((int, int, int, int));
901 static void push_it P_ ((struct it *));
902 static void pop_it P_ ((struct it *));
903 static void sync_frame_with_window_matrix_rows P_ ((struct window *));
904 static void select_frame_for_redisplay P_ ((Lisp_Object));
905 static void redisplay_internal P_ ((int));
906 static int echo_area_display P_ ((int));
907 static void redisplay_windows P_ ((Lisp_Object));
908 static void redisplay_window P_ ((Lisp_Object, int));
909 static Lisp_Object redisplay_window_error ();
910 static Lisp_Object redisplay_window_0 P_ ((Lisp_Object));
911 static Lisp_Object redisplay_window_1 P_ ((Lisp_Object));
912 static int update_menu_bar P_ ((struct frame *, int, int));
913 static int try_window_reusing_current_matrix P_ ((struct window *));
914 static int try_window_id P_ ((struct window *));
915 static int display_line P_ ((struct it *));
916 static int display_mode_lines P_ ((struct window *));
917 static int display_mode_line P_ ((struct window *, enum face_id, Lisp_Object));
918 static int display_mode_element P_ ((struct it *, int, int, int, Lisp_Object, Lisp_Object, int));
919 static int store_mode_line_string P_ ((char *, Lisp_Object, int, int, int, Lisp_Object));
920 static char *decode_mode_spec P_ ((struct window *, int, int, int, int *));
921 static void display_menu_bar P_ ((struct window *));
922 static int display_count_lines P_ ((int, int, int, int, int *));
923 static int display_string P_ ((unsigned char *, Lisp_Object, Lisp_Object,
924 EMACS_INT, EMACS_INT, struct it *, int, int, int, int));
925 static void compute_line_metrics P_ ((struct it *));
926 static void run_redisplay_end_trigger_hook P_ ((struct it *));
927 static int get_overlay_strings P_ ((struct it *, int));
928 static int get_overlay_strings_1 P_ ((struct it *, int, int));
929 static void next_overlay_string P_ ((struct it *));
930 static void reseat P_ ((struct it *, struct text_pos, int));
931 static void reseat_1 P_ ((struct it *, struct text_pos, int));
932 static void back_to_previous_visible_line_start P_ ((struct it *));
933 void reseat_at_previous_visible_line_start P_ ((struct it *));
934 static void reseat_at_next_visible_line_start P_ ((struct it *, int));
935 static int next_element_from_ellipsis P_ ((struct it *));
936 static int next_element_from_display_vector P_ ((struct it *));
937 static int next_element_from_string P_ ((struct it *));
938 static int next_element_from_c_string P_ ((struct it *));
939 static int next_element_from_buffer P_ ((struct it *));
940 static int next_element_from_composition P_ ((struct it *));
941 static int next_element_from_image P_ ((struct it *));
942 static int next_element_from_stretch P_ ((struct it *));
943 static void load_overlay_strings P_ ((struct it *, int));
944 static int init_from_display_pos P_ ((struct it *, struct window *,
945 struct display_pos *));
946 static void reseat_to_string P_ ((struct it *, unsigned char *,
947 Lisp_Object, int, int, int, int));
948 static enum move_it_result move_it_in_display_line_to P_ ((struct it *,
949 int, int, int));
950 void move_it_vertically_backward P_ ((struct it *, int));
951 static void init_to_row_start P_ ((struct it *, struct window *,
952 struct glyph_row *));
953 static int init_to_row_end P_ ((struct it *, struct window *,
954 struct glyph_row *));
955 static void back_to_previous_line_start P_ ((struct it *));
956 static int forward_to_next_line_start P_ ((struct it *, int *));
957 static struct text_pos string_pos_nchars_ahead P_ ((struct text_pos,
958 Lisp_Object, int));
959 static struct text_pos string_pos P_ ((int, Lisp_Object));
960 static struct text_pos c_string_pos P_ ((int, unsigned char *, int));
961 static int number_of_chars P_ ((unsigned char *, int));
962 static void compute_stop_pos P_ ((struct it *));
963 static void compute_string_pos P_ ((struct text_pos *, struct text_pos,
964 Lisp_Object));
965 static int face_before_or_after_it_pos P_ ((struct it *, int));
966 static EMACS_INT next_overlay_change P_ ((EMACS_INT));
967 static int handle_single_display_spec P_ ((struct it *, Lisp_Object,
968 Lisp_Object, Lisp_Object,
969 struct text_pos *, int));
970 static int underlying_face_id P_ ((struct it *));
971 static int in_ellipses_for_invisible_text_p P_ ((struct display_pos *,
972 struct window *));
974 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
975 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
977 #ifdef HAVE_WINDOW_SYSTEM
979 static void update_tool_bar P_ ((struct frame *, int));
980 static void build_desired_tool_bar_string P_ ((struct frame *f));
981 static int redisplay_tool_bar P_ ((struct frame *));
982 static void display_tool_bar_line P_ ((struct it *, int));
983 static void notice_overwritten_cursor P_ ((struct window *,
984 enum glyph_row_area,
985 int, int, int, int));
989 #endif /* HAVE_WINDOW_SYSTEM */
992 /***********************************************************************
993 Window display dimensions
994 ***********************************************************************/
996 /* Return the bottom boundary y-position for text lines in window W.
997 This is the first y position at which a line cannot start.
998 It is relative to the top of the window.
1000 This is the height of W minus the height of a mode line, if any. */
1002 INLINE int
1003 window_text_bottom_y (w)
1004 struct window *w;
1006 int height = WINDOW_TOTAL_HEIGHT (w);
1008 if (WINDOW_WANTS_MODELINE_P (w))
1009 height -= CURRENT_MODE_LINE_HEIGHT (w);
1010 return height;
1013 /* Return the pixel width of display area AREA of window W. AREA < 0
1014 means return the total width of W, not including fringes to
1015 the left and right of the window. */
1017 INLINE int
1018 window_box_width (w, area)
1019 struct window *w;
1020 int area;
1022 int cols = XFASTINT (w->total_cols);
1023 int pixels = 0;
1025 if (!w->pseudo_window_p)
1027 cols -= WINDOW_SCROLL_BAR_COLS (w);
1029 if (area == TEXT_AREA)
1031 if (INTEGERP (w->left_margin_cols))
1032 cols -= XFASTINT (w->left_margin_cols);
1033 if (INTEGERP (w->right_margin_cols))
1034 cols -= XFASTINT (w->right_margin_cols);
1035 pixels = -WINDOW_TOTAL_FRINGE_WIDTH (w);
1037 else if (area == LEFT_MARGIN_AREA)
1039 cols = (INTEGERP (w->left_margin_cols)
1040 ? XFASTINT (w->left_margin_cols) : 0);
1041 pixels = 0;
1043 else if (area == RIGHT_MARGIN_AREA)
1045 cols = (INTEGERP (w->right_margin_cols)
1046 ? XFASTINT (w->right_margin_cols) : 0);
1047 pixels = 0;
1051 return cols * WINDOW_FRAME_COLUMN_WIDTH (w) + pixels;
1055 /* Return the pixel height of the display area of window W, not
1056 including mode lines of W, if any. */
1058 INLINE int
1059 window_box_height (w)
1060 struct window *w;
1062 struct frame *f = XFRAME (w->frame);
1063 int height = WINDOW_TOTAL_HEIGHT (w);
1065 xassert (height >= 0);
1067 /* Note: the code below that determines the mode-line/header-line
1068 height is essentially the same as that contained in the macro
1069 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
1070 the appropriate glyph row has its `mode_line_p' flag set,
1071 and if it doesn't, uses estimate_mode_line_height instead. */
1073 if (WINDOW_WANTS_MODELINE_P (w))
1075 struct glyph_row *ml_row
1076 = (w->current_matrix && w->current_matrix->rows
1077 ? MATRIX_MODE_LINE_ROW (w->current_matrix)
1078 : 0);
1079 if (ml_row && ml_row->mode_line_p)
1080 height -= ml_row->height;
1081 else
1082 height -= estimate_mode_line_height (f, CURRENT_MODE_LINE_FACE_ID (w));
1085 if (WINDOW_WANTS_HEADER_LINE_P (w))
1087 struct glyph_row *hl_row
1088 = (w->current_matrix && w->current_matrix->rows
1089 ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
1090 : 0);
1091 if (hl_row && hl_row->mode_line_p)
1092 height -= hl_row->height;
1093 else
1094 height -= estimate_mode_line_height (f, HEADER_LINE_FACE_ID);
1097 /* With a very small font and a mode-line that's taller than
1098 default, we might end up with a negative height. */
1099 return max (0, height);
1102 /* Return the window-relative coordinate of the left edge of display
1103 area AREA of window W. AREA < 0 means return the left edge of the
1104 whole window, to the right of the left fringe of W. */
1106 INLINE int
1107 window_box_left_offset (w, area)
1108 struct window *w;
1109 int area;
1111 int x;
1113 if (w->pseudo_window_p)
1114 return 0;
1116 x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
1118 if (area == TEXT_AREA)
1119 x += (WINDOW_LEFT_FRINGE_WIDTH (w)
1120 + window_box_width (w, LEFT_MARGIN_AREA));
1121 else if (area == RIGHT_MARGIN_AREA)
1122 x += (WINDOW_LEFT_FRINGE_WIDTH (w)
1123 + window_box_width (w, LEFT_MARGIN_AREA)
1124 + window_box_width (w, TEXT_AREA)
1125 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
1127 : WINDOW_RIGHT_FRINGE_WIDTH (w)));
1128 else if (area == LEFT_MARGIN_AREA
1129 && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
1130 x += WINDOW_LEFT_FRINGE_WIDTH (w);
1132 return x;
1136 /* Return the window-relative coordinate of the right edge of display
1137 area AREA of window W. AREA < 0 means return the left edge of the
1138 whole window, to the left of the right fringe of W. */
1140 INLINE int
1141 window_box_right_offset (w, area)
1142 struct window *w;
1143 int area;
1145 return window_box_left_offset (w, area) + window_box_width (w, area);
1148 /* Return the frame-relative coordinate of the left edge of display
1149 area AREA of window W. AREA < 0 means return the left edge of the
1150 whole window, to the right of the left fringe of W. */
1152 INLINE int
1153 window_box_left (w, area)
1154 struct window *w;
1155 int area;
1157 struct frame *f = XFRAME (w->frame);
1158 int x;
1160 if (w->pseudo_window_p)
1161 return FRAME_INTERNAL_BORDER_WIDTH (f);
1163 x = (WINDOW_LEFT_EDGE_X (w)
1164 + window_box_left_offset (w, area));
1166 return x;
1170 /* Return the frame-relative coordinate of the right edge of display
1171 area AREA of window W. AREA < 0 means return the left edge of the
1172 whole window, to the left of the right fringe of W. */
1174 INLINE int
1175 window_box_right (w, area)
1176 struct window *w;
1177 int area;
1179 return window_box_left (w, area) + window_box_width (w, area);
1182 /* Get the bounding box of the display area AREA of window W, without
1183 mode lines, in frame-relative coordinates. AREA < 0 means the
1184 whole window, not including the left and right fringes of
1185 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
1186 coordinates of the upper-left corner of the box. Return in
1187 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
1189 INLINE void
1190 window_box (w, area, box_x, box_y, box_width, box_height)
1191 struct window *w;
1192 int area;
1193 int *box_x, *box_y, *box_width, *box_height;
1195 if (box_width)
1196 *box_width = window_box_width (w, area);
1197 if (box_height)
1198 *box_height = window_box_height (w);
1199 if (box_x)
1200 *box_x = window_box_left (w, area);
1201 if (box_y)
1203 *box_y = WINDOW_TOP_EDGE_Y (w);
1204 if (WINDOW_WANTS_HEADER_LINE_P (w))
1205 *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
1210 /* Get the bounding box of the display area AREA of window W, without
1211 mode lines. AREA < 0 means the whole window, not including the
1212 left and right fringe of the window. Return in *TOP_LEFT_X
1213 and TOP_LEFT_Y the frame-relative pixel coordinates of the
1214 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
1215 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
1216 box. */
1218 INLINE void
1219 window_box_edges (w, area, top_left_x, top_left_y,
1220 bottom_right_x, bottom_right_y)
1221 struct window *w;
1222 int area;
1223 int *top_left_x, *top_left_y, *bottom_right_x, *bottom_right_y;
1225 window_box (w, area, top_left_x, top_left_y, bottom_right_x,
1226 bottom_right_y);
1227 *bottom_right_x += *top_left_x;
1228 *bottom_right_y += *top_left_y;
1233 /***********************************************************************
1234 Utilities
1235 ***********************************************************************/
1237 /* Return the bottom y-position of the line the iterator IT is in.
1238 This can modify IT's settings. */
1241 line_bottom_y (it)
1242 struct it *it;
1244 int line_height = it->max_ascent + it->max_descent;
1245 int line_top_y = it->current_y;
1247 if (line_height == 0)
1249 if (last_height)
1250 line_height = last_height;
1251 else if (IT_CHARPOS (*it) < ZV)
1253 move_it_by_lines (it, 1, 1);
1254 line_height = (it->max_ascent || it->max_descent
1255 ? it->max_ascent + it->max_descent
1256 : last_height);
1258 else
1260 struct glyph_row *row = it->glyph_row;
1262 /* Use the default character height. */
1263 it->glyph_row = NULL;
1264 it->what = IT_CHARACTER;
1265 it->c = ' ';
1266 it->len = 1;
1267 PRODUCE_GLYPHS (it);
1268 line_height = it->ascent + it->descent;
1269 it->glyph_row = row;
1273 return line_top_y + line_height;
1277 /* Return 1 if position CHARPOS is visible in window W.
1278 CHARPOS < 0 means return info about WINDOW_END position.
1279 If visible, set *X and *Y to pixel coordinates of top left corner.
1280 Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
1281 Set *ROWH and *VPOS to row's visible height and VPOS (row number). */
1284 pos_visible_p (w, charpos, x, y, rtop, rbot, rowh, vpos)
1285 struct window *w;
1286 int charpos, *x, *y, *rtop, *rbot, *rowh, *vpos;
1288 struct it it;
1289 struct text_pos top;
1290 int visible_p = 0;
1291 struct buffer *old_buffer = NULL;
1293 if (noninteractive)
1294 return visible_p;
1296 if (XBUFFER (w->buffer) != current_buffer)
1298 old_buffer = current_buffer;
1299 set_buffer_internal_1 (XBUFFER (w->buffer));
1302 SET_TEXT_POS_FROM_MARKER (top, w->start);
1304 /* Compute exact mode line heights. */
1305 if (WINDOW_WANTS_MODELINE_P (w))
1306 current_mode_line_height
1307 = display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
1308 current_buffer->mode_line_format);
1310 if (WINDOW_WANTS_HEADER_LINE_P (w))
1311 current_header_line_height
1312 = display_mode_line (w, HEADER_LINE_FACE_ID,
1313 current_buffer->header_line_format);
1315 start_display (&it, w, top);
1316 move_it_to (&it, charpos, -1, it.last_visible_y-1, -1,
1317 (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
1319 /* Note that we may overshoot because of invisible text. */
1320 if (charpos >= 0 && IT_CHARPOS (it) >= charpos)
1322 int top_x = it.current_x;
1323 int top_y = it.current_y;
1324 int bottom_y = (last_height = 0, line_bottom_y (&it));
1325 int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
1327 if (top_y < window_top_y)
1328 visible_p = bottom_y > window_top_y;
1329 else if (top_y < it.last_visible_y)
1330 visible_p = 1;
1331 if (visible_p)
1333 Lisp_Object window, prop;
1335 XSETWINDOW (window, w);
1336 prop = Fget_char_property (make_number (it.position.charpos),
1337 Qinvisible, window);
1339 /* If charpos coincides with invisible text covered with an
1340 ellipsis, use the first glyph of the ellipsis to compute
1341 the pixel positions. */
1342 if (TEXT_PROP_MEANS_INVISIBLE (prop) == 2)
1344 struct glyph_row *row = it.glyph_row;
1345 struct glyph *glyph = row->glyphs[TEXT_AREA];
1346 struct glyph *end = glyph + row->used[TEXT_AREA];
1347 int x = row->x;
1349 for (; glyph < end && glyph->charpos < charpos; glyph++)
1350 x += glyph->pixel_width;
1352 top_x = x;
1355 *x = top_x;
1356 *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
1357 *rtop = max (0, window_top_y - top_y);
1358 *rbot = max (0, bottom_y - it.last_visible_y);
1359 *rowh = max (0, (min (bottom_y, it.last_visible_y)
1360 - max (top_y, window_top_y)));
1361 *vpos = it.vpos;
1364 else
1366 struct it it2;
1368 it2 = it;
1369 if (IT_CHARPOS (it) < ZV && FETCH_BYTE (IT_BYTEPOS (it)) != '\n')
1370 move_it_by_lines (&it, 1, 0);
1371 if (charpos < IT_CHARPOS (it)
1372 || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
1374 visible_p = 1;
1375 move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
1376 *x = it2.current_x;
1377 *y = it2.current_y + it2.max_ascent - it2.ascent;
1378 *rtop = max (0, -it2.current_y);
1379 *rbot = max (0, ((it2.current_y + it2.max_ascent + it2.max_descent)
1380 - it.last_visible_y));
1381 *rowh = max (0, (min (it2.current_y + it2.max_ascent + it2.max_descent,
1382 it.last_visible_y)
1383 - max (it2.current_y,
1384 WINDOW_HEADER_LINE_HEIGHT (w))));
1385 *vpos = it2.vpos;
1389 if (old_buffer)
1390 set_buffer_internal_1 (old_buffer);
1392 current_header_line_height = current_mode_line_height = -1;
1394 if (visible_p && XFASTINT (w->hscroll) > 0)
1395 *x -= XFASTINT (w->hscroll) * WINDOW_FRAME_COLUMN_WIDTH (w);
1397 #if 0
1398 /* Debugging code. */
1399 if (visible_p)
1400 fprintf (stderr, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1401 charpos, w->vscroll, *x, *y, *rtop, *rbot, *rowh, *vpos);
1402 else
1403 fprintf (stderr, "-pv pt=%d vs=%d\n", charpos, w->vscroll);
1404 #endif
1406 return visible_p;
1410 /* Return the next character from STR which is MAXLEN bytes long.
1411 Return in *LEN the length of the character. This is like
1412 STRING_CHAR_AND_LENGTH but never returns an invalid character. If
1413 we find one, we return a `?', but with the length of the invalid
1414 character. */
1416 static INLINE int
1417 string_char_and_length (str, maxlen, len)
1418 const unsigned char *str;
1419 int maxlen, *len;
1421 int c;
1423 c = STRING_CHAR_AND_LENGTH (str, maxlen, *len);
1424 if (!CHAR_VALID_P (c, 1))
1425 /* We may not change the length here because other places in Emacs
1426 don't use this function, i.e. they silently accept invalid
1427 characters. */
1428 c = '?';
1430 return c;
1435 /* Given a position POS containing a valid character and byte position
1436 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1438 static struct text_pos
1439 string_pos_nchars_ahead (pos, string, nchars)
1440 struct text_pos pos;
1441 Lisp_Object string;
1442 int nchars;
1444 xassert (STRINGP (string) && nchars >= 0);
1446 if (STRING_MULTIBYTE (string))
1448 int rest = SBYTES (string) - BYTEPOS (pos);
1449 const unsigned char *p = SDATA (string) + BYTEPOS (pos);
1450 int len;
1452 while (nchars--)
1454 string_char_and_length (p, rest, &len);
1455 p += len, rest -= len;
1456 xassert (rest >= 0);
1457 CHARPOS (pos) += 1;
1458 BYTEPOS (pos) += len;
1461 else
1462 SET_TEXT_POS (pos, CHARPOS (pos) + nchars, BYTEPOS (pos) + nchars);
1464 return pos;
1468 /* Value is the text position, i.e. character and byte position,
1469 for character position CHARPOS in STRING. */
1471 static INLINE struct text_pos
1472 string_pos (charpos, string)
1473 int charpos;
1474 Lisp_Object string;
1476 struct text_pos pos;
1477 xassert (STRINGP (string));
1478 xassert (charpos >= 0);
1479 SET_TEXT_POS (pos, charpos, string_char_to_byte (string, charpos));
1480 return pos;
1484 /* Value is a text position, i.e. character and byte position, for
1485 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1486 means recognize multibyte characters. */
1488 static struct text_pos
1489 c_string_pos (charpos, s, multibyte_p)
1490 int charpos;
1491 unsigned char *s;
1492 int multibyte_p;
1494 struct text_pos pos;
1496 xassert (s != NULL);
1497 xassert (charpos >= 0);
1499 if (multibyte_p)
1501 int rest = strlen (s), len;
1503 SET_TEXT_POS (pos, 0, 0);
1504 while (charpos--)
1506 string_char_and_length (s, rest, &len);
1507 s += len, rest -= len;
1508 xassert (rest >= 0);
1509 CHARPOS (pos) += 1;
1510 BYTEPOS (pos) += len;
1513 else
1514 SET_TEXT_POS (pos, charpos, charpos);
1516 return pos;
1520 /* Value is the number of characters in C string S. MULTIBYTE_P
1521 non-zero means recognize multibyte characters. */
1523 static int
1524 number_of_chars (s, multibyte_p)
1525 unsigned char *s;
1526 int multibyte_p;
1528 int nchars;
1530 if (multibyte_p)
1532 int rest = strlen (s), len;
1533 unsigned char *p = (unsigned char *) s;
1535 for (nchars = 0; rest > 0; ++nchars)
1537 string_char_and_length (p, rest, &len);
1538 rest -= len, p += len;
1541 else
1542 nchars = strlen (s);
1544 return nchars;
1548 /* Compute byte position NEWPOS->bytepos corresponding to
1549 NEWPOS->charpos. POS is a known position in string STRING.
1550 NEWPOS->charpos must be >= POS.charpos. */
1552 static void
1553 compute_string_pos (newpos, pos, string)
1554 struct text_pos *newpos, pos;
1555 Lisp_Object string;
1557 xassert (STRINGP (string));
1558 xassert (CHARPOS (*newpos) >= CHARPOS (pos));
1560 if (STRING_MULTIBYTE (string))
1561 *newpos = string_pos_nchars_ahead (pos, string,
1562 CHARPOS (*newpos) - CHARPOS (pos));
1563 else
1564 BYTEPOS (*newpos) = CHARPOS (*newpos);
1567 /* EXPORT:
1568 Return an estimation of the pixel height of mode or top lines on
1569 frame F. FACE_ID specifies what line's height to estimate. */
1572 estimate_mode_line_height (f, face_id)
1573 struct frame *f;
1574 enum face_id face_id;
1576 #ifdef HAVE_WINDOW_SYSTEM
1577 if (FRAME_WINDOW_P (f))
1579 int height = FONT_HEIGHT (FRAME_FONT (f));
1581 /* This function is called so early when Emacs starts that the face
1582 cache and mode line face are not yet initialized. */
1583 if (FRAME_FACE_CACHE (f))
1585 struct face *face = FACE_FROM_ID (f, face_id);
1586 if (face)
1588 if (face->font)
1589 height = FONT_HEIGHT (face->font);
1590 if (face->box_line_width > 0)
1591 height += 2 * face->box_line_width;
1595 return height;
1597 #endif
1599 return 1;
1602 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
1603 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
1604 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
1605 not force the value into range. */
1607 void
1608 pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
1609 FRAME_PTR f;
1610 register int pix_x, pix_y;
1611 int *x, *y;
1612 NativeRectangle *bounds;
1613 int noclip;
1616 #ifdef HAVE_WINDOW_SYSTEM
1617 if (FRAME_WINDOW_P (f))
1619 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
1620 even for negative values. */
1621 if (pix_x < 0)
1622 pix_x -= FRAME_COLUMN_WIDTH (f) - 1;
1623 if (pix_y < 0)
1624 pix_y -= FRAME_LINE_HEIGHT (f) - 1;
1626 pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
1627 pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);
1629 if (bounds)
1630 STORE_NATIVE_RECT (*bounds,
1631 FRAME_COL_TO_PIXEL_X (f, pix_x),
1632 FRAME_LINE_TO_PIXEL_Y (f, pix_y),
1633 FRAME_COLUMN_WIDTH (f) - 1,
1634 FRAME_LINE_HEIGHT (f) - 1);
1636 if (!noclip)
1638 if (pix_x < 0)
1639 pix_x = 0;
1640 else if (pix_x > FRAME_TOTAL_COLS (f))
1641 pix_x = FRAME_TOTAL_COLS (f);
1643 if (pix_y < 0)
1644 pix_y = 0;
1645 else if (pix_y > FRAME_LINES (f))
1646 pix_y = FRAME_LINES (f);
1649 #endif
1651 *x = pix_x;
1652 *y = pix_y;
1656 /* Given HPOS/VPOS in the current matrix of W, return corresponding
1657 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
1658 can't tell the positions because W's display is not up to date,
1659 return 0. */
1662 glyph_to_pixel_coords (w, hpos, vpos, frame_x, frame_y)
1663 struct window *w;
1664 int hpos, vpos;
1665 int *frame_x, *frame_y;
1667 #ifdef HAVE_WINDOW_SYSTEM
1668 if (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w))))
1670 int success_p;
1672 xassert (hpos >= 0 && hpos < w->current_matrix->matrix_w);
1673 xassert (vpos >= 0 && vpos < w->current_matrix->matrix_h);
1675 if (display_completed)
1677 struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
1678 struct glyph *glyph = row->glyphs[TEXT_AREA];
1679 struct glyph *end = glyph + min (hpos, row->used[TEXT_AREA]);
1681 hpos = row->x;
1682 vpos = row->y;
1683 while (glyph < end)
1685 hpos += glyph->pixel_width;
1686 ++glyph;
1689 /* If first glyph is partially visible, its first visible position is still 0. */
1690 if (hpos < 0)
1691 hpos = 0;
1693 success_p = 1;
1695 else
1697 hpos = vpos = 0;
1698 success_p = 0;
1701 *frame_x = WINDOW_TO_FRAME_PIXEL_X (w, hpos);
1702 *frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, vpos);
1703 return success_p;
1705 #endif
1707 *frame_x = hpos;
1708 *frame_y = vpos;
1709 return 1;
1713 #ifdef HAVE_WINDOW_SYSTEM
1715 /* Find the glyph under window-relative coordinates X/Y in window W.
1716 Consider only glyphs from buffer text, i.e. no glyphs from overlay
1717 strings. Return in *HPOS and *VPOS the row and column number of
1718 the glyph found. Return in *AREA the glyph area containing X.
1719 Value is a pointer to the glyph found or null if X/Y is not on
1720 text, or we can't tell because W's current matrix is not up to
1721 date. */
1723 static struct glyph *
1724 x_y_to_hpos_vpos (w, x, y, hpos, vpos, dx, dy, area)
1725 struct window *w;
1726 int x, y;
1727 int *hpos, *vpos, *dx, *dy, *area;
1729 struct glyph *glyph, *end;
1730 struct glyph_row *row = NULL;
1731 int x0, i;
1733 /* Find row containing Y. Give up if some row is not enabled. */
1734 for (i = 0; i < w->current_matrix->nrows; ++i)
1736 row = MATRIX_ROW (w->current_matrix, i);
1737 if (!row->enabled_p)
1738 return NULL;
1739 if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
1740 break;
1743 *vpos = i;
1744 *hpos = 0;
1746 /* Give up if Y is not in the window. */
1747 if (i == w->current_matrix->nrows)
1748 return NULL;
1750 /* Get the glyph area containing X. */
1751 if (w->pseudo_window_p)
1753 *area = TEXT_AREA;
1754 x0 = 0;
1756 else
1758 if (x < window_box_left_offset (w, TEXT_AREA))
1760 *area = LEFT_MARGIN_AREA;
1761 x0 = window_box_left_offset (w, LEFT_MARGIN_AREA);
1763 else if (x < window_box_right_offset (w, TEXT_AREA))
1765 *area = TEXT_AREA;
1766 x0 = window_box_left_offset (w, TEXT_AREA) + min (row->x, 0);
1768 else
1770 *area = RIGHT_MARGIN_AREA;
1771 x0 = window_box_left_offset (w, RIGHT_MARGIN_AREA);
1775 /* Find glyph containing X. */
1776 glyph = row->glyphs[*area];
1777 end = glyph + row->used[*area];
1778 x -= x0;
1779 while (glyph < end && x >= glyph->pixel_width)
1781 x -= glyph->pixel_width;
1782 ++glyph;
1785 if (glyph == end)
1786 return NULL;
1788 if (dx)
1790 *dx = x;
1791 *dy = y - (row->y + row->ascent - glyph->ascent);
1794 *hpos = glyph - row->glyphs[*area];
1795 return glyph;
1799 /* EXPORT:
1800 Convert frame-relative x/y to coordinates relative to window W.
1801 Takes pseudo-windows into account. */
1803 void
1804 frame_to_window_pixel_xy (w, x, y)
1805 struct window *w;
1806 int *x, *y;
1808 if (w->pseudo_window_p)
1810 /* A pseudo-window is always full-width, and starts at the
1811 left edge of the frame, plus a frame border. */
1812 struct frame *f = XFRAME (w->frame);
1813 *x -= FRAME_INTERNAL_BORDER_WIDTH (f);
1814 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
1816 else
1818 *x -= WINDOW_LEFT_EDGE_X (w);
1819 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
1823 /* EXPORT:
1824 Return in RECTS[] at most N clipping rectangles for glyph string S.
1825 Return the number of stored rectangles. */
1828 get_glyph_string_clip_rects (s, rects, n)
1829 struct glyph_string *s;
1830 NativeRectangle *rects;
1831 int n;
1833 XRectangle r;
1835 if (n <= 0)
1836 return 0;
1838 if (s->row->full_width_p)
1840 /* Draw full-width. X coordinates are relative to S->w->left_col. */
1841 r.x = WINDOW_LEFT_EDGE_X (s->w);
1842 r.width = WINDOW_TOTAL_WIDTH (s->w);
1844 /* Unless displaying a mode or menu bar line, which are always
1845 fully visible, clip to the visible part of the row. */
1846 if (s->w->pseudo_window_p)
1847 r.height = s->row->visible_height;
1848 else
1849 r.height = s->height;
1851 else
1853 /* This is a text line that may be partially visible. */
1854 r.x = window_box_left (s->w, s->area);
1855 r.width = window_box_width (s->w, s->area);
1856 r.height = s->row->visible_height;
1859 if (s->clip_head)
1860 if (r.x < s->clip_head->x)
1862 if (r.width >= s->clip_head->x - r.x)
1863 r.width -= s->clip_head->x - r.x;
1864 else
1865 r.width = 0;
1866 r.x = s->clip_head->x;
1868 if (s->clip_tail)
1869 if (r.x + r.width > s->clip_tail->x + s->clip_tail->background_width)
1871 if (s->clip_tail->x + s->clip_tail->background_width >= r.x)
1872 r.width = s->clip_tail->x + s->clip_tail->background_width - r.x;
1873 else
1874 r.width = 0;
1877 /* If S draws overlapping rows, it's sufficient to use the top and
1878 bottom of the window for clipping because this glyph string
1879 intentionally draws over other lines. */
1880 if (s->for_overlaps)
1882 r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
1883 r.height = window_text_bottom_y (s->w) - r.y;
1885 /* Alas, the above simple strategy does not work for the
1886 environments with anti-aliased text: if the same text is
1887 drawn onto the same place multiple times, it gets thicker.
1888 If the overlap we are processing is for the erased cursor, we
1889 take the intersection with the rectagle of the cursor. */
1890 if (s->for_overlaps & OVERLAPS_ERASED_CURSOR)
1892 XRectangle rc, r_save = r;
1894 rc.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (s->w, s->w->phys_cursor.x);
1895 rc.y = s->w->phys_cursor.y;
1896 rc.width = s->w->phys_cursor_width;
1897 rc.height = s->w->phys_cursor_height;
1899 x_intersect_rectangles (&r_save, &rc, &r);
1902 else
1904 /* Don't use S->y for clipping because it doesn't take partially
1905 visible lines into account. For example, it can be negative for
1906 partially visible lines at the top of a window. */
1907 if (!s->row->full_width_p
1908 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
1909 r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
1910 else
1911 r.y = max (0, s->row->y);
1913 /* If drawing a tool-bar window, draw it over the internal border
1914 at the top of the window. */
1915 if (WINDOWP (s->f->tool_bar_window)
1916 && s->w == XWINDOW (s->f->tool_bar_window))
1917 r.y -= FRAME_INTERNAL_BORDER_WIDTH (s->f);
1920 r.y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r.y);
1922 /* If drawing the cursor, don't let glyph draw outside its
1923 advertised boundaries. Cleartype does this under some circumstances. */
1924 if (s->hl == DRAW_CURSOR)
1926 struct glyph *glyph = s->first_glyph;
1927 int height, max_y;
1929 if (s->x > r.x)
1931 r.width -= s->x - r.x;
1932 r.x = s->x;
1934 r.width = min (r.width, glyph->pixel_width);
1936 /* If r.y is below window bottom, ensure that we still see a cursor. */
1937 height = min (glyph->ascent + glyph->descent,
1938 min (FRAME_LINE_HEIGHT (s->f), s->row->visible_height));
1939 max_y = window_text_bottom_y (s->w) - height;
1940 max_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, max_y);
1941 if (s->ybase - glyph->ascent > max_y)
1943 r.y = max_y;
1944 r.height = height;
1946 else
1948 /* Don't draw cursor glyph taller than our actual glyph. */
1949 height = max (FRAME_LINE_HEIGHT (s->f), glyph->ascent + glyph->descent);
1950 if (height < r.height)
1952 max_y = r.y + r.height;
1953 r.y = min (max_y, max (r.y, s->ybase + glyph->descent - height));
1954 r.height = min (max_y - r.y, height);
1959 if (s->row->clip)
1961 XRectangle r_save = r;
1963 if (! x_intersect_rectangles (&r_save, s->row->clip, &r))
1964 r.width = 0;
1967 if ((s->for_overlaps & OVERLAPS_BOTH) == 0
1968 || ((s->for_overlaps & OVERLAPS_BOTH) == OVERLAPS_BOTH && n == 1))
1970 #ifdef CONVERT_FROM_XRECT
1971 CONVERT_FROM_XRECT (r, *rects);
1972 #else
1973 *rects = r;
1974 #endif
1975 return 1;
1977 else
1979 /* If we are processing overlapping and allowed to return
1980 multiple clipping rectangles, we exclude the row of the glyph
1981 string from the clipping rectangle. This is to avoid drawing
1982 the same text on the environment with anti-aliasing. */
1983 #ifdef CONVERT_FROM_XRECT
1984 XRectangle rs[2];
1985 #else
1986 XRectangle *rs = rects;
1987 #endif
1988 int i = 0, row_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, s->row->y);
1990 if (s->for_overlaps & OVERLAPS_PRED)
1992 rs[i] = r;
1993 if (r.y + r.height > row_y)
1995 if (r.y < row_y)
1996 rs[i].height = row_y - r.y;
1997 else
1998 rs[i].height = 0;
2000 i++;
2002 if (s->for_overlaps & OVERLAPS_SUCC)
2004 rs[i] = r;
2005 if (r.y < row_y + s->row->visible_height)
2007 if (r.y + r.height > row_y + s->row->visible_height)
2009 rs[i].y = row_y + s->row->visible_height;
2010 rs[i].height = r.y + r.height - rs[i].y;
2012 else
2013 rs[i].height = 0;
2015 i++;
2018 n = i;
2019 #ifdef CONVERT_FROM_XRECT
2020 for (i = 0; i < n; i++)
2021 CONVERT_FROM_XRECT (rs[i], rects[i]);
2022 #endif
2023 return n;
2027 /* EXPORT:
2028 Return in *NR the clipping rectangle for glyph string S. */
2030 void
2031 get_glyph_string_clip_rect (s, nr)
2032 struct glyph_string *s;
2033 NativeRectangle *nr;
2035 get_glyph_string_clip_rects (s, nr, 1);
2039 /* EXPORT:
2040 Return the position and height of the phys cursor in window W.
2041 Set w->phys_cursor_width to width of phys cursor.
2044 void
2045 get_phys_cursor_geometry (w, row, glyph, xp, yp, heightp)
2046 struct window *w;
2047 struct glyph_row *row;
2048 struct glyph *glyph;
2049 int *xp, *yp, *heightp;
2051 struct frame *f = XFRAME (WINDOW_FRAME (w));
2052 int x, y, wd, h, h0, y0;
2054 /* Compute the width of the rectangle to draw. If on a stretch
2055 glyph, and `x-stretch-block-cursor' is nil, don't draw a
2056 rectangle as wide as the glyph, but use a canonical character
2057 width instead. */
2058 wd = glyph->pixel_width - 1;
2059 #ifdef HAVE_NTGUI
2060 wd++; /* Why? */
2061 #endif
2063 x = w->phys_cursor.x;
2064 if (x < 0)
2066 wd += x;
2067 x = 0;
2070 if (glyph->type == STRETCH_GLYPH
2071 && !x_stretch_cursor_p)
2072 wd = min (FRAME_COLUMN_WIDTH (f), wd);
2073 w->phys_cursor_width = wd;
2075 y = w->phys_cursor.y + row->ascent - glyph->ascent;
2077 /* If y is below window bottom, ensure that we still see a cursor. */
2078 h0 = min (FRAME_LINE_HEIGHT (f), row->visible_height);
2080 h = max (h0, glyph->ascent + glyph->descent);
2081 h0 = min (h0, glyph->ascent + glyph->descent);
2083 y0 = WINDOW_HEADER_LINE_HEIGHT (w);
2084 if (y < y0)
2086 h = max (h - (y0 - y) + 1, h0);
2087 y = y0 - 1;
2089 else
2091 y0 = window_text_bottom_y (w) - h0;
2092 if (y > y0)
2094 h += y - y0;
2095 y = y0;
2099 *xp = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
2100 *yp = WINDOW_TO_FRAME_PIXEL_Y (w, y);
2101 *heightp = h;
2105 * Remember which glyph the mouse is over.
2108 void
2109 remember_mouse_glyph (f, gx, gy, rect)
2110 struct frame *f;
2111 int gx, gy;
2112 NativeRectangle *rect;
2114 Lisp_Object window;
2115 struct window *w;
2116 struct glyph_row *r, *gr, *end_row;
2117 enum window_part part;
2118 enum glyph_row_area area;
2119 int x, y, width, height;
2121 /* Try to determine frame pixel position and size of the glyph under
2122 frame pixel coordinates X/Y on frame F. */
2124 if (!f->glyphs_initialized_p
2125 || (window = window_from_coordinates (f, gx, gy, &part, &x, &y, 0),
2126 NILP (window)))
2128 width = FRAME_SMALLEST_CHAR_WIDTH (f);
2129 height = FRAME_SMALLEST_FONT_HEIGHT (f);
2130 goto virtual_glyph;
2133 w = XWINDOW (window);
2134 width = WINDOW_FRAME_COLUMN_WIDTH (w);
2135 height = WINDOW_FRAME_LINE_HEIGHT (w);
2137 r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
2138 end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
2140 if (w->pseudo_window_p)
2142 area = TEXT_AREA;
2143 part = ON_MODE_LINE; /* Don't adjust margin. */
2144 goto text_glyph;
2147 switch (part)
2149 case ON_LEFT_MARGIN:
2150 area = LEFT_MARGIN_AREA;
2151 goto text_glyph;
2153 case ON_RIGHT_MARGIN:
2154 area = RIGHT_MARGIN_AREA;
2155 goto text_glyph;
2157 case ON_HEADER_LINE:
2158 case ON_MODE_LINE:
2159 gr = (part == ON_HEADER_LINE
2160 ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
2161 : MATRIX_MODE_LINE_ROW (w->current_matrix));
2162 gy = gr->y;
2163 area = TEXT_AREA;
2164 goto text_glyph_row_found;
2166 case ON_TEXT:
2167 area = TEXT_AREA;
2169 text_glyph:
2170 gr = 0; gy = 0;
2171 for (; r <= end_row && r->enabled_p; ++r)
2172 if (r->y + r->height > y)
2174 gr = r; gy = r->y;
2175 break;
2178 text_glyph_row_found:
2179 if (gr && gy <= y)
2181 struct glyph *g = gr->glyphs[area];
2182 struct glyph *end = g + gr->used[area];
2184 height = gr->height;
2185 for (gx = gr->x; g < end; gx += g->pixel_width, ++g)
2186 if (gx + g->pixel_width > x)
2187 break;
2189 if (g < end)
2191 if (g->type == IMAGE_GLYPH)
2193 /* Don't remember when mouse is over image, as
2194 image may have hot-spots. */
2195 STORE_NATIVE_RECT (*rect, 0, 0, 0, 0);
2196 return;
2198 width = g->pixel_width;
2200 else
2202 /* Use nominal char spacing at end of line. */
2203 x -= gx;
2204 gx += (x / width) * width;
2207 if (part != ON_MODE_LINE && part != ON_HEADER_LINE)
2208 gx += window_box_left_offset (w, area);
2210 else
2212 /* Use nominal line height at end of window. */
2213 gx = (x / width) * width;
2214 y -= gy;
2215 gy += (y / height) * height;
2217 break;
2219 case ON_LEFT_FRINGE:
2220 gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2221 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w)
2222 : window_box_right_offset (w, LEFT_MARGIN_AREA));
2223 width = WINDOW_LEFT_FRINGE_WIDTH (w);
2224 goto row_glyph;
2226 case ON_RIGHT_FRINGE:
2227 gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2228 ? window_box_right_offset (w, RIGHT_MARGIN_AREA)
2229 : window_box_right_offset (w, TEXT_AREA));
2230 width = WINDOW_RIGHT_FRINGE_WIDTH (w);
2231 goto row_glyph;
2233 case ON_SCROLL_BAR:
2234 gx = (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
2236 : (window_box_right_offset (w, RIGHT_MARGIN_AREA)
2237 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
2238 ? WINDOW_RIGHT_FRINGE_WIDTH (w)
2239 : 0)));
2240 width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
2242 row_glyph:
2243 gr = 0, gy = 0;
2244 for (; r <= end_row && r->enabled_p; ++r)
2245 if (r->y + r->height > y)
2247 gr = r; gy = r->y;
2248 break;
2251 if (gr && gy <= y)
2252 height = gr->height;
2253 else
2255 /* Use nominal line height at end of window. */
2256 y -= gy;
2257 gy += (y / height) * height;
2259 break;
2261 default:
2263 virtual_glyph:
2264 /* If there is no glyph under the mouse, then we divide the screen
2265 into a grid of the smallest glyph in the frame, and use that
2266 as our "glyph". */
2268 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
2269 round down even for negative values. */
2270 if (gx < 0)
2271 gx -= width - 1;
2272 if (gy < 0)
2273 gy -= height - 1;
2275 gx = (gx / width) * width;
2276 gy = (gy / height) * height;
2278 goto store_rect;
2281 gx += WINDOW_LEFT_EDGE_X (w);
2282 gy += WINDOW_TOP_EDGE_Y (w);
2284 store_rect:
2285 STORE_NATIVE_RECT (*rect, gx, gy, width, height);
2287 /* Visible feedback for debugging. */
2288 #if 0
2289 #if HAVE_X_WINDOWS
2290 XDrawRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2291 f->output_data.x->normal_gc,
2292 gx, gy, width, height);
2293 #endif
2294 #endif
2298 #endif /* HAVE_WINDOW_SYSTEM */
2301 /***********************************************************************
2302 Lisp form evaluation
2303 ***********************************************************************/
2305 /* Error handler for safe_eval and safe_call. */
2307 static Lisp_Object
2308 safe_eval_handler (arg)
2309 Lisp_Object arg;
2311 add_to_log ("Error during redisplay: %s", arg, Qnil);
2312 return Qnil;
2316 /* Evaluate SEXPR and return the result, or nil if something went
2317 wrong. Prevent redisplay during the evaluation. */
2319 Lisp_Object
2320 safe_eval (sexpr)
2321 Lisp_Object sexpr;
2323 Lisp_Object val;
2325 if (inhibit_eval_during_redisplay)
2326 val = Qnil;
2327 else
2329 int count = SPECPDL_INDEX ();
2330 struct gcpro gcpro1;
2332 GCPRO1 (sexpr);
2333 specbind (Qinhibit_redisplay, Qt);
2334 /* Use Qt to ensure debugger does not run,
2335 so there is no possibility of wanting to redisplay. */
2336 val = internal_condition_case_1 (Feval, sexpr, Qt,
2337 safe_eval_handler);
2338 UNGCPRO;
2339 val = unbind_to (count, val);
2342 return val;
2346 /* Call function ARGS[0] with arguments ARGS[1] to ARGS[NARGS - 1].
2347 Return the result, or nil if something went wrong. Prevent
2348 redisplay during the evaluation. */
2350 Lisp_Object
2351 safe_call (nargs, args)
2352 int nargs;
2353 Lisp_Object *args;
2355 Lisp_Object val;
2357 if (inhibit_eval_during_redisplay)
2358 val = Qnil;
2359 else
2361 int count = SPECPDL_INDEX ();
2362 struct gcpro gcpro1;
2364 GCPRO1 (args[0]);
2365 gcpro1.nvars = nargs;
2366 specbind (Qinhibit_redisplay, Qt);
2367 /* Use Qt to ensure debugger does not run,
2368 so there is no possibility of wanting to redisplay. */
2369 val = internal_condition_case_2 (Ffuncall, nargs, args, Qt,
2370 safe_eval_handler);
2371 UNGCPRO;
2372 val = unbind_to (count, val);
2375 return val;
2379 /* Call function FN with one argument ARG.
2380 Return the result, or nil if something went wrong. */
2382 Lisp_Object
2383 safe_call1 (fn, arg)
2384 Lisp_Object fn, arg;
2386 Lisp_Object args[2];
2387 args[0] = fn;
2388 args[1] = arg;
2389 return safe_call (2, args);
2394 /***********************************************************************
2395 Debugging
2396 ***********************************************************************/
2398 #if 0
2400 /* Define CHECK_IT to perform sanity checks on iterators.
2401 This is for debugging. It is too slow to do unconditionally. */
2403 static void
2404 check_it (it)
2405 struct it *it;
2407 if (it->method == GET_FROM_STRING)
2409 xassert (STRINGP (it->string));
2410 xassert (IT_STRING_CHARPOS (*it) >= 0);
2412 else
2414 xassert (IT_STRING_CHARPOS (*it) < 0);
2415 if (it->method == GET_FROM_BUFFER)
2417 /* Check that character and byte positions agree. */
2418 xassert (IT_CHARPOS (*it) == BYTE_TO_CHAR (IT_BYTEPOS (*it)));
2422 if (it->dpvec)
2423 xassert (it->current.dpvec_index >= 0);
2424 else
2425 xassert (it->current.dpvec_index < 0);
2428 #define CHECK_IT(IT) check_it ((IT))
2430 #else /* not 0 */
2432 #define CHECK_IT(IT) (void) 0
2434 #endif /* not 0 */
2437 #if GLYPH_DEBUG
2439 /* Check that the window end of window W is what we expect it
2440 to be---the last row in the current matrix displaying text. */
2442 static void
2443 check_window_end (w)
2444 struct window *w;
2446 if (!MINI_WINDOW_P (w)
2447 && !NILP (w->window_end_valid))
2449 struct glyph_row *row;
2450 xassert ((row = MATRIX_ROW (w->current_matrix,
2451 XFASTINT (w->window_end_vpos)),
2452 !row->enabled_p
2453 || MATRIX_ROW_DISPLAYS_TEXT_P (row)
2454 || MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
2458 #define CHECK_WINDOW_END(W) check_window_end ((W))
2460 #else /* not GLYPH_DEBUG */
2462 #define CHECK_WINDOW_END(W) (void) 0
2464 #endif /* not GLYPH_DEBUG */
2468 /***********************************************************************
2469 Iterator initialization
2470 ***********************************************************************/
2472 /* Initialize IT for displaying current_buffer in window W, starting
2473 at character position CHARPOS. CHARPOS < 0 means that no buffer
2474 position is specified which is useful when the iterator is assigned
2475 a position later. BYTEPOS is the byte position corresponding to
2476 CHARPOS. BYTEPOS < 0 means compute it from CHARPOS.
2478 If ROW is not null, calls to produce_glyphs with IT as parameter
2479 will produce glyphs in that row.
2481 BASE_FACE_ID is the id of a base face to use. It must be one of
2482 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
2483 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
2484 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
2486 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
2487 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
2488 will be initialized to use the corresponding mode line glyph row of
2489 the desired matrix of W. */
2491 void
2492 init_iterator (it, w, charpos, bytepos, row, base_face_id)
2493 struct it *it;
2494 struct window *w;
2495 int charpos, bytepos;
2496 struct glyph_row *row;
2497 enum face_id base_face_id;
2499 int highlight_region_p;
2501 /* Some precondition checks. */
2502 xassert (w != NULL && it != NULL);
2503 xassert (charpos < 0 || (charpos >= BUF_BEG (current_buffer)
2504 && charpos <= ZV));
2506 /* If face attributes have been changed since the last redisplay,
2507 free realized faces now because they depend on face definitions
2508 that might have changed. Don't free faces while there might be
2509 desired matrices pending which reference these faces. */
2510 if (face_change_count && !inhibit_free_realized_faces)
2512 face_change_count = 0;
2513 free_all_realized_faces (Qnil);
2516 /* Use one of the mode line rows of W's desired matrix if
2517 appropriate. */
2518 if (row == NULL)
2520 if (base_face_id == MODE_LINE_FACE_ID
2521 || base_face_id == MODE_LINE_INACTIVE_FACE_ID)
2522 row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
2523 else if (base_face_id == HEADER_LINE_FACE_ID)
2524 row = MATRIX_HEADER_LINE_ROW (w->desired_matrix);
2527 /* Clear IT. */
2528 bzero (it, sizeof *it);
2529 it->current.overlay_string_index = -1;
2530 it->current.dpvec_index = -1;
2531 it->base_face_id = base_face_id;
2532 it->string = Qnil;
2533 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
2535 /* The window in which we iterate over current_buffer: */
2536 XSETWINDOW (it->window, w);
2537 it->w = w;
2538 it->f = XFRAME (w->frame);
2540 /* Extra space between lines (on window systems only). */
2541 if (base_face_id == DEFAULT_FACE_ID
2542 && FRAME_WINDOW_P (it->f))
2544 if (NATNUMP (current_buffer->extra_line_spacing))
2545 it->extra_line_spacing = XFASTINT (current_buffer->extra_line_spacing);
2546 else if (FLOATP (current_buffer->extra_line_spacing))
2547 it->extra_line_spacing = (XFLOAT_DATA (current_buffer->extra_line_spacing)
2548 * FRAME_LINE_HEIGHT (it->f));
2549 else if (it->f->extra_line_spacing > 0)
2550 it->extra_line_spacing = it->f->extra_line_spacing;
2551 it->max_extra_line_spacing = 0;
2554 /* If realized faces have been removed, e.g. because of face
2555 attribute changes of named faces, recompute them. When running
2556 in batch mode, the face cache of the initial frame is null. If
2557 we happen to get called, make a dummy face cache. */
2558 if (FRAME_FACE_CACHE (it->f) == NULL)
2559 init_frame_faces (it->f);
2560 if (FRAME_FACE_CACHE (it->f)->used == 0)
2561 recompute_basic_faces (it->f);
2563 /* Current value of the `slice', `space-width', and 'height' properties. */
2564 it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
2565 it->space_width = Qnil;
2566 it->font_height = Qnil;
2567 it->override_ascent = -1;
2569 /* Are control characters displayed as `^C'? */
2570 it->ctl_arrow_p = !NILP (current_buffer->ctl_arrow);
2572 /* -1 means everything between a CR and the following line end
2573 is invisible. >0 means lines indented more than this value are
2574 invisible. */
2575 it->selective = (INTEGERP (current_buffer->selective_display)
2576 ? XFASTINT (current_buffer->selective_display)
2577 : (!NILP (current_buffer->selective_display)
2578 ? -1 : 0));
2579 it->selective_display_ellipsis_p
2580 = !NILP (current_buffer->selective_display_ellipses);
2582 /* Display table to use. */
2583 it->dp = window_display_table (w);
2585 /* Are multibyte characters enabled in current_buffer? */
2586 it->multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
2588 /* Non-zero if we should highlight the region. */
2589 highlight_region_p
2590 = (!NILP (Vtransient_mark_mode)
2591 && !NILP (current_buffer->mark_active)
2592 && XMARKER (current_buffer->mark)->buffer != 0);
2594 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
2595 start and end of a visible region in window IT->w. Set both to
2596 -1 to indicate no region. */
2597 if (highlight_region_p
2598 /* Maybe highlight only in selected window. */
2599 && (/* Either show region everywhere. */
2600 highlight_nonselected_windows
2601 /* Or show region in the selected window. */
2602 || w == XWINDOW (selected_window)
2603 /* Or show the region if we are in the mini-buffer and W is
2604 the window the mini-buffer refers to. */
2605 || (MINI_WINDOW_P (XWINDOW (selected_window))
2606 && WINDOWP (minibuf_selected_window)
2607 && w == XWINDOW (minibuf_selected_window))))
2609 int charpos = marker_position (current_buffer->mark);
2610 it->region_beg_charpos = min (PT, charpos);
2611 it->region_end_charpos = max (PT, charpos);
2613 else
2614 it->region_beg_charpos = it->region_end_charpos = -1;
2616 /* Get the position at which the redisplay_end_trigger hook should
2617 be run, if it is to be run at all. */
2618 if (MARKERP (w->redisplay_end_trigger)
2619 && XMARKER (w->redisplay_end_trigger)->buffer != 0)
2620 it->redisplay_end_trigger_charpos
2621 = marker_position (w->redisplay_end_trigger);
2622 else if (INTEGERP (w->redisplay_end_trigger))
2623 it->redisplay_end_trigger_charpos = XINT (w->redisplay_end_trigger);
2625 /* Correct bogus values of tab_width. */
2626 it->tab_width = XINT (current_buffer->tab_width);
2627 if (it->tab_width <= 0 || it->tab_width > 1000)
2628 it->tab_width = 8;
2630 /* Are lines in the display truncated? */
2631 it->truncate_lines_p
2632 = (base_face_id != DEFAULT_FACE_ID
2633 || XINT (it->w->hscroll)
2634 || (truncate_partial_width_windows
2635 && !WINDOW_FULL_WIDTH_P (it->w))
2636 || !NILP (current_buffer->truncate_lines));
2638 /* Get dimensions of truncation and continuation glyphs. These are
2639 displayed as fringe bitmaps under X, so we don't need them for such
2640 frames. */
2641 if (!FRAME_WINDOW_P (it->f))
2643 if (it->truncate_lines_p)
2645 /* We will need the truncation glyph. */
2646 xassert (it->glyph_row == NULL);
2647 produce_special_glyphs (it, IT_TRUNCATION);
2648 it->truncation_pixel_width = it->pixel_width;
2650 else
2652 /* We will need the continuation glyph. */
2653 xassert (it->glyph_row == NULL);
2654 produce_special_glyphs (it, IT_CONTINUATION);
2655 it->continuation_pixel_width = it->pixel_width;
2658 /* Reset these values to zero because the produce_special_glyphs
2659 above has changed them. */
2660 it->pixel_width = it->ascent = it->descent = 0;
2661 it->phys_ascent = it->phys_descent = 0;
2664 /* Set this after getting the dimensions of truncation and
2665 continuation glyphs, so that we don't produce glyphs when calling
2666 produce_special_glyphs, above. */
2667 it->glyph_row = row;
2668 it->area = TEXT_AREA;
2670 /* Get the dimensions of the display area. The display area
2671 consists of the visible window area plus a horizontally scrolled
2672 part to the left of the window. All x-values are relative to the
2673 start of this total display area. */
2674 if (base_face_id != DEFAULT_FACE_ID)
2676 /* Mode lines, menu bar in terminal frames. */
2677 it->first_visible_x = 0;
2678 it->last_visible_x = WINDOW_TOTAL_WIDTH (w);
2680 else
2682 it->first_visible_x
2683 = XFASTINT (it->w->hscroll) * FRAME_COLUMN_WIDTH (it->f);
2684 it->last_visible_x = (it->first_visible_x
2685 + window_box_width (w, TEXT_AREA));
2687 /* If we truncate lines, leave room for the truncator glyph(s) at
2688 the right margin. Otherwise, leave room for the continuation
2689 glyph(s). Truncation and continuation glyphs are not inserted
2690 for window-based redisplay. */
2691 if (!FRAME_WINDOW_P (it->f))
2693 if (it->truncate_lines_p)
2694 it->last_visible_x -= it->truncation_pixel_width;
2695 else
2696 it->last_visible_x -= it->continuation_pixel_width;
2699 it->header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
2700 it->current_y = WINDOW_HEADER_LINE_HEIGHT (w) + w->vscroll;
2703 /* Leave room for a border glyph. */
2704 if (!FRAME_WINDOW_P (it->f)
2705 && !WINDOW_RIGHTMOST_P (it->w))
2706 it->last_visible_x -= 1;
2708 it->last_visible_y = window_text_bottom_y (w);
2710 /* For mode lines and alike, arrange for the first glyph having a
2711 left box line if the face specifies a box. */
2712 if (base_face_id != DEFAULT_FACE_ID)
2714 struct face *face;
2716 it->face_id = base_face_id;
2718 /* If we have a boxed mode line, make the first character appear
2719 with a left box line. */
2720 face = FACE_FROM_ID (it->f, base_face_id);
2721 if (face->box != FACE_NO_BOX)
2722 it->start_of_box_run_p = 1;
2725 /* If a buffer position was specified, set the iterator there,
2726 getting overlays and face properties from that position. */
2727 if (charpos >= BUF_BEG (current_buffer))
2729 it->end_charpos = ZV;
2730 it->face_id = -1;
2731 IT_CHARPOS (*it) = charpos;
2733 /* Compute byte position if not specified. */
2734 if (bytepos < charpos)
2735 IT_BYTEPOS (*it) = CHAR_TO_BYTE (charpos);
2736 else
2737 IT_BYTEPOS (*it) = bytepos;
2739 it->start = it->current;
2741 /* Compute faces etc. */
2742 reseat (it, it->current.pos, 1);
2745 CHECK_IT (it);
2749 /* Initialize IT for the display of window W with window start POS. */
2751 void
2752 start_display (it, w, pos)
2753 struct it *it;
2754 struct window *w;
2755 struct text_pos pos;
2757 struct glyph_row *row;
2758 int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
2760 row = w->desired_matrix->rows + first_vpos;
2761 init_iterator (it, w, CHARPOS (pos), BYTEPOS (pos), row, DEFAULT_FACE_ID);
2762 it->first_vpos = first_vpos;
2764 /* Don't reseat to previous visible line start if current start
2765 position is in a string or image. */
2766 if (it->method == GET_FROM_BUFFER && !it->truncate_lines_p)
2768 int start_at_line_beg_p;
2769 int first_y = it->current_y;
2771 /* If window start is not at a line start, skip forward to POS to
2772 get the correct continuation lines width. */
2773 start_at_line_beg_p = (CHARPOS (pos) == BEGV
2774 || FETCH_BYTE (BYTEPOS (pos) - 1) == '\n');
2775 if (!start_at_line_beg_p)
2777 int new_x;
2779 reseat_at_previous_visible_line_start (it);
2780 move_it_to (it, CHARPOS (pos), -1, -1, -1, MOVE_TO_POS);
2782 new_x = it->current_x + it->pixel_width;
2784 /* If lines are continued, this line may end in the middle
2785 of a multi-glyph character (e.g. a control character
2786 displayed as \003, or in the middle of an overlay
2787 string). In this case move_it_to above will not have
2788 taken us to the start of the continuation line but to the
2789 end of the continued line. */
2790 if (it->current_x > 0
2791 && !it->truncate_lines_p /* Lines are continued. */
2792 && (/* And glyph doesn't fit on the line. */
2793 new_x > it->last_visible_x
2794 /* Or it fits exactly and we're on a window
2795 system frame. */
2796 || (new_x == it->last_visible_x
2797 && FRAME_WINDOW_P (it->f))))
2799 if (it->current.dpvec_index >= 0
2800 || it->current.overlay_string_index >= 0)
2802 set_iterator_to_next (it, 1);
2803 move_it_in_display_line_to (it, -1, -1, 0);
2806 it->continuation_lines_width += it->current_x;
2809 /* We're starting a new display line, not affected by the
2810 height of the continued line, so clear the appropriate
2811 fields in the iterator structure. */
2812 it->max_ascent = it->max_descent = 0;
2813 it->max_phys_ascent = it->max_phys_descent = 0;
2815 it->current_y = first_y;
2816 it->vpos = 0;
2817 it->current_x = it->hpos = 0;
2821 #if 0 /* Don't assert the following because start_display is sometimes
2822 called intentionally with a window start that is not at a
2823 line start. Please leave this code in as a comment. */
2825 /* Window start should be on a line start, now. */
2826 xassert (it->continuation_lines_width
2827 || IT_CHARPOS (it) == BEGV
2828 || FETCH_BYTE (IT_BYTEPOS (it) - 1) == '\n');
2829 #endif /* 0 */
2833 /* Return 1 if POS is a position in ellipses displayed for invisible
2834 text. W is the window we display, for text property lookup. */
2836 static int
2837 in_ellipses_for_invisible_text_p (pos, w)
2838 struct display_pos *pos;
2839 struct window *w;
2841 Lisp_Object prop, window;
2842 int ellipses_p = 0;
2843 int charpos = CHARPOS (pos->pos);
2845 /* If POS specifies a position in a display vector, this might
2846 be for an ellipsis displayed for invisible text. We won't
2847 get the iterator set up for delivering that ellipsis unless
2848 we make sure that it gets aware of the invisible text. */
2849 if (pos->dpvec_index >= 0
2850 && pos->overlay_string_index < 0
2851 && CHARPOS (pos->string_pos) < 0
2852 && charpos > BEGV
2853 && (XSETWINDOW (window, w),
2854 prop = Fget_char_property (make_number (charpos),
2855 Qinvisible, window),
2856 !TEXT_PROP_MEANS_INVISIBLE (prop)))
2858 prop = Fget_char_property (make_number (charpos - 1), Qinvisible,
2859 window);
2860 ellipses_p = 2 == TEXT_PROP_MEANS_INVISIBLE (prop);
2863 return ellipses_p;
2867 /* Initialize IT for stepping through current_buffer in window W,
2868 starting at position POS that includes overlay string and display
2869 vector/ control character translation position information. Value
2870 is zero if there are overlay strings with newlines at POS. */
2872 static int
2873 init_from_display_pos (it, w, pos)
2874 struct it *it;
2875 struct window *w;
2876 struct display_pos *pos;
2878 int charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos);
2879 int i, overlay_strings_with_newlines = 0;
2881 /* If POS specifies a position in a display vector, this might
2882 be for an ellipsis displayed for invisible text. We won't
2883 get the iterator set up for delivering that ellipsis unless
2884 we make sure that it gets aware of the invisible text. */
2885 if (in_ellipses_for_invisible_text_p (pos, w))
2887 --charpos;
2888 bytepos = 0;
2891 /* Keep in mind: the call to reseat in init_iterator skips invisible
2892 text, so we might end up at a position different from POS. This
2893 is only a problem when POS is a row start after a newline and an
2894 overlay starts there with an after-string, and the overlay has an
2895 invisible property. Since we don't skip invisible text in
2896 display_line and elsewhere immediately after consuming the
2897 newline before the row start, such a POS will not be in a string,
2898 but the call to init_iterator below will move us to the
2899 after-string. */
2900 init_iterator (it, w, charpos, bytepos, NULL, DEFAULT_FACE_ID);
2902 /* This only scans the current chunk -- it should scan all chunks.
2903 However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
2904 to 16 in 22.1 to make this a lesser problem. */
2905 for (i = 0; i < it->n_overlay_strings && i < OVERLAY_STRING_CHUNK_SIZE; ++i)
2907 const char *s = SDATA (it->overlay_strings[i]);
2908 const char *e = s + SBYTES (it->overlay_strings[i]);
2910 while (s < e && *s != '\n')
2911 ++s;
2913 if (s < e)
2915 overlay_strings_with_newlines = 1;
2916 break;
2920 /* If position is within an overlay string, set up IT to the right
2921 overlay string. */
2922 if (pos->overlay_string_index >= 0)
2924 int relative_index;
2926 /* If the first overlay string happens to have a `display'
2927 property for an image, the iterator will be set up for that
2928 image, and we have to undo that setup first before we can
2929 correct the overlay string index. */
2930 if (it->method == GET_FROM_IMAGE)
2931 pop_it (it);
2933 /* We already have the first chunk of overlay strings in
2934 IT->overlay_strings. Load more until the one for
2935 pos->overlay_string_index is in IT->overlay_strings. */
2936 if (pos->overlay_string_index >= OVERLAY_STRING_CHUNK_SIZE)
2938 int n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE;
2939 it->current.overlay_string_index = 0;
2940 while (n--)
2942 load_overlay_strings (it, 0);
2943 it->current.overlay_string_index += OVERLAY_STRING_CHUNK_SIZE;
2947 it->current.overlay_string_index = pos->overlay_string_index;
2948 relative_index = (it->current.overlay_string_index
2949 % OVERLAY_STRING_CHUNK_SIZE);
2950 it->string = it->overlay_strings[relative_index];
2951 xassert (STRINGP (it->string));
2952 it->current.string_pos = pos->string_pos;
2953 it->method = GET_FROM_STRING;
2956 #if 0 /* This is bogus because POS not having an overlay string
2957 position does not mean it's after the string. Example: A
2958 line starting with a before-string and initialization of IT
2959 to the previous row's end position. */
2960 else if (it->current.overlay_string_index >= 0)
2962 /* If POS says we're already after an overlay string ending at
2963 POS, make sure to pop the iterator because it will be in
2964 front of that overlay string. When POS is ZV, we've thereby
2965 also ``processed'' overlay strings at ZV. */
2966 while (it->sp)
2967 pop_it (it);
2968 xassert (it->current.overlay_string_index == -1);
2969 xassert (it->method == GET_FROM_BUFFER);
2970 if (CHARPOS (pos->pos) == ZV)
2971 it->overlay_strings_at_end_processed_p = 1;
2973 #endif /* 0 */
2975 if (CHARPOS (pos->string_pos) >= 0)
2977 /* Recorded position is not in an overlay string, but in another
2978 string. This can only be a string from a `display' property.
2979 IT should already be filled with that string. */
2980 it->current.string_pos = pos->string_pos;
2981 xassert (STRINGP (it->string));
2984 /* Restore position in display vector translations, control
2985 character translations or ellipses. */
2986 if (pos->dpvec_index >= 0)
2988 if (it->dpvec == NULL)
2989 get_next_display_element (it);
2990 xassert (it->dpvec && it->current.dpvec_index == 0);
2991 it->current.dpvec_index = pos->dpvec_index;
2994 CHECK_IT (it);
2995 return !overlay_strings_with_newlines;
2999 /* Initialize IT for stepping through current_buffer in window W
3000 starting at ROW->start. */
3002 static void
3003 init_to_row_start (it, w, row)
3004 struct it *it;
3005 struct window *w;
3006 struct glyph_row *row;
3008 init_from_display_pos (it, w, &row->start);
3009 it->start = row->start;
3010 it->continuation_lines_width = row->continuation_lines_width;
3011 CHECK_IT (it);
3015 /* Initialize IT for stepping through current_buffer in window W
3016 starting in the line following ROW, i.e. starting at ROW->end.
3017 Value is zero if there are overlay strings with newlines at ROW's
3018 end position. */
3020 static int
3021 init_to_row_end (it, w, row)
3022 struct it *it;
3023 struct window *w;
3024 struct glyph_row *row;
3026 int success = 0;
3028 if (init_from_display_pos (it, w, &row->end))
3030 if (row->continued_p)
3031 it->continuation_lines_width
3032 = row->continuation_lines_width + row->pixel_width;
3033 CHECK_IT (it);
3034 success = 1;
3037 return success;
3043 /***********************************************************************
3044 Text properties
3045 ***********************************************************************/
3047 /* Called when IT reaches IT->stop_charpos. Handle text property and
3048 overlay changes. Set IT->stop_charpos to the next position where
3049 to stop. */
3051 static void
3052 handle_stop (it)
3053 struct it *it;
3055 enum prop_handled handled;
3056 int handle_overlay_change_p;
3057 struct props *p;
3059 it->dpvec = NULL;
3060 it->current.dpvec_index = -1;
3061 handle_overlay_change_p = !it->ignore_overlay_strings_at_pos_p;
3062 it->ignore_overlay_strings_at_pos_p = 0;
3064 /* Use face of preceding text for ellipsis (if invisible) */
3065 if (it->selective_display_ellipsis_p)
3066 it->saved_face_id = it->face_id;
3070 handled = HANDLED_NORMALLY;
3072 /* Call text property handlers. */
3073 for (p = it_props; p->handler; ++p)
3075 handled = p->handler (it);
3077 if (handled == HANDLED_RECOMPUTE_PROPS)
3078 break;
3079 else if (handled == HANDLED_RETURN)
3081 /* We still want to show before and after strings from
3082 overlays even if the actual buffer text is replaced. */
3083 if (!handle_overlay_change_p || it->sp > 1)
3084 return;
3085 if (!get_overlay_strings_1 (it, 0, 0))
3086 return;
3087 it->ignore_overlay_strings_at_pos_p = 1;
3088 it->string_from_display_prop_p = 0;
3089 handle_overlay_change_p = 0;
3090 handled = HANDLED_RECOMPUTE_PROPS;
3091 break;
3093 else if (handled == HANDLED_OVERLAY_STRING_CONSUMED)
3094 handle_overlay_change_p = 0;
3097 if (handled != HANDLED_RECOMPUTE_PROPS)
3099 /* Don't check for overlay strings below when set to deliver
3100 characters from a display vector. */
3101 if (it->method == GET_FROM_DISPLAY_VECTOR)
3102 handle_overlay_change_p = 0;
3104 /* Handle overlay changes.
3105 This sets HANDLED to HANDLED_RECOMPUTE_PROPS
3106 if it finds overlays. */
3107 if (handle_overlay_change_p)
3108 handled = handle_overlay_change (it);
3111 while (handled == HANDLED_RECOMPUTE_PROPS);
3113 /* Determine where to stop next. */
3114 if (handled == HANDLED_NORMALLY)
3115 compute_stop_pos (it);
3119 /* Compute IT->stop_charpos from text property and overlay change
3120 information for IT's current position. */
3122 static void
3123 compute_stop_pos (it)
3124 struct it *it;
3126 register INTERVAL iv, next_iv;
3127 Lisp_Object object, limit, position;
3129 /* If nowhere else, stop at the end. */
3130 it->stop_charpos = it->end_charpos;
3132 if (STRINGP (it->string))
3134 /* Strings are usually short, so don't limit the search for
3135 properties. */
3136 object = it->string;
3137 limit = Qnil;
3138 position = make_number (IT_STRING_CHARPOS (*it));
3140 else
3142 int charpos;
3144 /* If next overlay change is in front of the current stop pos
3145 (which is IT->end_charpos), stop there. Note: value of
3146 next_overlay_change is point-max if no overlay change
3147 follows. */
3148 charpos = next_overlay_change (IT_CHARPOS (*it));
3149 if (charpos < it->stop_charpos)
3150 it->stop_charpos = charpos;
3152 /* If showing the region, we have to stop at the region
3153 start or end because the face might change there. */
3154 if (it->region_beg_charpos > 0)
3156 if (IT_CHARPOS (*it) < it->region_beg_charpos)
3157 it->stop_charpos = min (it->stop_charpos, it->region_beg_charpos);
3158 else if (IT_CHARPOS (*it) < it->region_end_charpos)
3159 it->stop_charpos = min (it->stop_charpos, it->region_end_charpos);
3162 /* Set up variables for computing the stop position from text
3163 property changes. */
3164 XSETBUFFER (object, current_buffer);
3165 limit = make_number (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT);
3166 position = make_number (IT_CHARPOS (*it));
3170 /* Get the interval containing IT's position. Value is a null
3171 interval if there isn't such an interval. */
3172 iv = validate_interval_range (object, &position, &position, 0);
3173 if (!NULL_INTERVAL_P (iv))
3175 Lisp_Object values_here[LAST_PROP_IDX];
3176 struct props *p;
3178 /* Get properties here. */
3179 for (p = it_props; p->handler; ++p)
3180 values_here[p->idx] = textget (iv->plist, *p->name);
3182 /* Look for an interval following iv that has different
3183 properties. */
3184 for (next_iv = next_interval (iv);
3185 (!NULL_INTERVAL_P (next_iv)
3186 && (NILP (limit)
3187 || XFASTINT (limit) > next_iv->position));
3188 next_iv = next_interval (next_iv))
3190 for (p = it_props; p->handler; ++p)
3192 Lisp_Object new_value;
3194 new_value = textget (next_iv->plist, *p->name);
3195 if (!EQ (values_here[p->idx], new_value))
3196 break;
3199 if (p->handler)
3200 break;
3203 if (!NULL_INTERVAL_P (next_iv))
3205 if (INTEGERP (limit)
3206 && next_iv->position >= XFASTINT (limit))
3207 /* No text property change up to limit. */
3208 it->stop_charpos = min (XFASTINT (limit), it->stop_charpos);
3209 else
3210 /* Text properties change in next_iv. */
3211 it->stop_charpos = min (it->stop_charpos, next_iv->position);
3215 xassert (STRINGP (it->string)
3216 || (it->stop_charpos >= BEGV
3217 && it->stop_charpos >= IT_CHARPOS (*it)));
3221 /* Return the position of the next overlay change after POS in
3222 current_buffer. Value is point-max if no overlay change
3223 follows. This is like `next-overlay-change' but doesn't use
3224 xmalloc. */
3226 static EMACS_INT
3227 next_overlay_change (pos)
3228 EMACS_INT pos;
3230 int noverlays;
3231 EMACS_INT endpos;
3232 Lisp_Object *overlays;
3233 int i;
3235 /* Get all overlays at the given position. */
3236 GET_OVERLAYS_AT (pos, overlays, noverlays, &endpos, 1);
3238 /* If any of these overlays ends before endpos,
3239 use its ending point instead. */
3240 for (i = 0; i < noverlays; ++i)
3242 Lisp_Object oend;
3243 EMACS_INT oendpos;
3245 oend = OVERLAY_END (overlays[i]);
3246 oendpos = OVERLAY_POSITION (oend);
3247 endpos = min (endpos, oendpos);
3250 return endpos;
3255 /***********************************************************************
3256 Fontification
3257 ***********************************************************************/
3259 /* Handle changes in the `fontified' property of the current buffer by
3260 calling hook functions from Qfontification_functions to fontify
3261 regions of text. */
3263 static enum prop_handled
3264 handle_fontified_prop (it)
3265 struct it *it;
3267 Lisp_Object prop, pos;
3268 enum prop_handled handled = HANDLED_NORMALLY;
3270 if (!NILP (Vmemory_full))
3271 return handled;
3273 /* Get the value of the `fontified' property at IT's current buffer
3274 position. (The `fontified' property doesn't have a special
3275 meaning in strings.) If the value is nil, call functions from
3276 Qfontification_functions. */
3277 if (!STRINGP (it->string)
3278 && it->s == NULL
3279 && !NILP (Vfontification_functions)
3280 && !NILP (Vrun_hooks)
3281 && (pos = make_number (IT_CHARPOS (*it)),
3282 prop = Fget_char_property (pos, Qfontified, Qnil),
3283 /* Ignore the special cased nil value always present at EOB since
3284 no amount of fontifying will be able to change it. */
3285 NILP (prop) && IT_CHARPOS (*it) < Z))
3287 int count = SPECPDL_INDEX ();
3288 Lisp_Object val;
3290 val = Vfontification_functions;
3291 specbind (Qfontification_functions, Qnil);
3293 if (!CONSP (val) || EQ (XCAR (val), Qlambda))
3294 safe_call1 (val, pos);
3295 else
3297 Lisp_Object globals, fn;
3298 struct gcpro gcpro1, gcpro2;
3300 globals = Qnil;
3301 GCPRO2 (val, globals);
3303 for (; CONSP (val); val = XCDR (val))
3305 fn = XCAR (val);
3307 if (EQ (fn, Qt))
3309 /* A value of t indicates this hook has a local
3310 binding; it means to run the global binding too.
3311 In a global value, t should not occur. If it
3312 does, we must ignore it to avoid an endless
3313 loop. */
3314 for (globals = Fdefault_value (Qfontification_functions);
3315 CONSP (globals);
3316 globals = XCDR (globals))
3318 fn = XCAR (globals);
3319 if (!EQ (fn, Qt))
3320 safe_call1 (fn, pos);
3323 else
3324 safe_call1 (fn, pos);
3327 UNGCPRO;
3330 unbind_to (count, Qnil);
3332 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
3333 something. This avoids an endless loop if they failed to
3334 fontify the text for which reason ever. */
3335 if (!NILP (Fget_char_property (pos, Qfontified, Qnil)))
3336 handled = HANDLED_RECOMPUTE_PROPS;
3339 return handled;
3344 /***********************************************************************
3345 Faces
3346 ***********************************************************************/
3348 /* Set up iterator IT from face properties at its current position.
3349 Called from handle_stop. */
3351 static enum prop_handled
3352 handle_face_prop (it)
3353 struct it *it;
3355 int new_face_id;
3356 EMACS_INT next_stop;
3358 if (!STRINGP (it->string))
3360 new_face_id
3361 = face_at_buffer_position (it->w,
3362 IT_CHARPOS (*it),
3363 it->region_beg_charpos,
3364 it->region_end_charpos,
3365 &next_stop,
3366 (IT_CHARPOS (*it)
3367 + TEXT_PROP_DISTANCE_LIMIT),
3370 /* Is this a start of a run of characters with box face?
3371 Caveat: this can be called for a freshly initialized
3372 iterator; face_id is -1 in this case. We know that the new
3373 face will not change until limit, i.e. if the new face has a
3374 box, all characters up to limit will have one. But, as
3375 usual, we don't know whether limit is really the end. */
3376 if (new_face_id != it->face_id)
3378 struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
3380 /* If new face has a box but old face has not, this is
3381 the start of a run of characters with box, i.e. it has
3382 a shadow on the left side. The value of face_id of the
3383 iterator will be -1 if this is the initial call that gets
3384 the face. In this case, we have to look in front of IT's
3385 position and see whether there is a face != new_face_id. */
3386 it->start_of_box_run_p
3387 = (new_face->box != FACE_NO_BOX
3388 && (it->face_id >= 0
3389 || IT_CHARPOS (*it) == BEG
3390 || new_face_id != face_before_it_pos (it)));
3391 it->face_box_p = new_face->box != FACE_NO_BOX;
3394 else
3396 int base_face_id, bufpos;
3397 int i;
3398 Lisp_Object from_overlay
3399 = (it->current.overlay_string_index >= 0
3400 ? it->string_overlays[it->current.overlay_string_index]
3401 : Qnil);
3403 /* See if we got to this string directly or indirectly from
3404 an overlay property. That includes the before-string or
3405 after-string of an overlay, strings in display properties
3406 provided by an overlay, their text properties, etc.
3408 FROM_OVERLAY is the overlay that brought us here, or nil if none. */
3409 if (! NILP (from_overlay))
3410 for (i = it->sp - 1; i >= 0; i--)
3412 if (it->stack[i].current.overlay_string_index >= 0)
3413 from_overlay
3414 = it->string_overlays[it->stack[i].current.overlay_string_index];
3415 else if (! NILP (it->stack[i].from_overlay))
3416 from_overlay = it->stack[i].from_overlay;
3418 if (!NILP (from_overlay))
3419 break;
3422 if (! NILP (from_overlay))
3424 bufpos = IT_CHARPOS (*it);
3425 /* For a string from an overlay, the base face depends
3426 only on text properties and ignores overlays. */
3427 base_face_id
3428 = face_for_overlay_string (it->w,
3429 IT_CHARPOS (*it),
3430 it->region_beg_charpos,
3431 it->region_end_charpos,
3432 &next_stop,
3433 (IT_CHARPOS (*it)
3434 + TEXT_PROP_DISTANCE_LIMIT),
3436 from_overlay);
3438 else
3440 bufpos = 0;
3442 /* For strings from a `display' property, use the face at
3443 IT's current buffer position as the base face to merge
3444 with, so that overlay strings appear in the same face as
3445 surrounding text, unless they specify their own
3446 faces. */
3447 base_face_id = underlying_face_id (it);
3450 new_face_id = face_at_string_position (it->w,
3451 it->string,
3452 IT_STRING_CHARPOS (*it),
3453 bufpos,
3454 it->region_beg_charpos,
3455 it->region_end_charpos,
3456 &next_stop,
3457 base_face_id, 0);
3459 #if 0 /* This shouldn't be neccessary. Let's check it. */
3460 /* If IT is used to display a mode line we would really like to
3461 use the mode line face instead of the frame's default face. */
3462 if (it->glyph_row == MATRIX_MODE_LINE_ROW (it->w->desired_matrix)
3463 && new_face_id == DEFAULT_FACE_ID)
3464 new_face_id = CURRENT_MODE_LINE_FACE_ID (it->w);
3465 #endif
3467 /* Is this a start of a run of characters with box? Caveat:
3468 this can be called for a freshly allocated iterator; face_id
3469 is -1 is this case. We know that the new face will not
3470 change until the next check pos, i.e. if the new face has a
3471 box, all characters up to that position will have a
3472 box. But, as usual, we don't know whether that position
3473 is really the end. */
3474 if (new_face_id != it->face_id)
3476 struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
3477 struct face *old_face = FACE_FROM_ID (it->f, it->face_id);
3479 /* If new face has a box but old face hasn't, this is the
3480 start of a run of characters with box, i.e. it has a
3481 shadow on the left side. */
3482 it->start_of_box_run_p
3483 = new_face->box && (old_face == NULL || !old_face->box);
3484 it->face_box_p = new_face->box != FACE_NO_BOX;
3488 it->face_id = new_face_id;
3489 return HANDLED_NORMALLY;
3493 /* Return the ID of the face ``underlying'' IT's current position,
3494 which is in a string. If the iterator is associated with a
3495 buffer, return the face at IT's current buffer position.
3496 Otherwise, use the iterator's base_face_id. */
3498 static int
3499 underlying_face_id (it)
3500 struct it *it;
3502 int face_id = it->base_face_id, i;
3504 xassert (STRINGP (it->string));
3506 for (i = it->sp - 1; i >= 0; --i)
3507 if (NILP (it->stack[i].string))
3508 face_id = it->stack[i].face_id;
3510 return face_id;
3514 /* Compute the face one character before or after the current position
3515 of IT. BEFORE_P non-zero means get the face in front of IT's
3516 position. Value is the id of the face. */
3518 static int
3519 face_before_or_after_it_pos (it, before_p)
3520 struct it *it;
3521 int before_p;
3523 int face_id, limit;
3524 EMACS_INT next_check_charpos;
3525 struct text_pos pos;
3527 xassert (it->s == NULL);
3529 if (STRINGP (it->string))
3531 int bufpos, base_face_id;
3533 /* No face change past the end of the string (for the case
3534 we are padding with spaces). No face change before the
3535 string start. */
3536 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string)
3537 || (IT_STRING_CHARPOS (*it) == 0 && before_p))
3538 return it->face_id;
3540 /* Set pos to the position before or after IT's current position. */
3541 if (before_p)
3542 pos = string_pos (IT_STRING_CHARPOS (*it) - 1, it->string);
3543 else
3544 /* For composition, we must check the character after the
3545 composition. */
3546 pos = (it->what == IT_COMPOSITION
3547 ? string_pos (IT_STRING_CHARPOS (*it) + it->cmp_len, it->string)
3548 : string_pos (IT_STRING_CHARPOS (*it) + 1, it->string));
3550 if (it->current.overlay_string_index >= 0)
3551 bufpos = IT_CHARPOS (*it);
3552 else
3553 bufpos = 0;
3555 base_face_id = underlying_face_id (it);
3557 /* Get the face for ASCII, or unibyte. */
3558 face_id = face_at_string_position (it->w,
3559 it->string,
3560 CHARPOS (pos),
3561 bufpos,
3562 it->region_beg_charpos,
3563 it->region_end_charpos,
3564 &next_check_charpos,
3565 base_face_id, 0);
3567 /* Correct the face for charsets different from ASCII. Do it
3568 for the multibyte case only. The face returned above is
3569 suitable for unibyte text if IT->string is unibyte. */
3570 if (STRING_MULTIBYTE (it->string))
3572 const unsigned char *p = SDATA (it->string) + BYTEPOS (pos);
3573 int rest = SBYTES (it->string) - BYTEPOS (pos);
3574 int c, len;
3575 struct face *face = FACE_FROM_ID (it->f, face_id);
3577 c = string_char_and_length (p, rest, &len);
3578 face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), it->string);
3581 else
3583 if ((IT_CHARPOS (*it) >= ZV && !before_p)
3584 || (IT_CHARPOS (*it) <= BEGV && before_p))
3585 return it->face_id;
3587 limit = IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT;
3588 pos = it->current.pos;
3590 if (before_p)
3591 DEC_TEXT_POS (pos, it->multibyte_p);
3592 else
3594 if (it->what == IT_COMPOSITION)
3595 /* For composition, we must check the position after the
3596 composition. */
3597 pos.charpos += it->cmp_len, pos.bytepos += it->len;
3598 else
3599 INC_TEXT_POS (pos, it->multibyte_p);
3602 /* Determine face for CHARSET_ASCII, or unibyte. */
3603 face_id = face_at_buffer_position (it->w,
3604 CHARPOS (pos),
3605 it->region_beg_charpos,
3606 it->region_end_charpos,
3607 &next_check_charpos,
3608 limit, 0);
3610 /* Correct the face for charsets different from ASCII. Do it
3611 for the multibyte case only. The face returned above is
3612 suitable for unibyte text if current_buffer is unibyte. */
3613 if (it->multibyte_p)
3615 int c = FETCH_MULTIBYTE_CHAR (BYTEPOS (pos));
3616 struct face *face = FACE_FROM_ID (it->f, face_id);
3617 face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), Qnil);
3621 return face_id;
3626 /***********************************************************************
3627 Invisible text
3628 ***********************************************************************/
3630 /* Set up iterator IT from invisible properties at its current
3631 position. Called from handle_stop. */
3633 static enum prop_handled
3634 handle_invisible_prop (it)
3635 struct it *it;
3637 enum prop_handled handled = HANDLED_NORMALLY;
3639 if (STRINGP (it->string))
3641 extern Lisp_Object Qinvisible;
3642 Lisp_Object prop, end_charpos, limit, charpos;
3644 /* Get the value of the invisible text property at the
3645 current position. Value will be nil if there is no such
3646 property. */
3647 charpos = make_number (IT_STRING_CHARPOS (*it));
3648 prop = Fget_text_property (charpos, Qinvisible, it->string);
3650 if (!NILP (prop)
3651 && IT_STRING_CHARPOS (*it) < it->end_charpos)
3653 handled = HANDLED_RECOMPUTE_PROPS;
3655 /* Get the position at which the next change of the
3656 invisible text property can be found in IT->string.
3657 Value will be nil if the property value is the same for
3658 all the rest of IT->string. */
3659 XSETINT (limit, SCHARS (it->string));
3660 end_charpos = Fnext_single_property_change (charpos, Qinvisible,
3661 it->string, limit);
3663 /* Text at current position is invisible. The next
3664 change in the property is at position end_charpos.
3665 Move IT's current position to that position. */
3666 if (INTEGERP (end_charpos)
3667 && XFASTINT (end_charpos) < XFASTINT (limit))
3669 struct text_pos old;
3670 old = it->current.string_pos;
3671 IT_STRING_CHARPOS (*it) = XFASTINT (end_charpos);
3672 compute_string_pos (&it->current.string_pos, old, it->string);
3674 else
3676 /* The rest of the string is invisible. If this is an
3677 overlay string, proceed with the next overlay string
3678 or whatever comes and return a character from there. */
3679 if (it->current.overlay_string_index >= 0)
3681 next_overlay_string (it);
3682 /* Don't check for overlay strings when we just
3683 finished processing them. */
3684 handled = HANDLED_OVERLAY_STRING_CONSUMED;
3686 else
3688 IT_STRING_CHARPOS (*it) = SCHARS (it->string);
3689 IT_STRING_BYTEPOS (*it) = SBYTES (it->string);
3694 else
3696 int invis_p;
3697 EMACS_INT newpos, next_stop, start_charpos;
3698 Lisp_Object pos, prop, overlay;
3700 /* First of all, is there invisible text at this position? */
3701 start_charpos = IT_CHARPOS (*it);
3702 pos = make_number (IT_CHARPOS (*it));
3703 prop = get_char_property_and_overlay (pos, Qinvisible, it->window,
3704 &overlay);
3705 invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
3707 /* If we are on invisible text, skip over it. */
3708 if (invis_p && IT_CHARPOS (*it) < it->end_charpos)
3710 /* Record whether we have to display an ellipsis for the
3711 invisible text. */
3712 int display_ellipsis_p = invis_p == 2;
3714 handled = HANDLED_RECOMPUTE_PROPS;
3716 /* Loop skipping over invisible text. The loop is left at
3717 ZV or with IT on the first char being visible again. */
3720 /* Try to skip some invisible text. Return value is the
3721 position reached which can be equal to IT's position
3722 if there is nothing invisible here. This skips both
3723 over invisible text properties and overlays with
3724 invisible property. */
3725 newpos = skip_invisible (IT_CHARPOS (*it),
3726 &next_stop, ZV, it->window);
3728 /* If we skipped nothing at all we weren't at invisible
3729 text in the first place. If everything to the end of
3730 the buffer was skipped, end the loop. */
3731 if (newpos == IT_CHARPOS (*it) || newpos >= ZV)
3732 invis_p = 0;
3733 else
3735 /* We skipped some characters but not necessarily
3736 all there are. Check if we ended up on visible
3737 text. Fget_char_property returns the property of
3738 the char before the given position, i.e. if we
3739 get invis_p = 0, this means that the char at
3740 newpos is visible. */
3741 pos = make_number (newpos);
3742 prop = Fget_char_property (pos, Qinvisible, it->window);
3743 invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
3746 /* If we ended up on invisible text, proceed to
3747 skip starting with next_stop. */
3748 if (invis_p)
3749 IT_CHARPOS (*it) = next_stop;
3751 /* If there are adjacent invisible texts, don't lose the
3752 second one's ellipsis. */
3753 if (invis_p == 2)
3754 display_ellipsis_p = 1;
3756 while (invis_p);
3758 /* The position newpos is now either ZV or on visible text. */
3759 IT_CHARPOS (*it) = newpos;
3760 IT_BYTEPOS (*it) = CHAR_TO_BYTE (newpos);
3762 /* If there are before-strings at the start of invisible
3763 text, and the text is invisible because of a text
3764 property, arrange to show before-strings because 20.x did
3765 it that way. (If the text is invisible because of an
3766 overlay property instead of a text property, this is
3767 already handled in the overlay code.) */
3768 if (NILP (overlay)
3769 && get_overlay_strings (it, start_charpos))
3771 handled = HANDLED_RECOMPUTE_PROPS;
3772 it->stack[it->sp - 1].display_ellipsis_p = display_ellipsis_p;
3774 else if (display_ellipsis_p)
3776 /* Make sure that the glyphs of the ellipsis will get
3777 correct `charpos' values. If we would not update
3778 it->position here, the glyphs would belong to the
3779 last visible character _before_ the invisible
3780 text, which confuses `set_cursor_from_row'.
3782 We use the last invisible position instead of the
3783 first because this way the cursor is always drawn on
3784 the first "." of the ellipsis, whenever PT is inside
3785 the invisible text. Otherwise the cursor would be
3786 placed _after_ the ellipsis when the point is after the
3787 first invisible character. */
3788 if (!STRINGP (it->object))
3790 it->position.charpos = IT_CHARPOS (*it) - 1;
3791 it->position.bytepos = CHAR_TO_BYTE (it->position.charpos);
3793 setup_for_ellipsis (it, 0);
3794 /* Let the ellipsis display before
3795 considering any properties of the following char.
3796 Fixes jasonr@gnu.org 01 Oct 07 bug. */
3797 handled = HANDLED_RETURN;
3802 return handled;
3806 /* Make iterator IT return `...' next.
3807 Replaces LEN characters from buffer. */
3809 static void
3810 setup_for_ellipsis (it, len)
3811 struct it *it;
3812 int len;
3814 /* Use the display table definition for `...'. Invalid glyphs
3815 will be handled by the method returning elements from dpvec. */
3816 if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
3818 struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
3819 it->dpvec = v->contents;
3820 it->dpend = v->contents + v->size;
3822 else
3824 /* Default `...'. */
3825 it->dpvec = default_invis_vector;
3826 it->dpend = default_invis_vector + 3;
3829 it->dpvec_char_len = len;
3830 it->current.dpvec_index = 0;
3831 it->dpvec_face_id = -1;
3833 /* Remember the current face id in case glyphs specify faces.
3834 IT's face is restored in set_iterator_to_next.
3835 saved_face_id was set to preceding char's face in handle_stop. */
3836 if (it->saved_face_id < 0 || it->saved_face_id != it->face_id)
3837 it->saved_face_id = it->face_id = DEFAULT_FACE_ID;
3839 it->method = GET_FROM_DISPLAY_VECTOR;
3840 it->ellipsis_p = 1;
3845 /***********************************************************************
3846 'display' property
3847 ***********************************************************************/
3849 /* Set up iterator IT from `display' property at its current position.
3850 Called from handle_stop.
3851 We return HANDLED_RETURN if some part of the display property
3852 overrides the display of the buffer text itself.
3853 Otherwise we return HANDLED_NORMALLY. */
3855 static enum prop_handled
3856 handle_display_prop (it)
3857 struct it *it;
3859 Lisp_Object prop, object, overlay;
3860 struct text_pos *position;
3861 /* Nonzero if some property replaces the display of the text itself. */
3862 int display_replaced_p = 0;
3864 if (STRINGP (it->string))
3866 object = it->string;
3867 position = &it->current.string_pos;
3869 else
3871 XSETWINDOW (object, it->w);
3872 position = &it->current.pos;
3875 /* Reset those iterator values set from display property values. */
3876 it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
3877 it->space_width = Qnil;
3878 it->font_height = Qnil;
3879 it->voffset = 0;
3881 /* We don't support recursive `display' properties, i.e. string
3882 values that have a string `display' property, that have a string
3883 `display' property etc. */
3884 if (!it->string_from_display_prop_p)
3885 it->area = TEXT_AREA;
3887 prop = get_char_property_and_overlay (make_number (position->charpos),
3888 Qdisplay, object, &overlay);
3889 if (NILP (prop))
3890 return HANDLED_NORMALLY;
3891 /* Now OVERLAY is the overlay that gave us this property, or nil
3892 if it was a text property. */
3894 if (!STRINGP (it->string))
3895 object = it->w->buffer;
3897 if (CONSP (prop)
3898 /* Simple properties. */
3899 && !EQ (XCAR (prop), Qimage)
3900 && !EQ (XCAR (prop), Qspace)
3901 && !EQ (XCAR (prop), Qwhen)
3902 && !EQ (XCAR (prop), Qslice)
3903 && !EQ (XCAR (prop), Qspace_width)
3904 && !EQ (XCAR (prop), Qheight)
3905 && !EQ (XCAR (prop), Qraise)
3906 /* Marginal area specifications. */
3907 && !(CONSP (XCAR (prop)) && EQ (XCAR (XCAR (prop)), Qmargin))
3908 && !EQ (XCAR (prop), Qleft_fringe)
3909 && !EQ (XCAR (prop), Qright_fringe)
3910 && !NILP (XCAR (prop)))
3912 for (; CONSP (prop); prop = XCDR (prop))
3914 if (handle_single_display_spec (it, XCAR (prop), object, overlay,
3915 position, display_replaced_p))
3917 display_replaced_p = 1;
3918 /* If some text in a string is replaced, `position' no
3919 longer points to the position of `object'. */
3920 if (STRINGP (object))
3921 break;
3925 else if (VECTORP (prop))
3927 int i;
3928 for (i = 0; i < ASIZE (prop); ++i)
3929 if (handle_single_display_spec (it, AREF (prop, i), object, overlay,
3930 position, display_replaced_p))
3932 display_replaced_p = 1;
3933 /* If some text in a string is replaced, `position' no
3934 longer points to the position of `object'. */
3935 if (STRINGP (object))
3936 break;
3939 else
3941 int ret = handle_single_display_spec (it, prop, object, overlay,
3942 position, 0);
3943 if (ret < 0) /* Replaced by "", i.e. nothing. */
3944 return HANDLED_RECOMPUTE_PROPS;
3945 if (ret)
3946 display_replaced_p = 1;
3949 return display_replaced_p ? HANDLED_RETURN : HANDLED_NORMALLY;
3953 /* Value is the position of the end of the `display' property starting
3954 at START_POS in OBJECT. */
3956 static struct text_pos
3957 display_prop_end (it, object, start_pos)
3958 struct it *it;
3959 Lisp_Object object;
3960 struct text_pos start_pos;
3962 Lisp_Object end;
3963 struct text_pos end_pos;
3965 end = Fnext_single_char_property_change (make_number (CHARPOS (start_pos)),
3966 Qdisplay, object, Qnil);
3967 CHARPOS (end_pos) = XFASTINT (end);
3968 if (STRINGP (object))
3969 compute_string_pos (&end_pos, start_pos, it->string);
3970 else
3971 BYTEPOS (end_pos) = CHAR_TO_BYTE (XFASTINT (end));
3973 return end_pos;
3977 /* Set up IT from a single `display' specification PROP. OBJECT
3978 is the object in which the `display' property was found. *POSITION
3979 is the position at which it was found. DISPLAY_REPLACED_P non-zero
3980 means that we previously saw a display specification which already
3981 replaced text display with something else, for example an image;
3982 we ignore such properties after the first one has been processed.
3984 OVERLAY is the overlay this `display' property came from,
3985 or nil if it was a text property.
3987 If PROP is a `space' or `image' specification, and in some other
3988 cases too, set *POSITION to the position where the `display'
3989 property ends.
3991 Value is non-zero if something was found which replaces the display
3992 of buffer or string text. Specifically, the value is -1 if that
3993 "something" is "nothing". */
3995 static int
3996 handle_single_display_spec (it, spec, object, overlay, position,
3997 display_replaced_before_p)
3998 struct it *it;
3999 Lisp_Object spec;
4000 Lisp_Object object;
4001 Lisp_Object overlay;
4002 struct text_pos *position;
4003 int display_replaced_before_p;
4005 Lisp_Object form;
4006 Lisp_Object location, value;
4007 struct text_pos start_pos, save_pos;
4008 int valid_p;
4010 /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
4011 If the result is non-nil, use VALUE instead of SPEC. */
4012 form = Qt;
4013 if (CONSP (spec) && EQ (XCAR (spec), Qwhen))
4015 spec = XCDR (spec);
4016 if (!CONSP (spec))
4017 return 0;
4018 form = XCAR (spec);
4019 spec = XCDR (spec);
4022 if (!NILP (form) && !EQ (form, Qt))
4024 int count = SPECPDL_INDEX ();
4025 struct gcpro gcpro1;
4027 /* Bind `object' to the object having the `display' property, a
4028 buffer or string. Bind `position' to the position in the
4029 object where the property was found, and `buffer-position'
4030 to the current position in the buffer. */
4031 specbind (Qobject, object);
4032 specbind (Qposition, make_number (CHARPOS (*position)));
4033 specbind (Qbuffer_position,
4034 make_number (STRINGP (object)
4035 ? IT_CHARPOS (*it) : CHARPOS (*position)));
4036 GCPRO1 (form);
4037 form = safe_eval (form);
4038 UNGCPRO;
4039 unbind_to (count, Qnil);
4042 if (NILP (form))
4043 return 0;
4045 /* Handle `(height HEIGHT)' specifications. */
4046 if (CONSP (spec)
4047 && EQ (XCAR (spec), Qheight)
4048 && CONSP (XCDR (spec)))
4050 if (!FRAME_WINDOW_P (it->f))
4051 return 0;
4053 it->font_height = XCAR (XCDR (spec));
4054 if (!NILP (it->font_height))
4056 struct face *face = FACE_FROM_ID (it->f, it->face_id);
4057 int new_height = -1;
4059 if (CONSP (it->font_height)
4060 && (EQ (XCAR (it->font_height), Qplus)
4061 || EQ (XCAR (it->font_height), Qminus))
4062 && CONSP (XCDR (it->font_height))
4063 && INTEGERP (XCAR (XCDR (it->font_height))))
4065 /* `(+ N)' or `(- N)' where N is an integer. */
4066 int steps = XINT (XCAR (XCDR (it->font_height)));
4067 if (EQ (XCAR (it->font_height), Qplus))
4068 steps = - steps;
4069 it->face_id = smaller_face (it->f, it->face_id, steps);
4071 else if (FUNCTIONP (it->font_height))
4073 /* Call function with current height as argument.
4074 Value is the new height. */
4075 Lisp_Object height;
4076 height = safe_call1 (it->font_height,
4077 face->lface[LFACE_HEIGHT_INDEX]);
4078 if (NUMBERP (height))
4079 new_height = XFLOATINT (height);
4081 else if (NUMBERP (it->font_height))
4083 /* Value is a multiple of the canonical char height. */
4084 struct face *face;
4086 face = FACE_FROM_ID (it->f, DEFAULT_FACE_ID);
4087 new_height = (XFLOATINT (it->font_height)
4088 * XINT (face->lface[LFACE_HEIGHT_INDEX]));
4090 else
4092 /* Evaluate IT->font_height with `height' bound to the
4093 current specified height to get the new height. */
4094 int count = SPECPDL_INDEX ();
4096 specbind (Qheight, face->lface[LFACE_HEIGHT_INDEX]);
4097 value = safe_eval (it->font_height);
4098 unbind_to (count, Qnil);
4100 if (NUMBERP (value))
4101 new_height = XFLOATINT (value);
4104 if (new_height > 0)
4105 it->face_id = face_with_height (it->f, it->face_id, new_height);
4108 return 0;
4111 /* Handle `(space-width WIDTH)'. */
4112 if (CONSP (spec)
4113 && EQ (XCAR (spec), Qspace_width)
4114 && CONSP (XCDR (spec)))
4116 if (!FRAME_WINDOW_P (it->f))
4117 return 0;
4119 value = XCAR (XCDR (spec));
4120 if (NUMBERP (value) && XFLOATINT (value) > 0)
4121 it->space_width = value;
4123 return 0;
4126 /* Handle `(slice X Y WIDTH HEIGHT)'. */
4127 if (CONSP (spec)
4128 && EQ (XCAR (spec), Qslice))
4130 Lisp_Object tem;
4132 if (!FRAME_WINDOW_P (it->f))
4133 return 0;
4135 if (tem = XCDR (spec), CONSP (tem))
4137 it->slice.x = XCAR (tem);
4138 if (tem = XCDR (tem), CONSP (tem))
4140 it->slice.y = XCAR (tem);
4141 if (tem = XCDR (tem), CONSP (tem))
4143 it->slice.width = XCAR (tem);
4144 if (tem = XCDR (tem), CONSP (tem))
4145 it->slice.height = XCAR (tem);
4150 return 0;
4153 /* Handle `(raise FACTOR)'. */
4154 if (CONSP (spec)
4155 && EQ (XCAR (spec), Qraise)
4156 && CONSP (XCDR (spec)))
4158 if (!FRAME_WINDOW_P (it->f))
4159 return 0;
4161 #ifdef HAVE_WINDOW_SYSTEM
4162 value = XCAR (XCDR (spec));
4163 if (NUMBERP (value))
4165 struct face *face = FACE_FROM_ID (it->f, it->face_id);
4166 it->voffset = - (XFLOATINT (value)
4167 * (FONT_HEIGHT (face->font)));
4169 #endif /* HAVE_WINDOW_SYSTEM */
4171 return 0;
4174 /* Don't handle the other kinds of display specifications
4175 inside a string that we got from a `display' property. */
4176 if (it->string_from_display_prop_p)
4177 return 0;
4179 /* Characters having this form of property are not displayed, so
4180 we have to find the end of the property. */
4181 start_pos = *position;
4182 *position = display_prop_end (it, object, start_pos);
4183 value = Qnil;
4185 /* Stop the scan at that end position--we assume that all
4186 text properties change there. */
4187 it->stop_charpos = position->charpos;
4189 /* Handle `(left-fringe BITMAP [FACE])'
4190 and `(right-fringe BITMAP [FACE])'. */
4191 if (CONSP (spec)
4192 && (EQ (XCAR (spec), Qleft_fringe)
4193 || EQ (XCAR (spec), Qright_fringe))
4194 && CONSP (XCDR (spec)))
4196 int face_id = DEFAULT_FACE_ID;
4197 int fringe_bitmap;
4199 if (!FRAME_WINDOW_P (it->f))
4200 /* If we return here, POSITION has been advanced
4201 across the text with this property. */
4202 return 0;
4204 #ifdef HAVE_WINDOW_SYSTEM
4205 value = XCAR (XCDR (spec));
4206 if (!SYMBOLP (value)
4207 || !(fringe_bitmap = lookup_fringe_bitmap (value)))
4208 /* If we return here, POSITION has been advanced
4209 across the text with this property. */
4210 return 0;
4212 if (CONSP (XCDR (XCDR (spec))))
4214 Lisp_Object face_name = XCAR (XCDR (XCDR (spec)));
4215 int face_id2 = lookup_derived_face (it->f, face_name,
4216 FRINGE_FACE_ID, 0);
4217 if (face_id2 >= 0)
4218 face_id = face_id2;
4221 /* Save current settings of IT so that we can restore them
4222 when we are finished with the glyph property value. */
4224 save_pos = it->position;
4225 it->position = *position;
4226 push_it (it);
4227 it->position = save_pos;
4229 it->area = TEXT_AREA;
4230 it->what = IT_IMAGE;
4231 it->image_id = -1; /* no image */
4232 it->position = start_pos;
4233 it->object = NILP (object) ? it->w->buffer : object;
4234 it->method = GET_FROM_IMAGE;
4235 it->from_overlay = Qnil;
4236 it->face_id = face_id;
4238 /* Say that we haven't consumed the characters with
4239 `display' property yet. The call to pop_it in
4240 set_iterator_to_next will clean this up. */
4241 *position = start_pos;
4243 if (EQ (XCAR (spec), Qleft_fringe))
4245 it->left_user_fringe_bitmap = fringe_bitmap;
4246 it->left_user_fringe_face_id = face_id;
4248 else
4250 it->right_user_fringe_bitmap = fringe_bitmap;
4251 it->right_user_fringe_face_id = face_id;
4253 #endif /* HAVE_WINDOW_SYSTEM */
4254 return 1;
4257 /* Prepare to handle `((margin left-margin) ...)',
4258 `((margin right-margin) ...)' and `((margin nil) ...)'
4259 prefixes for display specifications. */
4260 location = Qunbound;
4261 if (CONSP (spec) && CONSP (XCAR (spec)))
4263 Lisp_Object tem;
4265 value = XCDR (spec);
4266 if (CONSP (value))
4267 value = XCAR (value);
4269 tem = XCAR (spec);
4270 if (EQ (XCAR (tem), Qmargin)
4271 && (tem = XCDR (tem),
4272 tem = CONSP (tem) ? XCAR (tem) : Qnil,
4273 (NILP (tem)
4274 || EQ (tem, Qleft_margin)
4275 || EQ (tem, Qright_margin))))
4276 location = tem;
4279 if (EQ (location, Qunbound))
4281 location = Qnil;
4282 value = spec;
4285 /* After this point, VALUE is the property after any
4286 margin prefix has been stripped. It must be a string,
4287 an image specification, or `(space ...)'.
4289 LOCATION specifies where to display: `left-margin',
4290 `right-margin' or nil. */
4292 valid_p = (STRINGP (value)
4293 #ifdef HAVE_WINDOW_SYSTEM
4294 || (FRAME_WINDOW_P (it->f) && valid_image_p (value))
4295 #endif /* not HAVE_WINDOW_SYSTEM */
4296 || (CONSP (value) && EQ (XCAR (value), Qspace)));
4298 if (valid_p && !display_replaced_before_p)
4300 /* Save current settings of IT so that we can restore them
4301 when we are finished with the glyph property value. */
4302 save_pos = it->position;
4303 it->position = *position;
4304 push_it (it);
4305 it->position = save_pos;
4306 it->from_overlay = overlay;
4308 if (NILP (location))
4309 it->area = TEXT_AREA;
4310 else if (EQ (location, Qleft_margin))
4311 it->area = LEFT_MARGIN_AREA;
4312 else
4313 it->area = RIGHT_MARGIN_AREA;
4315 if (STRINGP (value))
4317 if (SCHARS (value) == 0)
4319 pop_it (it);
4320 return -1; /* Replaced by "", i.e. nothing. */
4322 it->string = value;
4323 it->multibyte_p = STRING_MULTIBYTE (it->string);
4324 it->current.overlay_string_index = -1;
4325 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
4326 it->end_charpos = it->string_nchars = SCHARS (it->string);
4327 it->method = GET_FROM_STRING;
4328 it->stop_charpos = 0;
4329 it->string_from_display_prop_p = 1;
4330 /* Say that we haven't consumed the characters with
4331 `display' property yet. The call to pop_it in
4332 set_iterator_to_next will clean this up. */
4333 if (BUFFERP (object))
4334 it->current.pos = start_pos;
4336 else if (CONSP (value) && EQ (XCAR (value), Qspace))
4338 it->method = GET_FROM_STRETCH;
4339 it->object = value;
4340 it->position = start_pos;
4341 if (BUFFERP (object))
4342 it->current.pos = start_pos;
4344 #ifdef HAVE_WINDOW_SYSTEM
4345 else
4347 it->what = IT_IMAGE;
4348 it->image_id = lookup_image (it->f, value);
4349 it->position = start_pos;
4350 it->object = NILP (object) ? it->w->buffer : object;
4351 it->method = GET_FROM_IMAGE;
4353 /* Say that we haven't consumed the characters with
4354 `display' property yet. The call to pop_it in
4355 set_iterator_to_next will clean this up. */
4356 if (BUFFERP (object))
4357 it->current.pos = start_pos;
4359 #endif /* HAVE_WINDOW_SYSTEM */
4361 return 1;
4364 /* Invalid property or property not supported. Restore
4365 POSITION to what it was before. */
4366 *position = start_pos;
4367 return 0;
4371 /* Check if SPEC is a display sub-property value whose text should be
4372 treated as intangible. */
4374 static int
4375 single_display_spec_intangible_p (prop)
4376 Lisp_Object prop;
4378 /* Skip over `when FORM'. */
4379 if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
4381 prop = XCDR (prop);
4382 if (!CONSP (prop))
4383 return 0;
4384 prop = XCDR (prop);
4387 if (STRINGP (prop))
4388 return 1;
4390 if (!CONSP (prop))
4391 return 0;
4393 /* Skip over `margin LOCATION'. If LOCATION is in the margins,
4394 we don't need to treat text as intangible. */
4395 if (EQ (XCAR (prop), Qmargin))
4397 prop = XCDR (prop);
4398 if (!CONSP (prop))
4399 return 0;
4401 prop = XCDR (prop);
4402 if (!CONSP (prop)
4403 || EQ (XCAR (prop), Qleft_margin)
4404 || EQ (XCAR (prop), Qright_margin))
4405 return 0;
4408 return (CONSP (prop)
4409 && (EQ (XCAR (prop), Qimage)
4410 || EQ (XCAR (prop), Qspace)));
4414 /* Check if PROP is a display property value whose text should be
4415 treated as intangible. */
4418 display_prop_intangible_p (prop)
4419 Lisp_Object prop;
4421 if (CONSP (prop)
4422 && CONSP (XCAR (prop))
4423 && !EQ (Qmargin, XCAR (XCAR (prop))))
4425 /* A list of sub-properties. */
4426 while (CONSP (prop))
4428 if (single_display_spec_intangible_p (XCAR (prop)))
4429 return 1;
4430 prop = XCDR (prop);
4433 else if (VECTORP (prop))
4435 /* A vector of sub-properties. */
4436 int i;
4437 for (i = 0; i < ASIZE (prop); ++i)
4438 if (single_display_spec_intangible_p (AREF (prop, i)))
4439 return 1;
4441 else
4442 return single_display_spec_intangible_p (prop);
4444 return 0;
4448 /* Return 1 if PROP is a display sub-property value containing STRING. */
4450 static int
4451 single_display_spec_string_p (prop, string)
4452 Lisp_Object prop, string;
4454 if (EQ (string, prop))
4455 return 1;
4457 /* Skip over `when FORM'. */
4458 if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
4460 prop = XCDR (prop);
4461 if (!CONSP (prop))
4462 return 0;
4463 prop = XCDR (prop);
4466 if (CONSP (prop))
4467 /* Skip over `margin LOCATION'. */
4468 if (EQ (XCAR (prop), Qmargin))
4470 prop = XCDR (prop);
4471 if (!CONSP (prop))
4472 return 0;
4474 prop = XCDR (prop);
4475 if (!CONSP (prop))
4476 return 0;
4479 return CONSP (prop) && EQ (XCAR (prop), string);
4483 /* Return 1 if STRING appears in the `display' property PROP. */
4485 static int
4486 display_prop_string_p (prop, string)
4487 Lisp_Object prop, string;
4489 if (CONSP (prop)
4490 && CONSP (XCAR (prop))
4491 && !EQ (Qmargin, XCAR (XCAR (prop))))
4493 /* A list of sub-properties. */
4494 while (CONSP (prop))
4496 if (single_display_spec_string_p (XCAR (prop), string))
4497 return 1;
4498 prop = XCDR (prop);
4501 else if (VECTORP (prop))
4503 /* A vector of sub-properties. */
4504 int i;
4505 for (i = 0; i < ASIZE (prop); ++i)
4506 if (single_display_spec_string_p (AREF (prop, i), string))
4507 return 1;
4509 else
4510 return single_display_spec_string_p (prop, string);
4512 return 0;
4516 /* Determine from which buffer position in W's buffer STRING comes
4517 from. AROUND_CHARPOS is an approximate position where it could
4518 be from. Value is the buffer position or 0 if it couldn't be
4519 determined.
4521 W's buffer must be current.
4523 This function is necessary because we don't record buffer positions
4524 in glyphs generated from strings (to keep struct glyph small).
4525 This function may only use code that doesn't eval because it is
4526 called asynchronously from note_mouse_highlight. */
4529 string_buffer_position (w, string, around_charpos)
4530 struct window *w;
4531 Lisp_Object string;
4532 int around_charpos;
4534 Lisp_Object limit, prop, pos;
4535 const int MAX_DISTANCE = 1000;
4536 int found = 0;
4538 pos = make_number (around_charpos);
4539 limit = make_number (min (XINT (pos) + MAX_DISTANCE, ZV));
4540 while (!found && !EQ (pos, limit))
4542 prop = Fget_char_property (pos, Qdisplay, Qnil);
4543 if (!NILP (prop) && display_prop_string_p (prop, string))
4544 found = 1;
4545 else
4546 pos = Fnext_single_char_property_change (pos, Qdisplay, Qnil, limit);
4549 if (!found)
4551 pos = make_number (around_charpos);
4552 limit = make_number (max (XINT (pos) - MAX_DISTANCE, BEGV));
4553 while (!found && !EQ (pos, limit))
4555 prop = Fget_char_property (pos, Qdisplay, Qnil);
4556 if (!NILP (prop) && display_prop_string_p (prop, string))
4557 found = 1;
4558 else
4559 pos = Fprevious_single_char_property_change (pos, Qdisplay, Qnil,
4560 limit);
4564 return found ? XINT (pos) : 0;
4569 /***********************************************************************
4570 `composition' property
4571 ***********************************************************************/
4573 static enum prop_handled
4574 handle_auto_composed_prop (it)
4575 struct it *it;
4577 enum prop_handled handled = HANDLED_NORMALLY;
4579 if (FUNCTIONP (Vauto_composition_function))
4581 Lisp_Object val = Qnil;
4582 EMACS_INT pos, limit = -1;
4584 if (STRINGP (it->string))
4585 pos = IT_STRING_CHARPOS (*it);
4586 else
4587 pos = IT_CHARPOS (*it);
4589 val = Fget_text_property (make_number (pos), Qauto_composed, it->string);
4590 if (! NILP (val))
4592 Lisp_Object cmp_prop;
4593 EMACS_INT cmp_start, cmp_end;
4595 #ifdef USE_FONT_BACKEND
4596 if (enable_font_backend
4597 && get_property_and_range (pos, Qcomposition, &cmp_prop,
4598 &cmp_start, &cmp_end, it->string)
4599 && cmp_start == pos
4600 && COMPOSITION_METHOD (cmp_prop) == COMPOSITION_WITH_GLYPH_STRING)
4602 Lisp_Object gstring = COMPOSITION_COMPONENTS (cmp_prop);
4603 Lisp_Object font_object = LGSTRING_FONT (gstring);
4605 if (! EQ (font_object,
4606 font_at (-1, pos, FACE_FROM_ID (it->f, it->face_id),
4607 it->w, it->string)))
4608 /* We must re-compute the composition for the
4609 different font. */
4610 val = Qnil;
4612 #endif
4613 if (! NILP (val))
4615 Lisp_Object end;
4617 /* As Fnext_single_char_property_change is very slow, we
4618 limit the search to the current line. */
4619 if (STRINGP (it->string))
4620 limit = SCHARS (it->string);
4621 else
4622 limit = find_next_newline_no_quit (pos, 1);
4623 end = Fnext_single_char_property_change (make_number (pos),
4624 Qauto_composed,
4625 it->string,
4626 make_number (limit));
4628 if (XINT (end) < limit)
4629 /* The current point is auto-composed, but there exist
4630 characters not yet composed beyond the
4631 auto-composed region. There's a possiblity that
4632 the last characters in the region may be newly
4633 composed. */
4634 val = Qnil;
4637 if (NILP (val) && ! STRINGP (it->string))
4639 if (limit < 0)
4640 limit = (STRINGP (it->string) ? SCHARS (it->string)
4641 : find_next_newline_no_quit (pos, 1));
4642 if (pos < limit)
4644 int count = SPECPDL_INDEX ();
4645 Lisp_Object args[5];
4647 args[0] = Vauto_composition_function;
4648 specbind (Qauto_composition_function, Qnil);
4649 args[1] = make_number (pos);
4650 args[2] = make_number (limit);
4651 #ifdef USE_FONT_BACKEND
4652 if (enable_font_backend)
4653 args[3] = it->window;
4654 else
4655 #endif /* USE_FONT_BACKEND */
4656 args[3] = Qnil;
4657 args[4] = it->string;
4658 safe_call (5, args);
4659 unbind_to (count, Qnil);
4664 return handled;
4667 /* Set up iterator IT from `composition' property at its current
4668 position. Called from handle_stop. */
4670 static enum prop_handled
4671 handle_composition_prop (it)
4672 struct it *it;
4674 Lisp_Object prop, string;
4675 EMACS_INT pos, pos_byte, start, end;
4676 enum prop_handled handled = HANDLED_NORMALLY;
4678 if (STRINGP (it->string))
4680 unsigned char *s;
4682 pos = IT_STRING_CHARPOS (*it);
4683 pos_byte = IT_STRING_BYTEPOS (*it);
4684 string = it->string;
4685 s = SDATA (string) + pos_byte;
4686 it->c = STRING_CHAR (s, 0);
4688 else
4690 pos = IT_CHARPOS (*it);
4691 pos_byte = IT_BYTEPOS (*it);
4692 string = Qnil;
4693 it->c = FETCH_CHAR (pos_byte);
4696 /* If there's a valid composition and point is not inside of the
4697 composition (in the case that the composition is from the current
4698 buffer), draw a glyph composed from the composition components. */
4699 if (find_composition (pos, -1, &start, &end, &prop, string)
4700 && COMPOSITION_VALID_P (start, end, prop)
4701 && (STRINGP (it->string) || (PT <= start || PT >= end)))
4703 int id;
4705 if (start != pos)
4707 if (STRINGP (it->string))
4708 pos_byte = string_char_to_byte (it->string, start);
4709 else
4710 pos_byte = CHAR_TO_BYTE (start);
4712 id = get_composition_id (start, pos_byte, end - start, prop, string);
4714 if (id >= 0)
4716 struct composition *cmp = composition_table[id];
4718 if (cmp->glyph_len == 0)
4720 /* No glyph. */
4721 if (STRINGP (it->string))
4723 IT_STRING_CHARPOS (*it) = end;
4724 IT_STRING_BYTEPOS (*it) = string_char_to_byte (it->string,
4725 end);
4727 else
4729 IT_CHARPOS (*it) = end;
4730 IT_BYTEPOS (*it) = CHAR_TO_BYTE (end);
4732 return HANDLED_RECOMPUTE_PROPS;
4735 it->stop_charpos = end;
4736 push_it (it);
4738 it->method = GET_FROM_COMPOSITION;
4739 it->cmp_id = id;
4740 it->cmp_len = COMPOSITION_LENGTH (prop);
4741 /* For a terminal, draw only the first (non-TAB) character
4742 of the components. */
4743 #ifdef USE_FONT_BACKEND
4744 if (composition_table[id]->method == COMPOSITION_WITH_GLYPH_STRING)
4746 /* FIXME: This doesn't do anything!?! */
4747 Lisp_Object lgstring = AREF (XHASH_TABLE (composition_hash_table)
4748 ->key_and_value,
4749 cmp->hash_index * 2);
4751 else
4752 #endif /* USE_FONT_BACKEND */
4754 int i;
4756 for (i = 0; i < cmp->glyph_len; i++)
4757 if ((it->c = COMPOSITION_GLYPH (composition_table[id], i))
4758 != '\t')
4759 break;
4761 if (it->c == '\t')
4762 it->c = ' ';
4763 it->len = (STRINGP (it->string)
4764 ? string_char_to_byte (it->string, end)
4765 : CHAR_TO_BYTE (end)) - pos_byte;
4766 handled = HANDLED_RETURN;
4770 return handled;
4775 /***********************************************************************
4776 Overlay strings
4777 ***********************************************************************/
4779 /* The following structure is used to record overlay strings for
4780 later sorting in load_overlay_strings. */
4782 struct overlay_entry
4784 Lisp_Object overlay;
4785 Lisp_Object string;
4786 int priority;
4787 int after_string_p;
4791 /* Set up iterator IT from overlay strings at its current position.
4792 Called from handle_stop. */
4794 static enum prop_handled
4795 handle_overlay_change (it)
4796 struct it *it;
4798 if (!STRINGP (it->string) && get_overlay_strings (it, 0))
4799 return HANDLED_RECOMPUTE_PROPS;
4800 else
4801 return HANDLED_NORMALLY;
4805 /* Set up the next overlay string for delivery by IT, if there is an
4806 overlay string to deliver. Called by set_iterator_to_next when the
4807 end of the current overlay string is reached. If there are more
4808 overlay strings to display, IT->string and
4809 IT->current.overlay_string_index are set appropriately here.
4810 Otherwise IT->string is set to nil. */
4812 static void
4813 next_overlay_string (it)
4814 struct it *it;
4816 ++it->current.overlay_string_index;
4817 if (it->current.overlay_string_index == it->n_overlay_strings)
4819 /* No more overlay strings. Restore IT's settings to what
4820 they were before overlay strings were processed, and
4821 continue to deliver from current_buffer. */
4822 int display_ellipsis_p = it->stack[it->sp - 1].display_ellipsis_p;
4824 pop_it (it);
4825 xassert (it->sp > 0
4826 || it->method == GET_FROM_COMPOSITION
4827 || (NILP (it->string)
4828 && it->method == GET_FROM_BUFFER
4829 && it->stop_charpos >= BEGV
4830 && it->stop_charpos <= it->end_charpos));
4831 it->current.overlay_string_index = -1;
4832 it->n_overlay_strings = 0;
4834 /* If we're at the end of the buffer, record that we have
4835 processed the overlay strings there already, so that
4836 next_element_from_buffer doesn't try it again. */
4837 if (NILP (it->string) && IT_CHARPOS (*it) >= it->end_charpos)
4838 it->overlay_strings_at_end_processed_p = 1;
4840 /* If we have to display `...' for invisible text, set
4841 the iterator up for that. */
4842 if (display_ellipsis_p)
4843 setup_for_ellipsis (it, 0);
4845 else
4847 /* There are more overlay strings to process. If
4848 IT->current.overlay_string_index has advanced to a position
4849 where we must load IT->overlay_strings with more strings, do
4850 it. */
4851 int i = it->current.overlay_string_index % OVERLAY_STRING_CHUNK_SIZE;
4853 if (it->current.overlay_string_index && i == 0)
4854 load_overlay_strings (it, 0);
4856 /* Initialize IT to deliver display elements from the overlay
4857 string. */
4858 it->string = it->overlay_strings[i];
4859 it->multibyte_p = STRING_MULTIBYTE (it->string);
4860 SET_TEXT_POS (it->current.string_pos, 0, 0);
4861 it->method = GET_FROM_STRING;
4862 it->stop_charpos = 0;
4865 CHECK_IT (it);
4869 /* Compare two overlay_entry structures E1 and E2. Used as a
4870 comparison function for qsort in load_overlay_strings. Overlay
4871 strings for the same position are sorted so that
4873 1. All after-strings come in front of before-strings, except
4874 when they come from the same overlay.
4876 2. Within after-strings, strings are sorted so that overlay strings
4877 from overlays with higher priorities come first.
4879 2. Within before-strings, strings are sorted so that overlay
4880 strings from overlays with higher priorities come last.
4882 Value is analogous to strcmp. */
4885 static int
4886 compare_overlay_entries (e1, e2)
4887 void *e1, *e2;
4889 struct overlay_entry *entry1 = (struct overlay_entry *) e1;
4890 struct overlay_entry *entry2 = (struct overlay_entry *) e2;
4891 int result;
4893 if (entry1->after_string_p != entry2->after_string_p)
4895 /* Let after-strings appear in front of before-strings if
4896 they come from different overlays. */
4897 if (EQ (entry1->overlay, entry2->overlay))
4898 result = entry1->after_string_p ? 1 : -1;
4899 else
4900 result = entry1->after_string_p ? -1 : 1;
4902 else if (entry1->after_string_p)
4903 /* After-strings sorted in order of decreasing priority. */
4904 result = entry2->priority - entry1->priority;
4905 else
4906 /* Before-strings sorted in order of increasing priority. */
4907 result = entry1->priority - entry2->priority;
4909 return result;
4913 /* Load the vector IT->overlay_strings with overlay strings from IT's
4914 current buffer position, or from CHARPOS if that is > 0. Set
4915 IT->n_overlays to the total number of overlay strings found.
4917 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
4918 a time. On entry into load_overlay_strings,
4919 IT->current.overlay_string_index gives the number of overlay
4920 strings that have already been loaded by previous calls to this
4921 function.
4923 IT->add_overlay_start contains an additional overlay start
4924 position to consider for taking overlay strings from, if non-zero.
4925 This position comes into play when the overlay has an `invisible'
4926 property, and both before and after-strings. When we've skipped to
4927 the end of the overlay, because of its `invisible' property, we
4928 nevertheless want its before-string to appear.
4929 IT->add_overlay_start will contain the overlay start position
4930 in this case.
4932 Overlay strings are sorted so that after-string strings come in
4933 front of before-string strings. Within before and after-strings,
4934 strings are sorted by overlay priority. See also function
4935 compare_overlay_entries. */
4937 static void
4938 load_overlay_strings (it, charpos)
4939 struct it *it;
4940 int charpos;
4942 extern Lisp_Object Qafter_string, Qbefore_string, Qwindow, Qpriority;
4943 Lisp_Object overlay, window, str, invisible;
4944 struct Lisp_Overlay *ov;
4945 int start, end;
4946 int size = 20;
4947 int n = 0, i, j, invis_p;
4948 struct overlay_entry *entries
4949 = (struct overlay_entry *) alloca (size * sizeof *entries);
4951 if (charpos <= 0)
4952 charpos = IT_CHARPOS (*it);
4954 /* Append the overlay string STRING of overlay OVERLAY to vector
4955 `entries' which has size `size' and currently contains `n'
4956 elements. AFTER_P non-zero means STRING is an after-string of
4957 OVERLAY. */
4958 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
4959 do \
4961 Lisp_Object priority; \
4963 if (n == size) \
4965 int new_size = 2 * size; \
4966 struct overlay_entry *old = entries; \
4967 entries = \
4968 (struct overlay_entry *) alloca (new_size \
4969 * sizeof *entries); \
4970 bcopy (old, entries, size * sizeof *entries); \
4971 size = new_size; \
4974 entries[n].string = (STRING); \
4975 entries[n].overlay = (OVERLAY); \
4976 priority = Foverlay_get ((OVERLAY), Qpriority); \
4977 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
4978 entries[n].after_string_p = (AFTER_P); \
4979 ++n; \
4981 while (0)
4983 /* Process overlay before the overlay center. */
4984 for (ov = current_buffer->overlays_before; ov; ov = ov->next)
4986 XSETMISC (overlay, ov);
4987 xassert (OVERLAYP (overlay));
4988 start = OVERLAY_POSITION (OVERLAY_START (overlay));
4989 end = OVERLAY_POSITION (OVERLAY_END (overlay));
4991 if (end < charpos)
4992 break;
4994 /* Skip this overlay if it doesn't start or end at IT's current
4995 position. */
4996 if (end != charpos && start != charpos)
4997 continue;
4999 /* Skip this overlay if it doesn't apply to IT->w. */
5000 window = Foverlay_get (overlay, Qwindow);
5001 if (WINDOWP (window) && XWINDOW (window) != it->w)
5002 continue;
5004 /* If the text ``under'' the overlay is invisible, both before-
5005 and after-strings from this overlay are visible; start and
5006 end position are indistinguishable. */
5007 invisible = Foverlay_get (overlay, Qinvisible);
5008 invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible);
5010 /* If overlay has a non-empty before-string, record it. */
5011 if ((start == charpos || (end == charpos && invis_p))
5012 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
5013 && SCHARS (str))
5014 RECORD_OVERLAY_STRING (overlay, str, 0);
5016 /* If overlay has a non-empty after-string, record it. */
5017 if ((end == charpos || (start == charpos && invis_p))
5018 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
5019 && SCHARS (str))
5020 RECORD_OVERLAY_STRING (overlay, str, 1);
5023 /* Process overlays after the overlay center. */
5024 for (ov = current_buffer->overlays_after; ov; ov = ov->next)
5026 XSETMISC (overlay, ov);
5027 xassert (OVERLAYP (overlay));
5028 start = OVERLAY_POSITION (OVERLAY_START (overlay));
5029 end = OVERLAY_POSITION (OVERLAY_END (overlay));
5031 if (start > charpos)
5032 break;
5034 /* Skip this overlay if it doesn't start or end at IT's current
5035 position. */
5036 if (end != charpos && start != charpos)
5037 continue;
5039 /* Skip this overlay if it doesn't apply to IT->w. */
5040 window = Foverlay_get (overlay, Qwindow);
5041 if (WINDOWP (window) && XWINDOW (window) != it->w)
5042 continue;
5044 /* If the text ``under'' the overlay is invisible, it has a zero
5045 dimension, and both before- and after-strings apply. */
5046 invisible = Foverlay_get (overlay, Qinvisible);
5047 invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible);
5049 /* If overlay has a non-empty before-string, record it. */
5050 if ((start == charpos || (end == charpos && invis_p))
5051 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
5052 && SCHARS (str))
5053 RECORD_OVERLAY_STRING (overlay, str, 0);
5055 /* If overlay has a non-empty after-string, record it. */
5056 if ((end == charpos || (start == charpos && invis_p))
5057 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
5058 && SCHARS (str))
5059 RECORD_OVERLAY_STRING (overlay, str, 1);
5062 #undef RECORD_OVERLAY_STRING
5064 /* Sort entries. */
5065 if (n > 1)
5066 qsort (entries, n, sizeof *entries, compare_overlay_entries);
5068 /* Record the total number of strings to process. */
5069 it->n_overlay_strings = n;
5071 /* IT->current.overlay_string_index is the number of overlay strings
5072 that have already been consumed by IT. Copy some of the
5073 remaining overlay strings to IT->overlay_strings. */
5074 i = 0;
5075 j = it->current.overlay_string_index;
5076 while (i < OVERLAY_STRING_CHUNK_SIZE && j < n)
5078 it->overlay_strings[i] = entries[j].string;
5079 it->string_overlays[i++] = entries[j++].overlay;
5082 CHECK_IT (it);
5086 /* Get the first chunk of overlay strings at IT's current buffer
5087 position, or at CHARPOS if that is > 0. Value is non-zero if at
5088 least one overlay string was found. */
5090 static int
5091 get_overlay_strings_1 (it, charpos, compute_stop_p)
5092 struct it *it;
5093 int charpos;
5094 int compute_stop_p;
5096 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
5097 process. This fills IT->overlay_strings with strings, and sets
5098 IT->n_overlay_strings to the total number of strings to process.
5099 IT->pos.overlay_string_index has to be set temporarily to zero
5100 because load_overlay_strings needs this; it must be set to -1
5101 when no overlay strings are found because a zero value would
5102 indicate a position in the first overlay string. */
5103 it->current.overlay_string_index = 0;
5104 load_overlay_strings (it, charpos);
5106 /* If we found overlay strings, set up IT to deliver display
5107 elements from the first one. Otherwise set up IT to deliver
5108 from current_buffer. */
5109 if (it->n_overlay_strings)
5111 /* Make sure we know settings in current_buffer, so that we can
5112 restore meaningful values when we're done with the overlay
5113 strings. */
5114 if (compute_stop_p)
5115 compute_stop_pos (it);
5116 xassert (it->face_id >= 0);
5118 /* Save IT's settings. They are restored after all overlay
5119 strings have been processed. */
5120 xassert (!compute_stop_p || it->sp == 0);
5121 push_it (it);
5123 /* Set up IT to deliver display elements from the first overlay
5124 string. */
5125 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
5126 it->string = it->overlay_strings[0];
5127 it->from_overlay = Qnil;
5128 it->stop_charpos = 0;
5129 xassert (STRINGP (it->string));
5130 it->end_charpos = SCHARS (it->string);
5131 it->multibyte_p = STRING_MULTIBYTE (it->string);
5132 it->method = GET_FROM_STRING;
5133 return 1;
5136 it->current.overlay_string_index = -1;
5137 return 0;
5140 static int
5141 get_overlay_strings (it, charpos)
5142 struct it *it;
5143 int charpos;
5145 it->string = Qnil;
5146 it->method = GET_FROM_BUFFER;
5148 (void) get_overlay_strings_1 (it, charpos, 1);
5150 CHECK_IT (it);
5152 /* Value is non-zero if we found at least one overlay string. */
5153 return STRINGP (it->string);
5158 /***********************************************************************
5159 Saving and restoring state
5160 ***********************************************************************/
5162 /* Save current settings of IT on IT->stack. Called, for example,
5163 before setting up IT for an overlay string, to be able to restore
5164 IT's settings to what they were after the overlay string has been
5165 processed. */
5167 static void
5168 push_it (it)
5169 struct it *it;
5171 struct iterator_stack_entry *p;
5173 xassert (it->sp < IT_STACK_SIZE);
5174 p = it->stack + it->sp;
5176 p->stop_charpos = it->stop_charpos;
5177 xassert (it->face_id >= 0);
5178 p->face_id = it->face_id;
5179 p->string = it->string;
5180 p->method = it->method;
5181 p->from_overlay = it->from_overlay;
5182 switch (p->method)
5184 case GET_FROM_IMAGE:
5185 p->u.image.object = it->object;
5186 p->u.image.image_id = it->image_id;
5187 p->u.image.slice = it->slice;
5188 break;
5189 case GET_FROM_COMPOSITION:
5190 p->u.comp.object = it->object;
5191 p->u.comp.c = it->c;
5192 p->u.comp.len = it->len;
5193 p->u.comp.cmp_id = it->cmp_id;
5194 p->u.comp.cmp_len = it->cmp_len;
5195 break;
5196 case GET_FROM_STRETCH:
5197 p->u.stretch.object = it->object;
5198 break;
5200 p->position = it->position;
5201 p->current = it->current;
5202 p->end_charpos = it->end_charpos;
5203 p->string_nchars = it->string_nchars;
5204 p->area = it->area;
5205 p->multibyte_p = it->multibyte_p;
5206 p->space_width = it->space_width;
5207 p->font_height = it->font_height;
5208 p->voffset = it->voffset;
5209 p->string_from_display_prop_p = it->string_from_display_prop_p;
5210 p->display_ellipsis_p = 0;
5211 ++it->sp;
5215 /* Restore IT's settings from IT->stack. Called, for example, when no
5216 more overlay strings must be processed, and we return to delivering
5217 display elements from a buffer, or when the end of a string from a
5218 `display' property is reached and we return to delivering display
5219 elements from an overlay string, or from a buffer. */
5221 static void
5222 pop_it (it)
5223 struct it *it;
5225 struct iterator_stack_entry *p;
5227 xassert (it->sp > 0);
5228 --it->sp;
5229 p = it->stack + it->sp;
5230 it->stop_charpos = p->stop_charpos;
5231 it->face_id = p->face_id;
5232 it->current = p->current;
5233 it->position = p->position;
5234 it->string = p->string;
5235 it->from_overlay = p->from_overlay;
5236 if (NILP (it->string))
5237 SET_TEXT_POS (it->current.string_pos, -1, -1);
5238 it->method = p->method;
5239 switch (it->method)
5241 case GET_FROM_IMAGE:
5242 it->image_id = p->u.image.image_id;
5243 it->object = p->u.image.object;
5244 it->slice = p->u.image.slice;
5245 break;
5246 case GET_FROM_COMPOSITION:
5247 it->object = p->u.comp.object;
5248 it->c = p->u.comp.c;
5249 it->len = p->u.comp.len;
5250 it->cmp_id = p->u.comp.cmp_id;
5251 it->cmp_len = p->u.comp.cmp_len;
5252 break;
5253 case GET_FROM_STRETCH:
5254 it->object = p->u.comp.object;
5255 break;
5256 case GET_FROM_BUFFER:
5257 it->object = it->w->buffer;
5258 break;
5259 case GET_FROM_STRING:
5260 it->object = it->string;
5261 break;
5263 it->end_charpos = p->end_charpos;
5264 it->string_nchars = p->string_nchars;
5265 it->area = p->area;
5266 it->multibyte_p = p->multibyte_p;
5267 it->space_width = p->space_width;
5268 it->font_height = p->font_height;
5269 it->voffset = p->voffset;
5270 it->string_from_display_prop_p = p->string_from_display_prop_p;
5275 /***********************************************************************
5276 Moving over lines
5277 ***********************************************************************/
5279 /* Set IT's current position to the previous line start. */
5281 static void
5282 back_to_previous_line_start (it)
5283 struct it *it;
5285 IT_CHARPOS (*it) = find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1);
5286 IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
5290 /* Move IT to the next line start.
5292 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
5293 we skipped over part of the text (as opposed to moving the iterator
5294 continuously over the text). Otherwise, don't change the value
5295 of *SKIPPED_P.
5297 Newlines may come from buffer text, overlay strings, or strings
5298 displayed via the `display' property. That's the reason we can't
5299 simply use find_next_newline_no_quit.
5301 Note that this function may not skip over invisible text that is so
5302 because of text properties and immediately follows a newline. If
5303 it would, function reseat_at_next_visible_line_start, when called
5304 from set_iterator_to_next, would effectively make invisible
5305 characters following a newline part of the wrong glyph row, which
5306 leads to wrong cursor motion. */
5308 static int
5309 forward_to_next_line_start (it, skipped_p)
5310 struct it *it;
5311 int *skipped_p;
5313 int old_selective, newline_found_p, n;
5314 const int MAX_NEWLINE_DISTANCE = 500;
5316 /* If already on a newline, just consume it to avoid unintended
5317 skipping over invisible text below. */
5318 if (it->what == IT_CHARACTER
5319 && it->c == '\n'
5320 && CHARPOS (it->position) == IT_CHARPOS (*it))
5322 set_iterator_to_next (it, 0);
5323 it->c = 0;
5324 return 1;
5327 /* Don't handle selective display in the following. It's (a)
5328 unnecessary because it's done by the caller, and (b) leads to an
5329 infinite recursion because next_element_from_ellipsis indirectly
5330 calls this function. */
5331 old_selective = it->selective;
5332 it->selective = 0;
5334 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
5335 from buffer text. */
5336 for (n = newline_found_p = 0;
5337 !newline_found_p && n < MAX_NEWLINE_DISTANCE;
5338 n += STRINGP (it->string) ? 0 : 1)
5340 if (!get_next_display_element (it))
5341 return 0;
5342 newline_found_p = it->what == IT_CHARACTER && it->c == '\n';
5343 set_iterator_to_next (it, 0);
5346 /* If we didn't find a newline near enough, see if we can use a
5347 short-cut. */
5348 if (!newline_found_p)
5350 int start = IT_CHARPOS (*it);
5351 int limit = find_next_newline_no_quit (start, 1);
5352 Lisp_Object pos;
5354 xassert (!STRINGP (it->string));
5356 /* If there isn't any `display' property in sight, and no
5357 overlays, we can just use the position of the newline in
5358 buffer text. */
5359 if (it->stop_charpos >= limit
5360 || ((pos = Fnext_single_property_change (make_number (start),
5361 Qdisplay,
5362 Qnil, make_number (limit)),
5363 NILP (pos))
5364 && next_overlay_change (start) == ZV))
5366 IT_CHARPOS (*it) = limit;
5367 IT_BYTEPOS (*it) = CHAR_TO_BYTE (limit);
5368 *skipped_p = newline_found_p = 1;
5370 else
5372 while (get_next_display_element (it)
5373 && !newline_found_p)
5375 newline_found_p = ITERATOR_AT_END_OF_LINE_P (it);
5376 set_iterator_to_next (it, 0);
5381 it->selective = old_selective;
5382 return newline_found_p;
5386 /* Set IT's current position to the previous visible line start. Skip
5387 invisible text that is so either due to text properties or due to
5388 selective display. Caution: this does not change IT->current_x and
5389 IT->hpos. */
5391 static void
5392 back_to_previous_visible_line_start (it)
5393 struct it *it;
5395 while (IT_CHARPOS (*it) > BEGV)
5397 back_to_previous_line_start (it);
5399 if (IT_CHARPOS (*it) <= BEGV)
5400 break;
5402 /* If selective > 0, then lines indented more than that values
5403 are invisible. */
5404 if (it->selective > 0
5405 && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
5406 (double) it->selective)) /* iftc */
5407 continue;
5409 /* Check the newline before point for invisibility. */
5411 Lisp_Object prop;
5412 prop = Fget_char_property (make_number (IT_CHARPOS (*it) - 1),
5413 Qinvisible, it->window);
5414 if (TEXT_PROP_MEANS_INVISIBLE (prop))
5415 continue;
5418 if (IT_CHARPOS (*it) <= BEGV)
5419 break;
5422 struct it it2;
5423 int pos;
5424 EMACS_INT beg, end;
5425 Lisp_Object val, overlay;
5427 /* If newline is part of a composition, continue from start of composition */
5428 if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil)
5429 && beg < IT_CHARPOS (*it))
5430 goto replaced;
5432 /* If newline is replaced by a display property, find start of overlay
5433 or interval and continue search from that point. */
5434 it2 = *it;
5435 pos = --IT_CHARPOS (it2);
5436 --IT_BYTEPOS (it2);
5437 it2.sp = 0;
5438 if (handle_display_prop (&it2) == HANDLED_RETURN
5439 && !NILP (val = get_char_property_and_overlay
5440 (make_number (pos), Qdisplay, Qnil, &overlay))
5441 && (OVERLAYP (overlay)
5442 ? (beg = OVERLAY_POSITION (OVERLAY_START (overlay)))
5443 : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
5444 goto replaced;
5446 /* Newline is not replaced by anything -- so we are done. */
5447 break;
5449 replaced:
5450 if (beg < BEGV)
5451 beg = BEGV;
5452 IT_CHARPOS (*it) = beg;
5453 IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
5457 it->continuation_lines_width = 0;
5459 xassert (IT_CHARPOS (*it) >= BEGV);
5460 xassert (IT_CHARPOS (*it) == BEGV
5461 || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
5462 CHECK_IT (it);
5466 /* Reseat iterator IT at the previous visible line start. Skip
5467 invisible text that is so either due to text properties or due to
5468 selective display. At the end, update IT's overlay information,
5469 face information etc. */
5471 void
5472 reseat_at_previous_visible_line_start (it)
5473 struct it *it;
5475 back_to_previous_visible_line_start (it);
5476 reseat (it, it->current.pos, 1);
5477 CHECK_IT (it);
5481 /* Reseat iterator IT on the next visible line start in the current
5482 buffer. ON_NEWLINE_P non-zero means position IT on the newline
5483 preceding the line start. Skip over invisible text that is so
5484 because of selective display. Compute faces, overlays etc at the
5485 new position. Note that this function does not skip over text that
5486 is invisible because of text properties. */
5488 static void
5489 reseat_at_next_visible_line_start (it, on_newline_p)
5490 struct it *it;
5491 int on_newline_p;
5493 int newline_found_p, skipped_p = 0;
5495 newline_found_p = forward_to_next_line_start (it, &skipped_p);
5497 /* Skip over lines that are invisible because they are indented
5498 more than the value of IT->selective. */
5499 if (it->selective > 0)
5500 while (IT_CHARPOS (*it) < ZV
5501 && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
5502 (double) it->selective)) /* iftc */
5504 xassert (IT_BYTEPOS (*it) == BEGV
5505 || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
5506 newline_found_p = forward_to_next_line_start (it, &skipped_p);
5509 /* Position on the newline if that's what's requested. */
5510 if (on_newline_p && newline_found_p)
5512 if (STRINGP (it->string))
5514 if (IT_STRING_CHARPOS (*it) > 0)
5516 --IT_STRING_CHARPOS (*it);
5517 --IT_STRING_BYTEPOS (*it);
5520 else if (IT_CHARPOS (*it) > BEGV)
5522 --IT_CHARPOS (*it);
5523 --IT_BYTEPOS (*it);
5524 reseat (it, it->current.pos, 0);
5527 else if (skipped_p)
5528 reseat (it, it->current.pos, 0);
5530 CHECK_IT (it);
5535 /***********************************************************************
5536 Changing an iterator's position
5537 ***********************************************************************/
5539 /* Change IT's current position to POS in current_buffer. If FORCE_P
5540 is non-zero, always check for text properties at the new position.
5541 Otherwise, text properties are only looked up if POS >=
5542 IT->check_charpos of a property. */
5544 static void
5545 reseat (it, pos, force_p)
5546 struct it *it;
5547 struct text_pos pos;
5548 int force_p;
5550 int original_pos = IT_CHARPOS (*it);
5552 reseat_1 (it, pos, 0);
5554 /* Determine where to check text properties. Avoid doing it
5555 where possible because text property lookup is very expensive. */
5556 if (force_p
5557 || CHARPOS (pos) > it->stop_charpos
5558 || CHARPOS (pos) < original_pos)
5559 handle_stop (it);
5561 CHECK_IT (it);
5565 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
5566 IT->stop_pos to POS, also. */
5568 static void
5569 reseat_1 (it, pos, set_stop_p)
5570 struct it *it;
5571 struct text_pos pos;
5572 int set_stop_p;
5574 /* Don't call this function when scanning a C string. */
5575 xassert (it->s == NULL);
5577 /* POS must be a reasonable value. */
5578 xassert (CHARPOS (pos) >= BEGV && CHARPOS (pos) <= ZV);
5580 it->current.pos = it->position = pos;
5581 it->end_charpos = ZV;
5582 it->dpvec = NULL;
5583 it->current.dpvec_index = -1;
5584 it->current.overlay_string_index = -1;
5585 IT_STRING_CHARPOS (*it) = -1;
5586 IT_STRING_BYTEPOS (*it) = -1;
5587 it->string = Qnil;
5588 it->method = GET_FROM_BUFFER;
5589 it->object = it->w->buffer;
5590 it->area = TEXT_AREA;
5591 it->multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
5592 it->sp = 0;
5593 it->string_from_display_prop_p = 0;
5594 it->face_before_selective_p = 0;
5596 if (set_stop_p)
5597 it->stop_charpos = CHARPOS (pos);
5601 /* Set up IT for displaying a string, starting at CHARPOS in window W.
5602 If S is non-null, it is a C string to iterate over. Otherwise,
5603 STRING gives a Lisp string to iterate over.
5605 If PRECISION > 0, don't return more then PRECISION number of
5606 characters from the string.
5608 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
5609 characters have been returned. FIELD_WIDTH < 0 means an infinite
5610 field width.
5612 MULTIBYTE = 0 means disable processing of multibyte characters,
5613 MULTIBYTE > 0 means enable it,
5614 MULTIBYTE < 0 means use IT->multibyte_p.
5616 IT must be initialized via a prior call to init_iterator before
5617 calling this function. */
5619 static void
5620 reseat_to_string (it, s, string, charpos, precision, field_width, multibyte)
5621 struct it *it;
5622 unsigned char *s;
5623 Lisp_Object string;
5624 int charpos;
5625 int precision, field_width, multibyte;
5627 /* No region in strings. */
5628 it->region_beg_charpos = it->region_end_charpos = -1;
5630 /* No text property checks performed by default, but see below. */
5631 it->stop_charpos = -1;
5633 /* Set iterator position and end position. */
5634 bzero (&it->current, sizeof it->current);
5635 it->current.overlay_string_index = -1;
5636 it->current.dpvec_index = -1;
5637 xassert (charpos >= 0);
5639 /* If STRING is specified, use its multibyteness, otherwise use the
5640 setting of MULTIBYTE, if specified. */
5641 if (multibyte >= 0)
5642 it->multibyte_p = multibyte > 0;
5644 if (s == NULL)
5646 xassert (STRINGP (string));
5647 it->string = string;
5648 it->s = NULL;
5649 it->end_charpos = it->string_nchars = SCHARS (string);
5650 it->method = GET_FROM_STRING;
5651 it->current.string_pos = string_pos (charpos, string);
5653 else
5655 it->s = s;
5656 it->string = Qnil;
5658 /* Note that we use IT->current.pos, not it->current.string_pos,
5659 for displaying C strings. */
5660 IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
5661 if (it->multibyte_p)
5663 it->current.pos = c_string_pos (charpos, s, 1);
5664 it->end_charpos = it->string_nchars = number_of_chars (s, 1);
5666 else
5668 IT_CHARPOS (*it) = IT_BYTEPOS (*it) = charpos;
5669 it->end_charpos = it->string_nchars = strlen (s);
5672 it->method = GET_FROM_C_STRING;
5675 /* PRECISION > 0 means don't return more than PRECISION characters
5676 from the string. */
5677 if (precision > 0 && it->end_charpos - charpos > precision)
5678 it->end_charpos = it->string_nchars = charpos + precision;
5680 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
5681 characters have been returned. FIELD_WIDTH == 0 means don't pad,
5682 FIELD_WIDTH < 0 means infinite field width. This is useful for
5683 padding with `-' at the end of a mode line. */
5684 if (field_width < 0)
5685 field_width = INFINITY;
5686 if (field_width > it->end_charpos - charpos)
5687 it->end_charpos = charpos + field_width;
5689 /* Use the standard display table for displaying strings. */
5690 if (DISP_TABLE_P (Vstandard_display_table))
5691 it->dp = XCHAR_TABLE (Vstandard_display_table);
5693 it->stop_charpos = charpos;
5694 CHECK_IT (it);
5699 /***********************************************************************
5700 Iteration
5701 ***********************************************************************/
5703 /* Map enum it_method value to corresponding next_element_from_* function. */
5705 static int (* get_next_element[NUM_IT_METHODS]) P_ ((struct it *it)) =
5707 next_element_from_buffer,
5708 next_element_from_display_vector,
5709 next_element_from_composition,
5710 next_element_from_string,
5711 next_element_from_c_string,
5712 next_element_from_image,
5713 next_element_from_stretch
5717 /* Load IT's display element fields with information about the next
5718 display element from the current position of IT. Value is zero if
5719 end of buffer (or C string) is reached. */
5721 static struct frame *last_escape_glyph_frame = NULL;
5722 static unsigned last_escape_glyph_face_id = (1 << FACE_ID_BITS);
5723 static int last_escape_glyph_merged_face_id = 0;
5726 get_next_display_element (it)
5727 struct it *it;
5729 /* Non-zero means that we found a display element. Zero means that
5730 we hit the end of what we iterate over. Performance note: the
5731 function pointer `method' used here turns out to be faster than
5732 using a sequence of if-statements. */
5733 int success_p;
5735 get_next:
5736 success_p = (*get_next_element[it->method]) (it);
5738 if (it->what == IT_CHARACTER)
5740 /* Map via display table or translate control characters.
5741 IT->c, IT->len etc. have been set to the next character by
5742 the function call above. If we have a display table, and it
5743 contains an entry for IT->c, translate it. Don't do this if
5744 IT->c itself comes from a display table, otherwise we could
5745 end up in an infinite recursion. (An alternative could be to
5746 count the recursion depth of this function and signal an
5747 error when a certain maximum depth is reached.) Is it worth
5748 it? */
5749 if (success_p && it->dpvec == NULL)
5751 Lisp_Object dv;
5753 if (it->dp
5754 && (dv = DISP_CHAR_VECTOR (it->dp, it->c),
5755 VECTORP (dv)))
5757 struct Lisp_Vector *v = XVECTOR (dv);
5759 /* Return the first character from the display table
5760 entry, if not empty. If empty, don't display the
5761 current character. */
5762 if (v->size)
5764 it->dpvec_char_len = it->len;
5765 it->dpvec = v->contents;
5766 it->dpend = v->contents + v->size;
5767 it->current.dpvec_index = 0;
5768 it->dpvec_face_id = -1;
5769 it->saved_face_id = it->face_id;
5770 it->method = GET_FROM_DISPLAY_VECTOR;
5771 it->ellipsis_p = 0;
5773 else
5775 set_iterator_to_next (it, 0);
5777 goto get_next;
5780 /* Translate control characters into `\003' or `^C' form.
5781 Control characters coming from a display table entry are
5782 currently not translated because we use IT->dpvec to hold
5783 the translation. This could easily be changed but I
5784 don't believe that it is worth doing.
5786 If it->multibyte_p is nonzero, non-printable non-ASCII
5787 characters are also translated to octal form.
5789 If it->multibyte_p is zero, eight-bit characters that
5790 don't have corresponding multibyte char code are also
5791 translated to octal form. */
5792 else if ((it->c < ' '
5793 ? (it->area != TEXT_AREA
5794 /* In mode line, treat \n, \t like other crl chars. */
5795 || (it->c != '\t'
5796 && it->glyph_row && it->glyph_row->mode_line_p)
5797 || (it->c != '\n' && it->c != '\t'))
5798 : (it->multibyte_p
5799 ? (!CHAR_PRINTABLE_P (it->c)
5800 || (!NILP (Vnobreak_char_display)
5801 && (it->c == 0xA0 /* NO-BREAK SPACE */
5802 || it->c == 0xAD /* SOFT HYPHEN */)))
5803 : (it->c >= 127
5804 && (! unibyte_display_via_language_environment
5805 || (UNIBYTE_CHAR_HAS_MULTIBYTE_P (it->c)))))))
5807 /* IT->c is a control character which must be displayed
5808 either as '\003' or as `^C' where the '\\' and '^'
5809 can be defined in the display table. Fill
5810 IT->ctl_chars with glyphs for what we have to
5811 display. Then, set IT->dpvec to these glyphs. */
5812 Lisp_Object gc;
5813 int ctl_len;
5814 int face_id, lface_id = 0 ;
5815 int escape_glyph;
5817 /* Handle control characters with ^. */
5819 if (it->c < 128 && it->ctl_arrow_p)
5821 int g;
5823 g = '^'; /* default glyph for Control */
5824 /* Set IT->ctl_chars[0] to the glyph for `^'. */
5825 if (it->dp
5826 && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc))
5827 && GLYPH_CODE_CHAR_VALID_P (gc))
5829 g = GLYPH_CODE_CHAR (gc);
5830 lface_id = GLYPH_CODE_FACE (gc);
5832 if (lface_id)
5834 face_id = merge_faces (it->f, Qt, lface_id, it->face_id);
5836 else if (it->f == last_escape_glyph_frame
5837 && it->face_id == last_escape_glyph_face_id)
5839 face_id = last_escape_glyph_merged_face_id;
5841 else
5843 /* Merge the escape-glyph face into the current face. */
5844 face_id = merge_faces (it->f, Qescape_glyph, 0,
5845 it->face_id);
5846 last_escape_glyph_frame = it->f;
5847 last_escape_glyph_face_id = it->face_id;
5848 last_escape_glyph_merged_face_id = face_id;
5851 XSETINT (it->ctl_chars[0], g);
5852 XSETINT (it->ctl_chars[1], it->c ^ 0100);
5853 ctl_len = 2;
5854 goto display_control;
5857 /* Handle non-break space in the mode where it only gets
5858 highlighting. */
5860 if (EQ (Vnobreak_char_display, Qt)
5861 && it->c == 0xA0)
5863 /* Merge the no-break-space face into the current face. */
5864 face_id = merge_faces (it->f, Qnobreak_space, 0,
5865 it->face_id);
5867 it->c = ' ';
5868 XSETINT (it->ctl_chars[0], ' ');
5869 ctl_len = 1;
5870 goto display_control;
5873 /* Handle sequences that start with the "escape glyph". */
5875 /* the default escape glyph is \. */
5876 escape_glyph = '\\';
5878 if (it->dp
5879 && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc))
5880 && GLYPH_CODE_CHAR_VALID_P (gc))
5882 escape_glyph = GLYPH_CODE_CHAR (gc);
5883 lface_id = GLYPH_CODE_FACE (gc);
5885 if (lface_id)
5887 /* The display table specified a face.
5888 Merge it into face_id and also into escape_glyph. */
5889 face_id = merge_faces (it->f, Qt, lface_id,
5890 it->face_id);
5892 else if (it->f == last_escape_glyph_frame
5893 && it->face_id == last_escape_glyph_face_id)
5895 face_id = last_escape_glyph_merged_face_id;
5897 else
5899 /* Merge the escape-glyph face into the current face. */
5900 face_id = merge_faces (it->f, Qescape_glyph, 0,
5901 it->face_id);
5902 last_escape_glyph_frame = it->f;
5903 last_escape_glyph_face_id = it->face_id;
5904 last_escape_glyph_merged_face_id = face_id;
5907 /* Handle soft hyphens in the mode where they only get
5908 highlighting. */
5910 if (EQ (Vnobreak_char_display, Qt)
5911 && it->c == 0xAD)
5913 it->c = '-';
5914 XSETINT (it->ctl_chars[0], '-');
5915 ctl_len = 1;
5916 goto display_control;
5919 /* Handle non-break space and soft hyphen
5920 with the escape glyph. */
5922 if (it->c == 0xA0 || it->c == 0xAD)
5924 XSETINT (it->ctl_chars[0], escape_glyph);
5925 it->c = (it->c == 0xA0 ? ' ' : '-');
5926 XSETINT (it->ctl_chars[1], it->c);
5927 ctl_len = 2;
5928 goto display_control;
5932 unsigned char str[MAX_MULTIBYTE_LENGTH];
5933 int len;
5934 int i;
5936 /* Set IT->ctl_chars[0] to the glyph for `\\'. */
5937 if (CHAR_BYTE8_P (it->c))
5939 str[0] = CHAR_TO_BYTE8 (it->c);
5940 len = 1;
5942 else if (it->c < 256)
5944 str[0] = it->c;
5945 len = 1;
5947 else
5949 /* It's an invalid character, which shouldn't
5950 happen actually, but due to bugs it may
5951 happen. Let's print the char as is, there's
5952 not much meaningful we can do with it. */
5953 str[0] = it->c;
5954 str[1] = it->c >> 8;
5955 str[2] = it->c >> 16;
5956 str[3] = it->c >> 24;
5957 len = 4;
5960 for (i = 0; i < len; i++)
5962 int g;
5963 XSETINT (it->ctl_chars[i * 4], escape_glyph);
5964 /* Insert three more glyphs into IT->ctl_chars for
5965 the octal display of the character. */
5966 g = ((str[i] >> 6) & 7) + '0';
5967 XSETINT (it->ctl_chars[i * 4 + 1], g);
5968 g = ((str[i] >> 3) & 7) + '0';
5969 XSETINT (it->ctl_chars[i * 4 + 2], g);
5970 g = (str[i] & 7) + '0';
5971 XSETINT (it->ctl_chars[i * 4 + 3], g);
5973 ctl_len = len * 4;
5976 display_control:
5977 /* Set up IT->dpvec and return first character from it. */
5978 it->dpvec_char_len = it->len;
5979 it->dpvec = it->ctl_chars;
5980 it->dpend = it->dpvec + ctl_len;
5981 it->current.dpvec_index = 0;
5982 it->dpvec_face_id = face_id;
5983 it->saved_face_id = it->face_id;
5984 it->method = GET_FROM_DISPLAY_VECTOR;
5985 it->ellipsis_p = 0;
5986 goto get_next;
5991 /* Adjust face id for a multibyte character. There are no multibyte
5992 character in unibyte text. */
5993 if ((it->what == IT_CHARACTER || it->what == IT_COMPOSITION)
5994 && it->multibyte_p
5995 && success_p
5996 && FRAME_WINDOW_P (it->f))
5998 struct face *face = FACE_FROM_ID (it->f, it->face_id);
5999 int pos = (it->s ? -1
6000 : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
6001 : IT_CHARPOS (*it));
6003 it->face_id = FACE_FOR_CHAR (it->f, face, it->c, pos, it->string);
6006 /* Is this character the last one of a run of characters with
6007 box? If yes, set IT->end_of_box_run_p to 1. */
6008 if (it->face_box_p
6009 && it->s == NULL)
6011 int face_id;
6012 struct face *face;
6014 it->end_of_box_run_p
6015 = ((face_id = face_after_it_pos (it),
6016 face_id != it->face_id)
6017 && (face = FACE_FROM_ID (it->f, face_id),
6018 face->box == FACE_NO_BOX));
6021 /* Value is 0 if end of buffer or string reached. */
6022 return success_p;
6026 /* Move IT to the next display element.
6028 RESEAT_P non-zero means if called on a newline in buffer text,
6029 skip to the next visible line start.
6031 Functions get_next_display_element and set_iterator_to_next are
6032 separate because I find this arrangement easier to handle than a
6033 get_next_display_element function that also increments IT's
6034 position. The way it is we can first look at an iterator's current
6035 display element, decide whether it fits on a line, and if it does,
6036 increment the iterator position. The other way around we probably
6037 would either need a flag indicating whether the iterator has to be
6038 incremented the next time, or we would have to implement a
6039 decrement position function which would not be easy to write. */
6041 void
6042 set_iterator_to_next (it, reseat_p)
6043 struct it *it;
6044 int reseat_p;
6046 /* Reset flags indicating start and end of a sequence of characters
6047 with box. Reset them at the start of this function because
6048 moving the iterator to a new position might set them. */
6049 it->start_of_box_run_p = it->end_of_box_run_p = 0;
6051 switch (it->method)
6053 case GET_FROM_BUFFER:
6054 /* The current display element of IT is a character from
6055 current_buffer. Advance in the buffer, and maybe skip over
6056 invisible lines that are so because of selective display. */
6057 if (ITERATOR_AT_END_OF_LINE_P (it) && reseat_p)
6058 reseat_at_next_visible_line_start (it, 0);
6059 else
6061 xassert (it->len != 0);
6062 IT_BYTEPOS (*it) += it->len;
6063 IT_CHARPOS (*it) += 1;
6064 xassert (IT_BYTEPOS (*it) == CHAR_TO_BYTE (IT_CHARPOS (*it)));
6066 break;
6068 case GET_FROM_COMPOSITION:
6069 xassert (it->cmp_id >= 0 && it->cmp_id < n_compositions);
6070 xassert (it->sp > 0);
6071 pop_it (it);
6072 if (it->method == GET_FROM_STRING)
6074 IT_STRING_BYTEPOS (*it) += it->len;
6075 IT_STRING_CHARPOS (*it) += it->cmp_len;
6076 goto consider_string_end;
6078 else if (it->method == GET_FROM_BUFFER)
6080 IT_BYTEPOS (*it) += it->len;
6081 IT_CHARPOS (*it) += it->cmp_len;
6083 break;
6085 case GET_FROM_C_STRING:
6086 /* Current display element of IT is from a C string. */
6087 IT_BYTEPOS (*it) += it->len;
6088 IT_CHARPOS (*it) += 1;
6089 break;
6091 case GET_FROM_DISPLAY_VECTOR:
6092 /* Current display element of IT is from a display table entry.
6093 Advance in the display table definition. Reset it to null if
6094 end reached, and continue with characters from buffers/
6095 strings. */
6096 ++it->current.dpvec_index;
6098 /* Restore face of the iterator to what they were before the
6099 display vector entry (these entries may contain faces). */
6100 it->face_id = it->saved_face_id;
6102 if (it->dpvec + it->current.dpvec_index == it->dpend)
6104 int recheck_faces = it->ellipsis_p;
6106 if (it->s)
6107 it->method = GET_FROM_C_STRING;
6108 else if (STRINGP (it->string))
6109 it->method = GET_FROM_STRING;
6110 else
6112 it->method = GET_FROM_BUFFER;
6113 it->object = it->w->buffer;
6116 it->dpvec = NULL;
6117 it->current.dpvec_index = -1;
6119 /* Skip over characters which were displayed via IT->dpvec. */
6120 if (it->dpvec_char_len < 0)
6121 reseat_at_next_visible_line_start (it, 1);
6122 else if (it->dpvec_char_len > 0)
6124 if (it->method == GET_FROM_STRING
6125 && it->n_overlay_strings > 0)
6126 it->ignore_overlay_strings_at_pos_p = 1;
6127 it->len = it->dpvec_char_len;
6128 set_iterator_to_next (it, reseat_p);
6131 /* Maybe recheck faces after display vector */
6132 if (recheck_faces)
6133 it->stop_charpos = IT_CHARPOS (*it);
6135 break;
6137 case GET_FROM_STRING:
6138 /* Current display element is a character from a Lisp string. */
6139 xassert (it->s == NULL && STRINGP (it->string));
6140 IT_STRING_BYTEPOS (*it) += it->len;
6141 IT_STRING_CHARPOS (*it) += 1;
6143 consider_string_end:
6145 if (it->current.overlay_string_index >= 0)
6147 /* IT->string is an overlay string. Advance to the
6148 next, if there is one. */
6149 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
6150 next_overlay_string (it);
6152 else
6154 /* IT->string is not an overlay string. If we reached
6155 its end, and there is something on IT->stack, proceed
6156 with what is on the stack. This can be either another
6157 string, this time an overlay string, or a buffer. */
6158 if (IT_STRING_CHARPOS (*it) == SCHARS (it->string)
6159 && it->sp > 0)
6161 pop_it (it);
6162 if (it->method == GET_FROM_STRING)
6163 goto consider_string_end;
6166 break;
6168 case GET_FROM_IMAGE:
6169 case GET_FROM_STRETCH:
6170 /* The position etc with which we have to proceed are on
6171 the stack. The position may be at the end of a string,
6172 if the `display' property takes up the whole string. */
6173 xassert (it->sp > 0);
6174 pop_it (it);
6175 if (it->method == GET_FROM_STRING)
6176 goto consider_string_end;
6177 break;
6179 default:
6180 /* There are no other methods defined, so this should be a bug. */
6181 abort ();
6184 xassert (it->method != GET_FROM_STRING
6185 || (STRINGP (it->string)
6186 && IT_STRING_CHARPOS (*it) >= 0));
6189 /* Load IT's display element fields with information about the next
6190 display element which comes from a display table entry or from the
6191 result of translating a control character to one of the forms `^C'
6192 or `\003'.
6194 IT->dpvec holds the glyphs to return as characters.
6195 IT->saved_face_id holds the face id before the display vector--
6196 it is restored into IT->face_idin set_iterator_to_next. */
6198 static int
6199 next_element_from_display_vector (it)
6200 struct it *it;
6202 Lisp_Object gc;
6204 /* Precondition. */
6205 xassert (it->dpvec && it->current.dpvec_index >= 0);
6207 it->face_id = it->saved_face_id;
6209 /* KFS: This code used to check ip->dpvec[0] instead of the current element.
6210 That seemed totally bogus - so I changed it... */
6212 if ((gc = it->dpvec[it->current.dpvec_index], GLYPH_CODE_P (gc))
6213 && GLYPH_CODE_CHAR_VALID_P (gc))
6215 it->c = GLYPH_CODE_CHAR (gc);
6216 it->len = CHAR_BYTES (it->c);
6218 /* The entry may contain a face id to use. Such a face id is
6219 the id of a Lisp face, not a realized face. A face id of
6220 zero means no face is specified. */
6221 if (it->dpvec_face_id >= 0)
6222 it->face_id = it->dpvec_face_id;
6223 else
6225 int lface_id = GLYPH_CODE_FACE (gc);
6226 if (lface_id > 0)
6227 it->face_id = merge_faces (it->f, Qt, lface_id,
6228 it->saved_face_id);
6231 else
6232 /* Display table entry is invalid. Return a space. */
6233 it->c = ' ', it->len = 1;
6235 /* Don't change position and object of the iterator here. They are
6236 still the values of the character that had this display table
6237 entry or was translated, and that's what we want. */
6238 it->what = IT_CHARACTER;
6239 return 1;
6243 /* Load IT with the next display element from Lisp string IT->string.
6244 IT->current.string_pos is the current position within the string.
6245 If IT->current.overlay_string_index >= 0, the Lisp string is an
6246 overlay string. */
6248 static int
6249 next_element_from_string (it)
6250 struct it *it;
6252 struct text_pos position;
6254 xassert (STRINGP (it->string));
6255 xassert (IT_STRING_CHARPOS (*it) >= 0);
6256 position = it->current.string_pos;
6258 /* Time to check for invisible text? */
6259 if (IT_STRING_CHARPOS (*it) < it->end_charpos
6260 && IT_STRING_CHARPOS (*it) == it->stop_charpos)
6262 handle_stop (it);
6264 /* Since a handler may have changed IT->method, we must
6265 recurse here. */
6266 return get_next_display_element (it);
6269 if (it->current.overlay_string_index >= 0)
6271 /* Get the next character from an overlay string. In overlay
6272 strings, There is no field width or padding with spaces to
6273 do. */
6274 if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
6276 it->what = IT_EOB;
6277 return 0;
6279 else if (STRING_MULTIBYTE (it->string))
6281 int remaining = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
6282 const unsigned char *s = (SDATA (it->string)
6283 + IT_STRING_BYTEPOS (*it));
6284 it->c = string_char_and_length (s, remaining, &it->len);
6286 else
6288 it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
6289 it->len = 1;
6292 else
6294 /* Get the next character from a Lisp string that is not an
6295 overlay string. Such strings come from the mode line, for
6296 example. We may have to pad with spaces, or truncate the
6297 string. See also next_element_from_c_string. */
6298 if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
6300 it->what = IT_EOB;
6301 return 0;
6303 else if (IT_STRING_CHARPOS (*it) >= it->string_nchars)
6305 /* Pad with spaces. */
6306 it->c = ' ', it->len = 1;
6307 CHARPOS (position) = BYTEPOS (position) = -1;
6309 else if (STRING_MULTIBYTE (it->string))
6311 int maxlen = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
6312 const unsigned char *s = (SDATA (it->string)
6313 + IT_STRING_BYTEPOS (*it));
6314 it->c = string_char_and_length (s, maxlen, &it->len);
6316 else
6318 it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
6319 it->len = 1;
6323 /* Record what we have and where it came from. */
6324 it->what = IT_CHARACTER;
6325 it->object = it->string;
6326 it->position = position;
6327 return 1;
6331 /* Load IT with next display element from C string IT->s.
6332 IT->string_nchars is the maximum number of characters to return
6333 from the string. IT->end_charpos may be greater than
6334 IT->string_nchars when this function is called, in which case we
6335 may have to return padding spaces. Value is zero if end of string
6336 reached, including padding spaces. */
6338 static int
6339 next_element_from_c_string (it)
6340 struct it *it;
6342 int success_p = 1;
6344 xassert (it->s);
6345 it->what = IT_CHARACTER;
6346 BYTEPOS (it->position) = CHARPOS (it->position) = 0;
6347 it->object = Qnil;
6349 /* IT's position can be greater IT->string_nchars in case a field
6350 width or precision has been specified when the iterator was
6351 initialized. */
6352 if (IT_CHARPOS (*it) >= it->end_charpos)
6354 /* End of the game. */
6355 it->what = IT_EOB;
6356 success_p = 0;
6358 else if (IT_CHARPOS (*it) >= it->string_nchars)
6360 /* Pad with spaces. */
6361 it->c = ' ', it->len = 1;
6362 BYTEPOS (it->position) = CHARPOS (it->position) = -1;
6364 else if (it->multibyte_p)
6366 /* Implementation note: The calls to strlen apparently aren't a
6367 performance problem because there is no noticeable performance
6368 difference between Emacs running in unibyte or multibyte mode. */
6369 int maxlen = strlen (it->s) - IT_BYTEPOS (*it);
6370 it->c = string_char_and_length (it->s + IT_BYTEPOS (*it),
6371 maxlen, &it->len);
6373 else
6374 it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
6376 return success_p;
6380 /* Set up IT to return characters from an ellipsis, if appropriate.
6381 The definition of the ellipsis glyphs may come from a display table
6382 entry. This function Fills IT with the first glyph from the
6383 ellipsis if an ellipsis is to be displayed. */
6385 static int
6386 next_element_from_ellipsis (it)
6387 struct it *it;
6389 if (it->selective_display_ellipsis_p)
6390 setup_for_ellipsis (it, it->len);
6391 else
6393 /* The face at the current position may be different from the
6394 face we find after the invisible text. Remember what it
6395 was in IT->saved_face_id, and signal that it's there by
6396 setting face_before_selective_p. */
6397 it->saved_face_id = it->face_id;
6398 it->method = GET_FROM_BUFFER;
6399 it->object = it->w->buffer;
6400 reseat_at_next_visible_line_start (it, 1);
6401 it->face_before_selective_p = 1;
6404 return get_next_display_element (it);
6408 /* Deliver an image display element. The iterator IT is already
6409 filled with image information (done in handle_display_prop). Value
6410 is always 1. */
6413 static int
6414 next_element_from_image (it)
6415 struct it *it;
6417 it->what = IT_IMAGE;
6418 return 1;
6422 /* Fill iterator IT with next display element from a stretch glyph
6423 property. IT->object is the value of the text property. Value is
6424 always 1. */
6426 static int
6427 next_element_from_stretch (it)
6428 struct it *it;
6430 it->what = IT_STRETCH;
6431 return 1;
6435 /* Load IT with the next display element from current_buffer. Value
6436 is zero if end of buffer reached. IT->stop_charpos is the next
6437 position at which to stop and check for text properties or buffer
6438 end. */
6440 static int
6441 next_element_from_buffer (it)
6442 struct it *it;
6444 int success_p = 1;
6446 /* Check this assumption, otherwise, we would never enter the
6447 if-statement, below. */
6448 xassert (IT_CHARPOS (*it) >= BEGV
6449 && IT_CHARPOS (*it) <= it->stop_charpos);
6451 if (IT_CHARPOS (*it) >= it->stop_charpos)
6453 if (IT_CHARPOS (*it) >= it->end_charpos)
6455 int overlay_strings_follow_p;
6457 /* End of the game, except when overlay strings follow that
6458 haven't been returned yet. */
6459 if (it->overlay_strings_at_end_processed_p)
6460 overlay_strings_follow_p = 0;
6461 else
6463 it->overlay_strings_at_end_processed_p = 1;
6464 overlay_strings_follow_p = get_overlay_strings (it, 0);
6467 if (overlay_strings_follow_p)
6468 success_p = get_next_display_element (it);
6469 else
6471 it->what = IT_EOB;
6472 it->position = it->current.pos;
6473 success_p = 0;
6476 else
6478 handle_stop (it);
6479 return get_next_display_element (it);
6482 else
6484 /* No face changes, overlays etc. in sight, so just return a
6485 character from current_buffer. */
6486 unsigned char *p;
6488 /* Maybe run the redisplay end trigger hook. Performance note:
6489 This doesn't seem to cost measurable time. */
6490 if (it->redisplay_end_trigger_charpos
6491 && it->glyph_row
6492 && IT_CHARPOS (*it) >= it->redisplay_end_trigger_charpos)
6493 run_redisplay_end_trigger_hook (it);
6495 /* Get the next character, maybe multibyte. */
6496 p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
6497 if (it->multibyte_p && !ASCII_BYTE_P (*p))
6499 int maxlen = ((IT_BYTEPOS (*it) >= GPT_BYTE ? ZV_BYTE : GPT_BYTE)
6500 - IT_BYTEPOS (*it));
6501 it->c = string_char_and_length (p, maxlen, &it->len);
6503 else
6504 it->c = *p, it->len = 1;
6506 /* Record what we have and where it came from. */
6507 it->what = IT_CHARACTER;
6508 it->object = it->w->buffer;
6509 it->position = it->current.pos;
6511 /* Normally we return the character found above, except when we
6512 really want to return an ellipsis for selective display. */
6513 if (it->selective)
6515 if (it->c == '\n')
6517 /* A value of selective > 0 means hide lines indented more
6518 than that number of columns. */
6519 if (it->selective > 0
6520 && IT_CHARPOS (*it) + 1 < ZV
6521 && indented_beyond_p (IT_CHARPOS (*it) + 1,
6522 IT_BYTEPOS (*it) + 1,
6523 (double) it->selective)) /* iftc */
6525 success_p = next_element_from_ellipsis (it);
6526 it->dpvec_char_len = -1;
6529 else if (it->c == '\r' && it->selective == -1)
6531 /* A value of selective == -1 means that everything from the
6532 CR to the end of the line is invisible, with maybe an
6533 ellipsis displayed for it. */
6534 success_p = next_element_from_ellipsis (it);
6535 it->dpvec_char_len = -1;
6540 /* Value is zero if end of buffer reached. */
6541 xassert (!success_p || it->what != IT_CHARACTER || it->len > 0);
6542 return success_p;
6546 /* Run the redisplay end trigger hook for IT. */
6548 static void
6549 run_redisplay_end_trigger_hook (it)
6550 struct it *it;
6552 Lisp_Object args[3];
6554 /* IT->glyph_row should be non-null, i.e. we should be actually
6555 displaying something, or otherwise we should not run the hook. */
6556 xassert (it->glyph_row);
6558 /* Set up hook arguments. */
6559 args[0] = Qredisplay_end_trigger_functions;
6560 args[1] = it->window;
6561 XSETINT (args[2], it->redisplay_end_trigger_charpos);
6562 it->redisplay_end_trigger_charpos = 0;
6564 /* Since we are *trying* to run these functions, don't try to run
6565 them again, even if they get an error. */
6566 it->w->redisplay_end_trigger = Qnil;
6567 Frun_hook_with_args (3, args);
6569 /* Notice if it changed the face of the character we are on. */
6570 handle_face_prop (it);
6574 /* Deliver a composition display element. The iterator IT is already
6575 filled with composition information (done in
6576 handle_composition_prop). Value is always 1. */
6578 static int
6579 next_element_from_composition (it)
6580 struct it *it;
6582 it->what = IT_COMPOSITION;
6583 it->position = (STRINGP (it->string)
6584 ? it->current.string_pos
6585 : it->current.pos);
6586 if (STRINGP (it->string))
6587 it->object = it->string;
6588 else
6589 it->object = it->w->buffer;
6590 return 1;
6595 /***********************************************************************
6596 Moving an iterator without producing glyphs
6597 ***********************************************************************/
6599 /* Check if iterator is at a position corresponding to a valid buffer
6600 position after some move_it_ call. */
6602 #define IT_POS_VALID_AFTER_MOVE_P(it) \
6603 ((it)->method == GET_FROM_STRING \
6604 ? IT_STRING_CHARPOS (*it) == 0 \
6605 : 1)
6608 /* Move iterator IT to a specified buffer or X position within one
6609 line on the display without producing glyphs.
6611 OP should be a bit mask including some or all of these bits:
6612 MOVE_TO_X: Stop on reaching x-position TO_X.
6613 MOVE_TO_POS: Stop on reaching buffer or string position TO_CHARPOS.
6614 Regardless of OP's value, stop in reaching the end of the display line.
6616 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
6617 This means, in particular, that TO_X includes window's horizontal
6618 scroll amount.
6620 The return value has several possible values that
6621 say what condition caused the scan to stop:
6623 MOVE_POS_MATCH_OR_ZV
6624 - when TO_POS or ZV was reached.
6626 MOVE_X_REACHED
6627 -when TO_X was reached before TO_POS or ZV were reached.
6629 MOVE_LINE_CONTINUED
6630 - when we reached the end of the display area and the line must
6631 be continued.
6633 MOVE_LINE_TRUNCATED
6634 - when we reached the end of the display area and the line is
6635 truncated.
6637 MOVE_NEWLINE_OR_CR
6638 - when we stopped at a line end, i.e. a newline or a CR and selective
6639 display is on. */
6641 static enum move_it_result
6642 move_it_in_display_line_to (it, to_charpos, to_x, op)
6643 struct it *it;
6644 int to_charpos, to_x, op;
6646 enum move_it_result result = MOVE_UNDEFINED;
6647 struct glyph_row *saved_glyph_row;
6649 /* Don't produce glyphs in produce_glyphs. */
6650 saved_glyph_row = it->glyph_row;
6651 it->glyph_row = NULL;
6653 #define BUFFER_POS_REACHED_P() \
6654 ((op & MOVE_TO_POS) != 0 \
6655 && BUFFERP (it->object) \
6656 && IT_CHARPOS (*it) >= to_charpos \
6657 && (it->method == GET_FROM_BUFFER \
6658 || (it->method == GET_FROM_DISPLAY_VECTOR \
6659 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
6662 while (1)
6664 int x, i, ascent = 0, descent = 0;
6666 /* Stop if we move beyond TO_CHARPOS (after an image or stretch glyph). */
6667 if ((op & MOVE_TO_POS) != 0
6668 && BUFFERP (it->object)
6669 && it->method == GET_FROM_BUFFER
6670 && IT_CHARPOS (*it) > to_charpos)
6672 result = MOVE_POS_MATCH_OR_ZV;
6673 break;
6676 /* Stop when ZV reached.
6677 We used to stop here when TO_CHARPOS reached as well, but that is
6678 too soon if this glyph does not fit on this line. So we handle it
6679 explicitly below. */
6680 if (!get_next_display_element (it)
6681 || (it->truncate_lines_p
6682 && BUFFER_POS_REACHED_P ()))
6684 result = MOVE_POS_MATCH_OR_ZV;
6685 break;
6688 /* The call to produce_glyphs will get the metrics of the
6689 display element IT is loaded with. We record in x the
6690 x-position before this display element in case it does not
6691 fit on the line. */
6692 x = it->current_x;
6694 /* Remember the line height so far in case the next element doesn't
6695 fit on the line. */
6696 if (!it->truncate_lines_p)
6698 ascent = it->max_ascent;
6699 descent = it->max_descent;
6702 PRODUCE_GLYPHS (it);
6704 if (it->area != TEXT_AREA)
6706 set_iterator_to_next (it, 1);
6707 continue;
6710 /* The number of glyphs we get back in IT->nglyphs will normally
6711 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
6712 character on a terminal frame, or (iii) a line end. For the
6713 second case, IT->nglyphs - 1 padding glyphs will be present
6714 (on X frames, there is only one glyph produced for a
6715 composite character.
6717 The behavior implemented below means, for continuation lines,
6718 that as many spaces of a TAB as fit on the current line are
6719 displayed there. For terminal frames, as many glyphs of a
6720 multi-glyph character are displayed in the current line, too.
6721 This is what the old redisplay code did, and we keep it that
6722 way. Under X, the whole shape of a complex character must
6723 fit on the line or it will be completely displayed in the
6724 next line.
6726 Note that both for tabs and padding glyphs, all glyphs have
6727 the same width. */
6728 if (it->nglyphs)
6730 /* More than one glyph or glyph doesn't fit on line. All
6731 glyphs have the same width. */
6732 int single_glyph_width = it->pixel_width / it->nglyphs;
6733 int new_x;
6734 int x_before_this_char = x;
6735 int hpos_before_this_char = it->hpos;
6737 for (i = 0; i < it->nglyphs; ++i, x = new_x)
6739 new_x = x + single_glyph_width;
6741 /* We want to leave anything reaching TO_X to the caller. */
6742 if ((op & MOVE_TO_X) && new_x > to_x)
6744 if (BUFFER_POS_REACHED_P ())
6745 goto buffer_pos_reached;
6746 it->current_x = x;
6747 result = MOVE_X_REACHED;
6748 break;
6750 else if (/* Lines are continued. */
6751 !it->truncate_lines_p
6752 && (/* And glyph doesn't fit on the line. */
6753 new_x > it->last_visible_x
6754 /* Or it fits exactly and we're on a window
6755 system frame. */
6756 || (new_x == it->last_visible_x
6757 && FRAME_WINDOW_P (it->f))))
6759 if (/* IT->hpos == 0 means the very first glyph
6760 doesn't fit on the line, e.g. a wide image. */
6761 it->hpos == 0
6762 || (new_x == it->last_visible_x
6763 && FRAME_WINDOW_P (it->f)))
6765 ++it->hpos;
6766 it->current_x = new_x;
6768 /* The character's last glyph just barely fits
6769 in this row. */
6770 if (i == it->nglyphs - 1)
6772 /* If this is the destination position,
6773 return a position *before* it in this row,
6774 now that we know it fits in this row. */
6775 if (BUFFER_POS_REACHED_P ())
6777 it->hpos = hpos_before_this_char;
6778 it->current_x = x_before_this_char;
6779 result = MOVE_POS_MATCH_OR_ZV;
6780 break;
6783 set_iterator_to_next (it, 1);
6784 #ifdef HAVE_WINDOW_SYSTEM
6785 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
6787 if (!get_next_display_element (it))
6789 result = MOVE_POS_MATCH_OR_ZV;
6790 break;
6792 if (BUFFER_POS_REACHED_P ())
6794 if (ITERATOR_AT_END_OF_LINE_P (it))
6795 result = MOVE_POS_MATCH_OR_ZV;
6796 else
6797 result = MOVE_LINE_CONTINUED;
6798 break;
6800 if (ITERATOR_AT_END_OF_LINE_P (it))
6802 result = MOVE_NEWLINE_OR_CR;
6803 break;
6806 #endif /* HAVE_WINDOW_SYSTEM */
6809 else
6811 it->current_x = x;
6812 it->max_ascent = ascent;
6813 it->max_descent = descent;
6816 TRACE_MOVE ((stderr, "move_it_in: continued at %d\n",
6817 IT_CHARPOS (*it)));
6818 result = MOVE_LINE_CONTINUED;
6819 break;
6821 else if (BUFFER_POS_REACHED_P ())
6822 goto buffer_pos_reached;
6823 else if (new_x > it->first_visible_x)
6825 /* Glyph is visible. Increment number of glyphs that
6826 would be displayed. */
6827 ++it->hpos;
6829 else
6831 /* Glyph is completely off the left margin of the display
6832 area. Nothing to do. */
6836 if (result != MOVE_UNDEFINED)
6837 break;
6839 else if (BUFFER_POS_REACHED_P ())
6841 buffer_pos_reached:
6842 it->current_x = x;
6843 it->max_ascent = ascent;
6844 it->max_descent = descent;
6845 result = MOVE_POS_MATCH_OR_ZV;
6846 break;
6848 else if ((op & MOVE_TO_X) && it->current_x >= to_x)
6850 /* Stop when TO_X specified and reached. This check is
6851 necessary here because of lines consisting of a line end,
6852 only. The line end will not produce any glyphs and we
6853 would never get MOVE_X_REACHED. */
6854 xassert (it->nglyphs == 0);
6855 result = MOVE_X_REACHED;
6856 break;
6859 /* Is this a line end? If yes, we're done. */
6860 if (ITERATOR_AT_END_OF_LINE_P (it))
6862 result = MOVE_NEWLINE_OR_CR;
6863 break;
6866 /* The current display element has been consumed. Advance
6867 to the next. */
6868 set_iterator_to_next (it, 1);
6870 /* Stop if lines are truncated and IT's current x-position is
6871 past the right edge of the window now. */
6872 if (it->truncate_lines_p
6873 && it->current_x >= it->last_visible_x)
6875 #ifdef HAVE_WINDOW_SYSTEM
6876 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
6878 if (!get_next_display_element (it)
6879 || BUFFER_POS_REACHED_P ())
6881 result = MOVE_POS_MATCH_OR_ZV;
6882 break;
6884 if (ITERATOR_AT_END_OF_LINE_P (it))
6886 result = MOVE_NEWLINE_OR_CR;
6887 break;
6890 #endif /* HAVE_WINDOW_SYSTEM */
6891 result = MOVE_LINE_TRUNCATED;
6892 break;
6896 #undef BUFFER_POS_REACHED_P
6898 /* Restore the iterator settings altered at the beginning of this
6899 function. */
6900 it->glyph_row = saved_glyph_row;
6901 return result;
6905 /* Move IT forward until it satisfies one or more of the criteria in
6906 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
6908 OP is a bit-mask that specifies where to stop, and in particular,
6909 which of those four position arguments makes a difference. See the
6910 description of enum move_operation_enum.
6912 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
6913 screen line, this function will set IT to the next position >
6914 TO_CHARPOS. */
6916 void
6917 move_it_to (it, to_charpos, to_x, to_y, to_vpos, op)
6918 struct it *it;
6919 int to_charpos, to_x, to_y, to_vpos;
6920 int op;
6922 enum move_it_result skip, skip2 = MOVE_X_REACHED;
6923 int line_height;
6924 int reached = 0;
6926 for (;;)
6928 if (op & MOVE_TO_VPOS)
6930 /* If no TO_CHARPOS and no TO_X specified, stop at the
6931 start of the line TO_VPOS. */
6932 if ((op & (MOVE_TO_X | MOVE_TO_POS)) == 0)
6934 if (it->vpos == to_vpos)
6936 reached = 1;
6937 break;
6939 else
6940 skip = move_it_in_display_line_to (it, -1, -1, 0);
6942 else
6944 /* TO_VPOS >= 0 means stop at TO_X in the line at
6945 TO_VPOS, or at TO_POS, whichever comes first. */
6946 if (it->vpos == to_vpos)
6948 reached = 2;
6949 break;
6952 skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
6954 if (skip == MOVE_POS_MATCH_OR_ZV || it->vpos == to_vpos)
6956 reached = 3;
6957 break;
6959 else if (skip == MOVE_X_REACHED && it->vpos != to_vpos)
6961 /* We have reached TO_X but not in the line we want. */
6962 skip = move_it_in_display_line_to (it, to_charpos,
6963 -1, MOVE_TO_POS);
6964 if (skip == MOVE_POS_MATCH_OR_ZV)
6966 reached = 4;
6967 break;
6972 else if (op & MOVE_TO_Y)
6974 struct it it_backup;
6976 /* TO_Y specified means stop at TO_X in the line containing
6977 TO_Y---or at TO_CHARPOS if this is reached first. The
6978 problem is that we can't really tell whether the line
6979 contains TO_Y before we have completely scanned it, and
6980 this may skip past TO_X. What we do is to first scan to
6981 TO_X.
6983 If TO_X is not specified, use a TO_X of zero. The reason
6984 is to make the outcome of this function more predictable.
6985 If we didn't use TO_X == 0, we would stop at the end of
6986 the line which is probably not what a caller would expect
6987 to happen. */
6988 skip = move_it_in_display_line_to (it, to_charpos,
6989 ((op & MOVE_TO_X)
6990 ? to_x : 0),
6991 (MOVE_TO_X
6992 | (op & MOVE_TO_POS)));
6994 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
6995 if (skip == MOVE_POS_MATCH_OR_ZV)
6997 reached = 5;
6998 break;
7001 /* If TO_X was reached, we would like to know whether TO_Y
7002 is in the line. This can only be said if we know the
7003 total line height which requires us to scan the rest of
7004 the line. */
7005 if (skip == MOVE_X_REACHED)
7007 /* Wait! We can conclude that TO_Y is in the line if
7008 the already scanned glyphs make the line tall enough
7009 because further scanning doesn't make it shorter. */
7010 line_height = it->max_ascent + it->max_descent;
7011 if (to_y >= it->current_y
7012 && to_y < it->current_y + line_height)
7014 reached = 6;
7015 break;
7017 it_backup = *it;
7018 TRACE_MOVE ((stderr, "move_it: from %d\n", IT_CHARPOS (*it)));
7019 skip2 = move_it_in_display_line_to (it, to_charpos, -1,
7020 op & MOVE_TO_POS);
7021 TRACE_MOVE ((stderr, "move_it: to %d\n", IT_CHARPOS (*it)));
7024 /* Now, decide whether TO_Y is in this line. */
7025 line_height = it->max_ascent + it->max_descent;
7026 TRACE_MOVE ((stderr, "move_it: line_height = %d\n", line_height));
7028 if (to_y >= it->current_y
7029 && to_y < it->current_y + line_height)
7031 if (skip == MOVE_X_REACHED)
7032 /* If TO_Y is in this line and TO_X was reached above,
7033 we scanned too far. We have to restore IT's settings
7034 to the ones before skipping. */
7035 *it = it_backup;
7036 reached = 6;
7038 else if (skip == MOVE_X_REACHED)
7040 skip = skip2;
7041 if (skip == MOVE_POS_MATCH_OR_ZV)
7042 reached = 7;
7045 if (reached)
7046 break;
7048 else if (BUFFERP (it->object)
7049 && it->method == GET_FROM_BUFFER
7050 && IT_CHARPOS (*it) >= to_charpos)
7051 skip = MOVE_POS_MATCH_OR_ZV;
7052 else
7053 skip = move_it_in_display_line_to (it, to_charpos, -1, MOVE_TO_POS);
7055 switch (skip)
7057 case MOVE_POS_MATCH_OR_ZV:
7058 reached = 8;
7059 goto out;
7061 case MOVE_NEWLINE_OR_CR:
7062 set_iterator_to_next (it, 1);
7063 it->continuation_lines_width = 0;
7064 break;
7066 case MOVE_LINE_TRUNCATED:
7067 it->continuation_lines_width = 0;
7068 reseat_at_next_visible_line_start (it, 0);
7069 if ((op & MOVE_TO_POS) != 0
7070 && IT_CHARPOS (*it) > to_charpos)
7072 reached = 9;
7073 goto out;
7075 break;
7077 case MOVE_LINE_CONTINUED:
7078 /* For continued lines ending in a tab, some of the glyphs
7079 associated with the tab are displayed on the current
7080 line. Since it->current_x does not include these glyphs,
7081 we use it->last_visible_x instead. */
7082 it->continuation_lines_width +=
7083 (it->c == '\t') ? it->last_visible_x : it->current_x;
7084 break;
7086 default:
7087 abort ();
7090 /* Reset/increment for the next run. */
7091 recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
7092 it->current_x = it->hpos = 0;
7093 it->current_y += it->max_ascent + it->max_descent;
7094 ++it->vpos;
7095 last_height = it->max_ascent + it->max_descent;
7096 last_max_ascent = it->max_ascent;
7097 it->max_ascent = it->max_descent = 0;
7100 out:
7102 TRACE_MOVE ((stderr, "move_it_to: reached %d\n", reached));
7106 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
7108 If DY > 0, move IT backward at least that many pixels. DY = 0
7109 means move IT backward to the preceding line start or BEGV. This
7110 function may move over more than DY pixels if IT->current_y - DY
7111 ends up in the middle of a line; in this case IT->current_y will be
7112 set to the top of the line moved to. */
7114 void
7115 move_it_vertically_backward (it, dy)
7116 struct it *it;
7117 int dy;
7119 int nlines, h;
7120 struct it it2, it3;
7121 int start_pos;
7123 move_further_back:
7124 xassert (dy >= 0);
7126 start_pos = IT_CHARPOS (*it);
7128 /* Estimate how many newlines we must move back. */
7129 nlines = max (1, dy / FRAME_LINE_HEIGHT (it->f));
7131 /* Set the iterator's position that many lines back. */
7132 while (nlines-- && IT_CHARPOS (*it) > BEGV)
7133 back_to_previous_visible_line_start (it);
7135 /* Reseat the iterator here. When moving backward, we don't want
7136 reseat to skip forward over invisible text, set up the iterator
7137 to deliver from overlay strings at the new position etc. So,
7138 use reseat_1 here. */
7139 reseat_1 (it, it->current.pos, 1);
7141 /* We are now surely at a line start. */
7142 it->current_x = it->hpos = 0;
7143 it->continuation_lines_width = 0;
7145 /* Move forward and see what y-distance we moved. First move to the
7146 start of the next line so that we get its height. We need this
7147 height to be able to tell whether we reached the specified
7148 y-distance. */
7149 it2 = *it;
7150 it2.max_ascent = it2.max_descent = 0;
7153 move_it_to (&it2, start_pos, -1, -1, it2.vpos + 1,
7154 MOVE_TO_POS | MOVE_TO_VPOS);
7156 while (!IT_POS_VALID_AFTER_MOVE_P (&it2));
7157 xassert (IT_CHARPOS (*it) >= BEGV);
7158 it3 = it2;
7160 move_it_to (&it2, start_pos, -1, -1, -1, MOVE_TO_POS);
7161 xassert (IT_CHARPOS (*it) >= BEGV);
7162 /* H is the actual vertical distance from the position in *IT
7163 and the starting position. */
7164 h = it2.current_y - it->current_y;
7165 /* NLINES is the distance in number of lines. */
7166 nlines = it2.vpos - it->vpos;
7168 /* Correct IT's y and vpos position
7169 so that they are relative to the starting point. */
7170 it->vpos -= nlines;
7171 it->current_y -= h;
7173 if (dy == 0)
7175 /* DY == 0 means move to the start of the screen line. The
7176 value of nlines is > 0 if continuation lines were involved. */
7177 if (nlines > 0)
7178 move_it_by_lines (it, nlines, 1);
7179 #if 0
7180 /* I think this assert is bogus if buffer contains
7181 invisible text or images. KFS. */
7182 xassert (IT_CHARPOS (*it) <= start_pos);
7183 #endif
7185 else
7187 /* The y-position we try to reach, relative to *IT.
7188 Note that H has been subtracted in front of the if-statement. */
7189 int target_y = it->current_y + h - dy;
7190 int y0 = it3.current_y;
7191 int y1 = line_bottom_y (&it3);
7192 int line_height = y1 - y0;
7194 /* If we did not reach target_y, try to move further backward if
7195 we can. If we moved too far backward, try to move forward. */
7196 if (target_y < it->current_y
7197 /* This is heuristic. In a window that's 3 lines high, with
7198 a line height of 13 pixels each, recentering with point
7199 on the bottom line will try to move -39/2 = 19 pixels
7200 backward. Try to avoid moving into the first line. */
7201 && (it->current_y - target_y
7202 > min (window_box_height (it->w), line_height * 2 / 3))
7203 && IT_CHARPOS (*it) > BEGV)
7205 TRACE_MOVE ((stderr, " not far enough -> move_vert %d\n",
7206 target_y - it->current_y));
7207 dy = it->current_y - target_y;
7208 goto move_further_back;
7210 else if (target_y >= it->current_y + line_height
7211 && IT_CHARPOS (*it) < ZV)
7213 /* Should move forward by at least one line, maybe more.
7215 Note: Calling move_it_by_lines can be expensive on
7216 terminal frames, where compute_motion is used (via
7217 vmotion) to do the job, when there are very long lines
7218 and truncate-lines is nil. That's the reason for
7219 treating terminal frames specially here. */
7221 if (!FRAME_WINDOW_P (it->f))
7222 move_it_vertically (it, target_y - (it->current_y + line_height));
7223 else
7227 move_it_by_lines (it, 1, 1);
7229 while (target_y >= line_bottom_y (it) && IT_CHARPOS (*it) < ZV);
7232 #if 0
7233 /* I think this assert is bogus if buffer contains
7234 invisible text or images. KFS. */
7235 xassert (IT_CHARPOS (*it) >= BEGV);
7236 #endif
7242 /* Move IT by a specified amount of pixel lines DY. DY negative means
7243 move backwards. DY = 0 means move to start of screen line. At the
7244 end, IT will be on the start of a screen line. */
7246 void
7247 move_it_vertically (it, dy)
7248 struct it *it;
7249 int dy;
7251 if (dy <= 0)
7252 move_it_vertically_backward (it, -dy);
7253 else
7255 TRACE_MOVE ((stderr, "move_it_v: from %d, %d\n", IT_CHARPOS (*it), dy));
7256 move_it_to (it, ZV, -1, it->current_y + dy, -1,
7257 MOVE_TO_POS | MOVE_TO_Y);
7258 TRACE_MOVE ((stderr, "move_it_v: to %d\n", IT_CHARPOS (*it)));
7260 /* If buffer ends in ZV without a newline, move to the start of
7261 the line to satisfy the post-condition. */
7262 if (IT_CHARPOS (*it) == ZV
7263 && ZV > BEGV
7264 && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
7265 move_it_by_lines (it, 0, 0);
7270 /* Move iterator IT past the end of the text line it is in. */
7272 void
7273 move_it_past_eol (it)
7274 struct it *it;
7276 enum move_it_result rc;
7278 rc = move_it_in_display_line_to (it, Z, 0, MOVE_TO_POS);
7279 if (rc == MOVE_NEWLINE_OR_CR)
7280 set_iterator_to_next (it, 0);
7284 #if 0 /* Currently not used. */
7286 /* Return non-zero if some text between buffer positions START_CHARPOS
7287 and END_CHARPOS is invisible. IT->window is the window for text
7288 property lookup. */
7290 static int
7291 invisible_text_between_p (it, start_charpos, end_charpos)
7292 struct it *it;
7293 int start_charpos, end_charpos;
7295 Lisp_Object prop, limit;
7296 int invisible_found_p;
7298 xassert (it != NULL && start_charpos <= end_charpos);
7300 /* Is text at START invisible? */
7301 prop = Fget_char_property (make_number (start_charpos), Qinvisible,
7302 it->window);
7303 if (TEXT_PROP_MEANS_INVISIBLE (prop))
7304 invisible_found_p = 1;
7305 else
7307 limit = Fnext_single_char_property_change (make_number (start_charpos),
7308 Qinvisible, Qnil,
7309 make_number (end_charpos));
7310 invisible_found_p = XFASTINT (limit) < end_charpos;
7313 return invisible_found_p;
7316 #endif /* 0 */
7319 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
7320 negative means move up. DVPOS == 0 means move to the start of the
7321 screen line. NEED_Y_P non-zero means calculate IT->current_y. If
7322 NEED_Y_P is zero, IT->current_y will be left unchanged.
7324 Further optimization ideas: If we would know that IT->f doesn't use
7325 a face with proportional font, we could be faster for
7326 truncate-lines nil. */
7328 void
7329 move_it_by_lines (it, dvpos, need_y_p)
7330 struct it *it;
7331 int dvpos, need_y_p;
7333 struct position pos;
7335 /* The commented-out optimization uses vmotion on terminals. This
7336 gives bad results, because elements like it->what, on which
7337 callers such as pos_visible_p rely, aren't updated. */
7338 /* if (!FRAME_WINDOW_P (it->f))
7340 struct text_pos textpos;
7342 pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
7343 SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
7344 reseat (it, textpos, 1);
7345 it->vpos += pos.vpos;
7346 it->current_y += pos.vpos;
7348 else */
7350 if (dvpos == 0)
7352 /* DVPOS == 0 means move to the start of the screen line. */
7353 move_it_vertically_backward (it, 0);
7354 xassert (it->current_x == 0 && it->hpos == 0);
7355 /* Let next call to line_bottom_y calculate real line height */
7356 last_height = 0;
7358 else if (dvpos > 0)
7360 move_it_to (it, -1, -1, -1, it->vpos + dvpos, MOVE_TO_VPOS);
7361 if (!IT_POS_VALID_AFTER_MOVE_P (it))
7362 move_it_to (it, IT_CHARPOS (*it) + 1, -1, -1, -1, MOVE_TO_POS);
7364 else
7366 struct it it2;
7367 int start_charpos, i;
7369 /* Start at the beginning of the screen line containing IT's
7370 position. This may actually move vertically backwards,
7371 in case of overlays, so adjust dvpos accordingly. */
7372 dvpos += it->vpos;
7373 move_it_vertically_backward (it, 0);
7374 dvpos -= it->vpos;
7376 /* Go back -DVPOS visible lines and reseat the iterator there. */
7377 start_charpos = IT_CHARPOS (*it);
7378 for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > BEGV; --i)
7379 back_to_previous_visible_line_start (it);
7380 reseat (it, it->current.pos, 1);
7382 /* Move further back if we end up in a string or an image. */
7383 while (!IT_POS_VALID_AFTER_MOVE_P (it))
7385 /* First try to move to start of display line. */
7386 dvpos += it->vpos;
7387 move_it_vertically_backward (it, 0);
7388 dvpos -= it->vpos;
7389 if (IT_POS_VALID_AFTER_MOVE_P (it))
7390 break;
7391 /* If start of line is still in string or image,
7392 move further back. */
7393 back_to_previous_visible_line_start (it);
7394 reseat (it, it->current.pos, 1);
7395 dvpos--;
7398 it->current_x = it->hpos = 0;
7400 /* Above call may have moved too far if continuation lines
7401 are involved. Scan forward and see if it did. */
7402 it2 = *it;
7403 it2.vpos = it2.current_y = 0;
7404 move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
7405 it->vpos -= it2.vpos;
7406 it->current_y -= it2.current_y;
7407 it->current_x = it->hpos = 0;
7409 /* If we moved too far back, move IT some lines forward. */
7410 if (it2.vpos > -dvpos)
7412 int delta = it2.vpos + dvpos;
7413 it2 = *it;
7414 move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
7415 /* Move back again if we got too far ahead. */
7416 if (IT_CHARPOS (*it) >= start_charpos)
7417 *it = it2;
7422 /* Return 1 if IT points into the middle of a display vector. */
7425 in_display_vector_p (it)
7426 struct it *it;
7428 return (it->method == GET_FROM_DISPLAY_VECTOR
7429 && it->current.dpvec_index > 0
7430 && it->dpvec + it->current.dpvec_index != it->dpend);
7434 /***********************************************************************
7435 Messages
7436 ***********************************************************************/
7439 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
7440 to *Messages*. */
7442 void
7443 add_to_log (format, arg1, arg2)
7444 char *format;
7445 Lisp_Object arg1, arg2;
7447 Lisp_Object args[3];
7448 Lisp_Object msg, fmt;
7449 char *buffer;
7450 int len;
7451 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
7452 USE_SAFE_ALLOCA;
7454 /* Do nothing if called asynchronously. Inserting text into
7455 a buffer may call after-change-functions and alike and
7456 that would means running Lisp asynchronously. */
7457 if (handling_signal)
7458 return;
7460 fmt = msg = Qnil;
7461 GCPRO4 (fmt, msg, arg1, arg2);
7463 args[0] = fmt = build_string (format);
7464 args[1] = arg1;
7465 args[2] = arg2;
7466 msg = Fformat (3, args);
7468 len = SBYTES (msg) + 1;
7469 SAFE_ALLOCA (buffer, char *, len);
7470 bcopy (SDATA (msg), buffer, len);
7472 message_dolog (buffer, len - 1, 1, 0);
7473 SAFE_FREE ();
7475 UNGCPRO;
7479 /* Output a newline in the *Messages* buffer if "needs" one. */
7481 void
7482 message_log_maybe_newline ()
7484 if (message_log_need_newline)
7485 message_dolog ("", 0, 1, 0);
7489 /* Add a string M of length NBYTES to the message log, optionally
7490 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
7491 nonzero, means interpret the contents of M as multibyte. This
7492 function calls low-level routines in order to bypass text property
7493 hooks, etc. which might not be safe to run.
7495 This may GC (insert may run before/after change hooks),
7496 so the buffer M must NOT point to a Lisp string. */
7498 void
7499 message_dolog (m, nbytes, nlflag, multibyte)
7500 const char *m;
7501 int nbytes, nlflag, multibyte;
7503 if (!NILP (Vmemory_full))
7504 return;
7506 if (!NILP (Vmessage_log_max))
7508 struct buffer *oldbuf;
7509 Lisp_Object oldpoint, oldbegv, oldzv;
7510 int old_windows_or_buffers_changed = windows_or_buffers_changed;
7511 int point_at_end = 0;
7512 int zv_at_end = 0;
7513 Lisp_Object old_deactivate_mark, tem;
7514 struct gcpro gcpro1;
7516 old_deactivate_mark = Vdeactivate_mark;
7517 oldbuf = current_buffer;
7518 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name));
7519 current_buffer->undo_list = Qt;
7521 oldpoint = message_dolog_marker1;
7522 set_marker_restricted (oldpoint, make_number (PT), Qnil);
7523 oldbegv = message_dolog_marker2;
7524 set_marker_restricted (oldbegv, make_number (BEGV), Qnil);
7525 oldzv = message_dolog_marker3;
7526 set_marker_restricted (oldzv, make_number (ZV), Qnil);
7527 GCPRO1 (old_deactivate_mark);
7529 if (PT == Z)
7530 point_at_end = 1;
7531 if (ZV == Z)
7532 zv_at_end = 1;
7534 BEGV = BEG;
7535 BEGV_BYTE = BEG_BYTE;
7536 ZV = Z;
7537 ZV_BYTE = Z_BYTE;
7538 TEMP_SET_PT_BOTH (Z, Z_BYTE);
7540 /* Insert the string--maybe converting multibyte to single byte
7541 or vice versa, so that all the text fits the buffer. */
7542 if (multibyte
7543 && NILP (current_buffer->enable_multibyte_characters))
7545 int i, c, char_bytes;
7546 unsigned char work[1];
7548 /* Convert a multibyte string to single-byte
7549 for the *Message* buffer. */
7550 for (i = 0; i < nbytes; i += char_bytes)
7552 c = string_char_and_length (m + i, nbytes - i, &char_bytes);
7553 work[0] = (ASCII_CHAR_P (c)
7555 : multibyte_char_to_unibyte (c, Qnil));
7556 insert_1_both (work, 1, 1, 1, 0, 0);
7559 else if (! multibyte
7560 && ! NILP (current_buffer->enable_multibyte_characters))
7562 int i, c, char_bytes;
7563 unsigned char *msg = (unsigned char *) m;
7564 unsigned char str[MAX_MULTIBYTE_LENGTH];
7565 /* Convert a single-byte string to multibyte
7566 for the *Message* buffer. */
7567 for (i = 0; i < nbytes; i++)
7569 c = msg[i];
7570 c = unibyte_char_to_multibyte (c);
7571 char_bytes = CHAR_STRING (c, str);
7572 insert_1_both (str, 1, char_bytes, 1, 0, 0);
7575 else if (nbytes)
7576 insert_1 (m, nbytes, 1, 0, 0);
7578 if (nlflag)
7580 int this_bol, this_bol_byte, prev_bol, prev_bol_byte, dup;
7581 insert_1 ("\n", 1, 1, 0, 0);
7583 scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, 0);
7584 this_bol = PT;
7585 this_bol_byte = PT_BYTE;
7587 /* See if this line duplicates the previous one.
7588 If so, combine duplicates. */
7589 if (this_bol > BEG)
7591 scan_newline (PT, PT_BYTE, BEG, BEG_BYTE, -2, 0);
7592 prev_bol = PT;
7593 prev_bol_byte = PT_BYTE;
7595 dup = message_log_check_duplicate (prev_bol, prev_bol_byte,
7596 this_bol, this_bol_byte);
7597 if (dup)
7599 del_range_both (prev_bol, prev_bol_byte,
7600 this_bol, this_bol_byte, 0);
7601 if (dup > 1)
7603 char dupstr[40];
7604 int duplen;
7606 /* If you change this format, don't forget to also
7607 change message_log_check_duplicate. */
7608 sprintf (dupstr, " [%d times]", dup);
7609 duplen = strlen (dupstr);
7610 TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
7611 insert_1 (dupstr, duplen, 1, 0, 1);
7616 /* If we have more than the desired maximum number of lines
7617 in the *Messages* buffer now, delete the oldest ones.
7618 This is safe because we don't have undo in this buffer. */
7620 if (NATNUMP (Vmessage_log_max))
7622 scan_newline (Z, Z_BYTE, BEG, BEG_BYTE,
7623 -XFASTINT (Vmessage_log_max) - 1, 0);
7624 del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, 0);
7627 BEGV = XMARKER (oldbegv)->charpos;
7628 BEGV_BYTE = marker_byte_position (oldbegv);
7630 if (zv_at_end)
7632 ZV = Z;
7633 ZV_BYTE = Z_BYTE;
7635 else
7637 ZV = XMARKER (oldzv)->charpos;
7638 ZV_BYTE = marker_byte_position (oldzv);
7641 if (point_at_end)
7642 TEMP_SET_PT_BOTH (Z, Z_BYTE);
7643 else
7644 /* We can't do Fgoto_char (oldpoint) because it will run some
7645 Lisp code. */
7646 TEMP_SET_PT_BOTH (XMARKER (oldpoint)->charpos,
7647 XMARKER (oldpoint)->bytepos);
7649 UNGCPRO;
7650 unchain_marker (XMARKER (oldpoint));
7651 unchain_marker (XMARKER (oldbegv));
7652 unchain_marker (XMARKER (oldzv));
7654 tem = Fget_buffer_window (Fcurrent_buffer (), Qt);
7655 set_buffer_internal (oldbuf);
7656 if (NILP (tem))
7657 windows_or_buffers_changed = old_windows_or_buffers_changed;
7658 message_log_need_newline = !nlflag;
7659 Vdeactivate_mark = old_deactivate_mark;
7664 /* We are at the end of the buffer after just having inserted a newline.
7665 (Note: We depend on the fact we won't be crossing the gap.)
7666 Check to see if the most recent message looks a lot like the previous one.
7667 Return 0 if different, 1 if the new one should just replace it, or a
7668 value N > 1 if we should also append " [N times]". */
7670 static int
7671 message_log_check_duplicate (prev_bol, prev_bol_byte, this_bol, this_bol_byte)
7672 int prev_bol, this_bol;
7673 int prev_bol_byte, this_bol_byte;
7675 int i;
7676 int len = Z_BYTE - 1 - this_bol_byte;
7677 int seen_dots = 0;
7678 unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte);
7679 unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte);
7681 for (i = 0; i < len; i++)
7683 if (i >= 3 && p1[i-3] == '.' && p1[i-2] == '.' && p1[i-1] == '.')
7684 seen_dots = 1;
7685 if (p1[i] != p2[i])
7686 return seen_dots;
7688 p1 += len;
7689 if (*p1 == '\n')
7690 return 2;
7691 if (*p1++ == ' ' && *p1++ == '[')
7693 int n = 0;
7694 while (*p1 >= '0' && *p1 <= '9')
7695 n = n * 10 + *p1++ - '0';
7696 if (strncmp (p1, " times]\n", 8) == 0)
7697 return n+1;
7699 return 0;
7703 /* Display an echo area message M with a specified length of NBYTES
7704 bytes. The string may include null characters. If M is 0, clear
7705 out any existing message, and let the mini-buffer text show
7706 through.
7708 This may GC, so the buffer M must NOT point to a Lisp string. */
7710 void
7711 message2 (m, nbytes, multibyte)
7712 const char *m;
7713 int nbytes;
7714 int multibyte;
7716 /* First flush out any partial line written with print. */
7717 message_log_maybe_newline ();
7718 if (m)
7719 message_dolog (m, nbytes, 1, multibyte);
7720 message2_nolog (m, nbytes, multibyte);
7724 /* The non-logging counterpart of message2. */
7726 void
7727 message2_nolog (m, nbytes, multibyte)
7728 const char *m;
7729 int nbytes, multibyte;
7731 struct frame *sf = SELECTED_FRAME ();
7732 message_enable_multibyte = multibyte;
7734 if (noninteractive)
7736 if (noninteractive_need_newline)
7737 putc ('\n', stderr);
7738 noninteractive_need_newline = 0;
7739 if (m)
7740 fwrite (m, nbytes, 1, stderr);
7741 if (cursor_in_echo_area == 0)
7742 fprintf (stderr, "\n");
7743 fflush (stderr);
7745 /* A null message buffer means that the frame hasn't really been
7746 initialized yet. Error messages get reported properly by
7747 cmd_error, so this must be just an informative message; toss it. */
7748 else if (INTERACTIVE
7749 && sf->glyphs_initialized_p
7750 && FRAME_MESSAGE_BUF (sf))
7752 Lisp_Object mini_window;
7753 struct frame *f;
7755 /* Get the frame containing the mini-buffer
7756 that the selected frame is using. */
7757 mini_window = FRAME_MINIBUF_WINDOW (sf);
7758 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
7760 FRAME_SAMPLE_VISIBILITY (f);
7761 if (FRAME_VISIBLE_P (sf)
7762 && ! FRAME_VISIBLE_P (f))
7763 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window)));
7765 if (m)
7767 set_message (m, Qnil, nbytes, multibyte);
7768 if (minibuffer_auto_raise)
7769 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
7771 else
7772 clear_message (1, 1);
7774 do_pending_window_change (0);
7775 echo_area_display (1);
7776 do_pending_window_change (0);
7777 if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
7778 (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
7783 /* Display an echo area message M with a specified length of NBYTES
7784 bytes. The string may include null characters. If M is not a
7785 string, clear out any existing message, and let the mini-buffer
7786 text show through.
7788 This function cancels echoing. */
7790 void
7791 message3 (m, nbytes, multibyte)
7792 Lisp_Object m;
7793 int nbytes;
7794 int multibyte;
7796 struct gcpro gcpro1;
7798 GCPRO1 (m);
7799 clear_message (1,1);
7800 cancel_echoing ();
7802 /* First flush out any partial line written with print. */
7803 message_log_maybe_newline ();
7804 if (STRINGP (m))
7806 char *buffer;
7807 USE_SAFE_ALLOCA;
7809 SAFE_ALLOCA (buffer, char *, nbytes);
7810 bcopy (SDATA (m), buffer, nbytes);
7811 message_dolog (buffer, nbytes, 1, multibyte);
7812 SAFE_FREE ();
7814 message3_nolog (m, nbytes, multibyte);
7816 UNGCPRO;
7820 /* The non-logging version of message3.
7821 This does not cancel echoing, because it is used for echoing.
7822 Perhaps we need to make a separate function for echoing
7823 and make this cancel echoing. */
7825 void
7826 message3_nolog (m, nbytes, multibyte)
7827 Lisp_Object m;
7828 int nbytes, multibyte;
7830 struct frame *sf = SELECTED_FRAME ();
7831 message_enable_multibyte = multibyte;
7833 if (noninteractive)
7835 if (noninteractive_need_newline)
7836 putc ('\n', stderr);
7837 noninteractive_need_newline = 0;
7838 if (STRINGP (m))
7839 fwrite (SDATA (m), nbytes, 1, stderr);
7840 if (cursor_in_echo_area == 0)
7841 fprintf (stderr, "\n");
7842 fflush (stderr);
7844 /* A null message buffer means that the frame hasn't really been
7845 initialized yet. Error messages get reported properly by
7846 cmd_error, so this must be just an informative message; toss it. */
7847 else if (INTERACTIVE
7848 && sf->glyphs_initialized_p
7849 && FRAME_MESSAGE_BUF (sf))
7851 Lisp_Object mini_window;
7852 Lisp_Object frame;
7853 struct frame *f;
7855 /* Get the frame containing the mini-buffer
7856 that the selected frame is using. */
7857 mini_window = FRAME_MINIBUF_WINDOW (sf);
7858 frame = XWINDOW (mini_window)->frame;
7859 f = XFRAME (frame);
7861 FRAME_SAMPLE_VISIBILITY (f);
7862 if (FRAME_VISIBLE_P (sf)
7863 && !FRAME_VISIBLE_P (f))
7864 Fmake_frame_visible (frame);
7866 if (STRINGP (m) && SCHARS (m) > 0)
7868 set_message (NULL, m, nbytes, multibyte);
7869 if (minibuffer_auto_raise)
7870 Fraise_frame (frame);
7871 /* Assume we are not echoing.
7872 (If we are, echo_now will override this.) */
7873 echo_message_buffer = Qnil;
7875 else
7876 clear_message (1, 1);
7878 do_pending_window_change (0);
7879 echo_area_display (1);
7880 do_pending_window_change (0);
7881 if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
7882 (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
7887 /* Display a null-terminated echo area message M. If M is 0, clear
7888 out any existing message, and let the mini-buffer text show through.
7890 The buffer M must continue to exist until after the echo area gets
7891 cleared or some other message gets displayed there. Do not pass
7892 text that is stored in a Lisp string. Do not pass text in a buffer
7893 that was alloca'd. */
7895 void
7896 message1 (m)
7897 char *m;
7899 message2 (m, (m ? strlen (m) : 0), 0);
7903 /* The non-logging counterpart of message1. */
7905 void
7906 message1_nolog (m)
7907 char *m;
7909 message2_nolog (m, (m ? strlen (m) : 0), 0);
7912 /* Display a message M which contains a single %s
7913 which gets replaced with STRING. */
7915 void
7916 message_with_string (m, string, log)
7917 char *m;
7918 Lisp_Object string;
7919 int log;
7921 CHECK_STRING (string);
7923 if (noninteractive)
7925 if (m)
7927 if (noninteractive_need_newline)
7928 putc ('\n', stderr);
7929 noninteractive_need_newline = 0;
7930 fprintf (stderr, m, SDATA (string));
7931 if (cursor_in_echo_area == 0)
7932 fprintf (stderr, "\n");
7933 fflush (stderr);
7936 else if (INTERACTIVE)
7938 /* The frame whose minibuffer we're going to display the message on.
7939 It may be larger than the selected frame, so we need
7940 to use its buffer, not the selected frame's buffer. */
7941 Lisp_Object mini_window;
7942 struct frame *f, *sf = SELECTED_FRAME ();
7944 /* Get the frame containing the minibuffer
7945 that the selected frame is using. */
7946 mini_window = FRAME_MINIBUF_WINDOW (sf);
7947 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
7949 /* A null message buffer means that the frame hasn't really been
7950 initialized yet. Error messages get reported properly by
7951 cmd_error, so this must be just an informative message; toss it. */
7952 if (FRAME_MESSAGE_BUF (f))
7954 Lisp_Object args[2], message;
7955 struct gcpro gcpro1, gcpro2;
7957 args[0] = build_string (m);
7958 args[1] = message = string;
7959 GCPRO2 (args[0], message);
7960 gcpro1.nvars = 2;
7962 message = Fformat (2, args);
7964 if (log)
7965 message3 (message, SBYTES (message), STRING_MULTIBYTE (message));
7966 else
7967 message3_nolog (message, SBYTES (message), STRING_MULTIBYTE (message));
7969 UNGCPRO;
7971 /* Print should start at the beginning of the message
7972 buffer next time. */
7973 message_buf_print = 0;
7979 /* Dump an informative message to the minibuf. If M is 0, clear out
7980 any existing message, and let the mini-buffer text show through. */
7982 /* VARARGS 1 */
7983 void
7984 message (m, a1, a2, a3)
7985 char *m;
7986 EMACS_INT a1, a2, a3;
7988 if (noninteractive)
7990 if (m)
7992 if (noninteractive_need_newline)
7993 putc ('\n', stderr);
7994 noninteractive_need_newline = 0;
7995 fprintf (stderr, m, a1, a2, a3);
7996 if (cursor_in_echo_area == 0)
7997 fprintf (stderr, "\n");
7998 fflush (stderr);
8001 else if (INTERACTIVE)
8003 /* The frame whose mini-buffer we're going to display the message
8004 on. It may be larger than the selected frame, so we need to
8005 use its buffer, not the selected frame's buffer. */
8006 Lisp_Object mini_window;
8007 struct frame *f, *sf = SELECTED_FRAME ();
8009 /* Get the frame containing the mini-buffer
8010 that the selected frame is using. */
8011 mini_window = FRAME_MINIBUF_WINDOW (sf);
8012 f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
8014 /* A null message buffer means that the frame hasn't really been
8015 initialized yet. Error messages get reported properly by
8016 cmd_error, so this must be just an informative message; toss
8017 it. */
8018 if (FRAME_MESSAGE_BUF (f))
8020 if (m)
8022 int len;
8023 #ifdef NO_ARG_ARRAY
8024 char *a[3];
8025 a[0] = (char *) a1;
8026 a[1] = (char *) a2;
8027 a[2] = (char *) a3;
8029 len = doprnt (FRAME_MESSAGE_BUF (f),
8030 FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3, a);
8031 #else
8032 len = doprnt (FRAME_MESSAGE_BUF (f),
8033 FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3,
8034 (char **) &a1);
8035 #endif /* NO_ARG_ARRAY */
8037 message2 (FRAME_MESSAGE_BUF (f), len, 0);
8039 else
8040 message1 (0);
8042 /* Print should start at the beginning of the message
8043 buffer next time. */
8044 message_buf_print = 0;
8050 /* The non-logging version of message. */
8052 void
8053 message_nolog (m, a1, a2, a3)
8054 char *m;
8055 EMACS_INT a1, a2, a3;
8057 Lisp_Object old_log_max;
8058 old_log_max = Vmessage_log_max;
8059 Vmessage_log_max = Qnil;
8060 message (m, a1, a2, a3);
8061 Vmessage_log_max = old_log_max;
8065 /* Display the current message in the current mini-buffer. This is
8066 only called from error handlers in process.c, and is not time
8067 critical. */
8069 void
8070 update_echo_area ()
8072 if (!NILP (echo_area_buffer[0]))
8074 Lisp_Object string;
8075 string = Fcurrent_message ();
8076 message3 (string, SBYTES (string),
8077 !NILP (current_buffer->enable_multibyte_characters));
8082 /* Make sure echo area buffers in `echo_buffers' are live.
8083 If they aren't, make new ones. */
8085 static void
8086 ensure_echo_area_buffers ()
8088 int i;
8090 for (i = 0; i < 2; ++i)
8091 if (!BUFFERP (echo_buffer[i])
8092 || NILP (XBUFFER (echo_buffer[i])->name))
8094 char name[30];
8095 Lisp_Object old_buffer;
8096 int j;
8098 old_buffer = echo_buffer[i];
8099 sprintf (name, " *Echo Area %d*", i);
8100 echo_buffer[i] = Fget_buffer_create (build_string (name));
8101 XBUFFER (echo_buffer[i])->truncate_lines = Qnil;
8103 for (j = 0; j < 2; ++j)
8104 if (EQ (old_buffer, echo_area_buffer[j]))
8105 echo_area_buffer[j] = echo_buffer[i];
8110 /* Call FN with args A1..A4 with either the current or last displayed
8111 echo_area_buffer as current buffer.
8113 WHICH zero means use the current message buffer
8114 echo_area_buffer[0]. If that is nil, choose a suitable buffer
8115 from echo_buffer[] and clear it.
8117 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
8118 suitable buffer from echo_buffer[] and clear it.
8120 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
8121 that the current message becomes the last displayed one, make
8122 choose a suitable buffer for echo_area_buffer[0], and clear it.
8124 Value is what FN returns. */
8126 static int
8127 with_echo_area_buffer (w, which, fn, a1, a2, a3, a4)
8128 struct window *w;
8129 int which;
8130 int (*fn) P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
8131 EMACS_INT a1;
8132 Lisp_Object a2;
8133 EMACS_INT a3, a4;
8135 Lisp_Object buffer;
8136 int this_one, the_other, clear_buffer_p, rc;
8137 int count = SPECPDL_INDEX ();
8139 /* If buffers aren't live, make new ones. */
8140 ensure_echo_area_buffers ();
8142 clear_buffer_p = 0;
8144 if (which == 0)
8145 this_one = 0, the_other = 1;
8146 else if (which > 0)
8147 this_one = 1, the_other = 0;
8148 else
8150 this_one = 0, the_other = 1;
8151 clear_buffer_p = 1;
8153 /* We need a fresh one in case the current echo buffer equals
8154 the one containing the last displayed echo area message. */
8155 if (!NILP (echo_area_buffer[this_one])
8156 && EQ (echo_area_buffer[this_one], echo_area_buffer[the_other]))
8157 echo_area_buffer[this_one] = Qnil;
8160 /* Choose a suitable buffer from echo_buffer[] is we don't
8161 have one. */
8162 if (NILP (echo_area_buffer[this_one]))
8164 echo_area_buffer[this_one]
8165 = (EQ (echo_area_buffer[the_other], echo_buffer[this_one])
8166 ? echo_buffer[the_other]
8167 : echo_buffer[this_one]);
8168 clear_buffer_p = 1;
8171 buffer = echo_area_buffer[this_one];
8173 /* Don't get confused by reusing the buffer used for echoing
8174 for a different purpose. */
8175 if (echo_kboard == NULL && EQ (buffer, echo_message_buffer))
8176 cancel_echoing ();
8178 record_unwind_protect (unwind_with_echo_area_buffer,
8179 with_echo_area_buffer_unwind_data (w));
8181 /* Make the echo area buffer current. Note that for display
8182 purposes, it is not necessary that the displayed window's buffer
8183 == current_buffer, except for text property lookup. So, let's
8184 only set that buffer temporarily here without doing a full
8185 Fset_window_buffer. We must also change w->pointm, though,
8186 because otherwise an assertions in unshow_buffer fails, and Emacs
8187 aborts. */
8188 set_buffer_internal_1 (XBUFFER (buffer));
8189 if (w)
8191 w->buffer = buffer;
8192 set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
8195 current_buffer->undo_list = Qt;
8196 current_buffer->read_only = Qnil;
8197 specbind (Qinhibit_read_only, Qt);
8198 specbind (Qinhibit_modification_hooks, Qt);
8200 if (clear_buffer_p && Z > BEG)
8201 del_range (BEG, Z);
8203 xassert (BEGV >= BEG);
8204 xassert (ZV <= Z && ZV >= BEGV);
8206 rc = fn (a1, a2, a3, a4);
8208 xassert (BEGV >= BEG);
8209 xassert (ZV <= Z && ZV >= BEGV);
8211 unbind_to (count, Qnil);
8212 return rc;
8216 /* Save state that should be preserved around the call to the function
8217 FN called in with_echo_area_buffer. */
8219 static Lisp_Object
8220 with_echo_area_buffer_unwind_data (w)
8221 struct window *w;
8223 int i = 0;
8224 Lisp_Object vector, tmp;
8226 /* Reduce consing by keeping one vector in
8227 Vwith_echo_area_save_vector. */
8228 vector = Vwith_echo_area_save_vector;
8229 Vwith_echo_area_save_vector = Qnil;
8231 if (NILP (vector))
8232 vector = Fmake_vector (make_number (7), Qnil);
8234 XSETBUFFER (tmp, current_buffer); ASET (vector, i, tmp); ++i;
8235 ASET (vector, i, Vdeactivate_mark); ++i;
8236 ASET (vector, i, make_number (windows_or_buffers_changed)); ++i;
8238 if (w)
8240 XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
8241 ASET (vector, i, w->buffer); ++i;
8242 ASET (vector, i, make_number (XMARKER (w->pointm)->charpos)); ++i;
8243 ASET (vector, i, make_number (XMARKER (w->pointm)->bytepos)); ++i;
8245 else
8247 int end = i + 4;
8248 for (; i < end; ++i)
8249 ASET (vector, i, Qnil);
8252 xassert (i == ASIZE (vector));
8253 return vector;
8257 /* Restore global state from VECTOR which was created by
8258 with_echo_area_buffer_unwind_data. */
8260 static Lisp_Object
8261 unwind_with_echo_area_buffer (vector)
8262 Lisp_Object vector;
8264 set_buffer_internal_1 (XBUFFER (AREF (vector, 0)));
8265 Vdeactivate_mark = AREF (vector, 1);
8266 windows_or_buffers_changed = XFASTINT (AREF (vector, 2));
8268 if (WINDOWP (AREF (vector, 3)))
8270 struct window *w;
8271 Lisp_Object buffer, charpos, bytepos;
8273 w = XWINDOW (AREF (vector, 3));
8274 buffer = AREF (vector, 4);
8275 charpos = AREF (vector, 5);
8276 bytepos = AREF (vector, 6);
8278 w->buffer = buffer;
8279 set_marker_both (w->pointm, buffer,
8280 XFASTINT (charpos), XFASTINT (bytepos));
8283 Vwith_echo_area_save_vector = vector;
8284 return Qnil;
8288 /* Set up the echo area for use by print functions. MULTIBYTE_P
8289 non-zero means we will print multibyte. */
8291 void
8292 setup_echo_area_for_printing (multibyte_p)
8293 int multibyte_p;
8295 /* If we can't find an echo area any more, exit. */
8296 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
8297 Fkill_emacs (Qnil);
8299 ensure_echo_area_buffers ();
8301 if (!message_buf_print)
8303 /* A message has been output since the last time we printed.
8304 Choose a fresh echo area buffer. */
8305 if (EQ (echo_area_buffer[1], echo_buffer[0]))
8306 echo_area_buffer[0] = echo_buffer[1];
8307 else
8308 echo_area_buffer[0] = echo_buffer[0];
8310 /* Switch to that buffer and clear it. */
8311 set_buffer_internal (XBUFFER (echo_area_buffer[0]));
8312 current_buffer->truncate_lines = Qnil;
8314 if (Z > BEG)
8316 int count = SPECPDL_INDEX ();
8317 specbind (Qinhibit_read_only, Qt);
8318 /* Note that undo recording is always disabled. */
8319 del_range (BEG, Z);
8320 unbind_to (count, Qnil);
8322 TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
8324 /* Set up the buffer for the multibyteness we need. */
8325 if (multibyte_p
8326 != !NILP (current_buffer->enable_multibyte_characters))
8327 Fset_buffer_multibyte (multibyte_p ? Qt : Qnil);
8329 /* Raise the frame containing the echo area. */
8330 if (minibuffer_auto_raise)
8332 struct frame *sf = SELECTED_FRAME ();
8333 Lisp_Object mini_window;
8334 mini_window = FRAME_MINIBUF_WINDOW (sf);
8335 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
8338 message_log_maybe_newline ();
8339 message_buf_print = 1;
8341 else
8343 if (NILP (echo_area_buffer[0]))
8345 if (EQ (echo_area_buffer[1], echo_buffer[0]))
8346 echo_area_buffer[0] = echo_buffer[1];
8347 else
8348 echo_area_buffer[0] = echo_buffer[0];
8351 if (current_buffer != XBUFFER (echo_area_buffer[0]))
8353 /* Someone switched buffers between print requests. */
8354 set_buffer_internal (XBUFFER (echo_area_buffer[0]));
8355 current_buffer->truncate_lines = Qnil;
8361 /* Display an echo area message in window W. Value is non-zero if W's
8362 height is changed. If display_last_displayed_message_p is
8363 non-zero, display the message that was last displayed, otherwise
8364 display the current message. */
8366 static int
8367 display_echo_area (w)
8368 struct window *w;
8370 int i, no_message_p, window_height_changed_p, count;
8372 /* Temporarily disable garbage collections while displaying the echo
8373 area. This is done because a GC can print a message itself.
8374 That message would modify the echo area buffer's contents while a
8375 redisplay of the buffer is going on, and seriously confuse
8376 redisplay. */
8377 count = inhibit_garbage_collection ();
8379 /* If there is no message, we must call display_echo_area_1
8380 nevertheless because it resizes the window. But we will have to
8381 reset the echo_area_buffer in question to nil at the end because
8382 with_echo_area_buffer will sets it to an empty buffer. */
8383 i = display_last_displayed_message_p ? 1 : 0;
8384 no_message_p = NILP (echo_area_buffer[i]);
8386 window_height_changed_p
8387 = with_echo_area_buffer (w, display_last_displayed_message_p,
8388 display_echo_area_1,
8389 (EMACS_INT) w, Qnil, 0, 0);
8391 if (no_message_p)
8392 echo_area_buffer[i] = Qnil;
8394 unbind_to (count, Qnil);
8395 return window_height_changed_p;
8399 /* Helper for display_echo_area. Display the current buffer which
8400 contains the current echo area message in window W, a mini-window,
8401 a pointer to which is passed in A1. A2..A4 are currently not used.
8402 Change the height of W so that all of the message is displayed.
8403 Value is non-zero if height of W was changed. */
8405 static int
8406 display_echo_area_1 (a1, a2, a3, a4)
8407 EMACS_INT a1;
8408 Lisp_Object a2;
8409 EMACS_INT a3, a4;
8411 struct window *w = (struct window *) a1;
8412 Lisp_Object window;
8413 struct text_pos start;
8414 int window_height_changed_p = 0;
8416 /* Do this before displaying, so that we have a large enough glyph
8417 matrix for the display. If we can't get enough space for the
8418 whole text, display the last N lines. That works by setting w->start. */
8419 window_height_changed_p = resize_mini_window (w, 0);
8421 /* Use the starting position chosen by resize_mini_window. */
8422 SET_TEXT_POS_FROM_MARKER (start, w->start);
8424 /* Display. */
8425 clear_glyph_matrix (w->desired_matrix);
8426 XSETWINDOW (window, w);
8427 try_window (window, start, 0);
8429 return window_height_changed_p;
8433 /* Resize the echo area window to exactly the size needed for the
8434 currently displayed message, if there is one. If a mini-buffer
8435 is active, don't shrink it. */
8437 void
8438 resize_echo_area_exactly ()
8440 if (BUFFERP (echo_area_buffer[0])
8441 && WINDOWP (echo_area_window))
8443 struct window *w = XWINDOW (echo_area_window);
8444 int resized_p;
8445 Lisp_Object resize_exactly;
8447 if (minibuf_level == 0)
8448 resize_exactly = Qt;
8449 else
8450 resize_exactly = Qnil;
8452 resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
8453 (EMACS_INT) w, resize_exactly, 0, 0);
8454 if (resized_p)
8456 ++windows_or_buffers_changed;
8457 ++update_mode_lines;
8458 redisplay_internal (0);
8464 /* Callback function for with_echo_area_buffer, when used from
8465 resize_echo_area_exactly. A1 contains a pointer to the window to
8466 resize, EXACTLY non-nil means resize the mini-window exactly to the
8467 size of the text displayed. A3 and A4 are not used. Value is what
8468 resize_mini_window returns. */
8470 static int
8471 resize_mini_window_1 (a1, exactly, a3, a4)
8472 EMACS_INT a1;
8473 Lisp_Object exactly;
8474 EMACS_INT a3, a4;
8476 return resize_mini_window ((struct window *) a1, !NILP (exactly));
8480 /* Resize mini-window W to fit the size of its contents. EXACT_P
8481 means size the window exactly to the size needed. Otherwise, it's
8482 only enlarged until W's buffer is empty.
8484 Set W->start to the right place to begin display. If the whole
8485 contents fit, start at the beginning. Otherwise, start so as
8486 to make the end of the contents appear. This is particularly
8487 important for y-or-n-p, but seems desirable generally.
8489 Value is non-zero if the window height has been changed. */
8492 resize_mini_window (w, exact_p)
8493 struct window *w;
8494 int exact_p;
8496 struct frame *f = XFRAME (w->frame);
8497 int window_height_changed_p = 0;
8499 xassert (MINI_WINDOW_P (w));
8501 /* By default, start display at the beginning. */
8502 set_marker_both (w->start, w->buffer,
8503 BUF_BEGV (XBUFFER (w->buffer)),
8504 BUF_BEGV_BYTE (XBUFFER (w->buffer)));
8506 /* Don't resize windows while redisplaying a window; it would
8507 confuse redisplay functions when the size of the window they are
8508 displaying changes from under them. Such a resizing can happen,
8509 for instance, when which-func prints a long message while
8510 we are running fontification-functions. We're running these
8511 functions with safe_call which binds inhibit-redisplay to t. */
8512 if (!NILP (Vinhibit_redisplay))
8513 return 0;
8515 /* Nil means don't try to resize. */
8516 if (NILP (Vresize_mini_windows)
8517 || (FRAME_X_P (f) && FRAME_X_OUTPUT (f) == NULL))
8518 return 0;
8520 if (!FRAME_MINIBUF_ONLY_P (f))
8522 struct it it;
8523 struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
8524 int total_height = WINDOW_TOTAL_LINES (root) + WINDOW_TOTAL_LINES (w);
8525 int height, max_height;
8526 int unit = FRAME_LINE_HEIGHT (f);
8527 struct text_pos start;
8528 struct buffer *old_current_buffer = NULL;
8530 if (current_buffer != XBUFFER (w->buffer))
8532 old_current_buffer = current_buffer;
8533 set_buffer_internal (XBUFFER (w->buffer));
8536 init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
8538 /* Compute the max. number of lines specified by the user. */
8539 if (FLOATP (Vmax_mini_window_height))
8540 max_height = XFLOATINT (Vmax_mini_window_height) * FRAME_LINES (f);
8541 else if (INTEGERP (Vmax_mini_window_height))
8542 max_height = XINT (Vmax_mini_window_height);
8543 else
8544 max_height = total_height / 4;
8546 /* Correct that max. height if it's bogus. */
8547 max_height = max (1, max_height);
8548 max_height = min (total_height, max_height);
8550 /* Find out the height of the text in the window. */
8551 if (it.truncate_lines_p)
8552 height = 1;
8553 else
8555 last_height = 0;
8556 move_it_to (&it, ZV, -1, -1, -1, MOVE_TO_POS);
8557 if (it.max_ascent == 0 && it.max_descent == 0)
8558 height = it.current_y + last_height;
8559 else
8560 height = it.current_y + it.max_ascent + it.max_descent;
8561 height -= min (it.extra_line_spacing, it.max_extra_line_spacing);
8562 height = (height + unit - 1) / unit;
8565 /* Compute a suitable window start. */
8566 if (height > max_height)
8568 height = max_height;
8569 init_iterator (&it, w, ZV, ZV_BYTE, NULL, DEFAULT_FACE_ID);
8570 move_it_vertically_backward (&it, (height - 1) * unit);
8571 start = it.current.pos;
8573 else
8574 SET_TEXT_POS (start, BEGV, BEGV_BYTE);
8575 SET_MARKER_FROM_TEXT_POS (w->start, start);
8577 if (EQ (Vresize_mini_windows, Qgrow_only))
8579 /* Let it grow only, until we display an empty message, in which
8580 case the window shrinks again. */
8581 if (height > WINDOW_TOTAL_LINES (w))
8583 int old_height = WINDOW_TOTAL_LINES (w);
8584 freeze_window_starts (f, 1);
8585 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
8586 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
8588 else if (height < WINDOW_TOTAL_LINES (w)
8589 && (exact_p || BEGV == ZV))
8591 int old_height = WINDOW_TOTAL_LINES (w);
8592 freeze_window_starts (f, 0);
8593 shrink_mini_window (w);
8594 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
8597 else
8599 /* Always resize to exact size needed. */
8600 if (height > WINDOW_TOTAL_LINES (w))
8602 int old_height = WINDOW_TOTAL_LINES (w);
8603 freeze_window_starts (f, 1);
8604 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
8605 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
8607 else if (height < WINDOW_TOTAL_LINES (w))
8609 int old_height = WINDOW_TOTAL_LINES (w);
8610 freeze_window_starts (f, 0);
8611 shrink_mini_window (w);
8613 if (height)
8615 freeze_window_starts (f, 1);
8616 grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
8619 window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
8623 if (old_current_buffer)
8624 set_buffer_internal (old_current_buffer);
8627 return window_height_changed_p;
8631 /* Value is the current message, a string, or nil if there is no
8632 current message. */
8634 Lisp_Object
8635 current_message ()
8637 Lisp_Object msg;
8639 if (NILP (echo_area_buffer[0]))
8640 msg = Qnil;
8641 else
8643 with_echo_area_buffer (0, 0, current_message_1,
8644 (EMACS_INT) &msg, Qnil, 0, 0);
8645 if (NILP (msg))
8646 echo_area_buffer[0] = Qnil;
8649 return msg;
8653 static int
8654 current_message_1 (a1, a2, a3, a4)
8655 EMACS_INT a1;
8656 Lisp_Object a2;
8657 EMACS_INT a3, a4;
8659 Lisp_Object *msg = (Lisp_Object *) a1;
8661 if (Z > BEG)
8662 *msg = make_buffer_string (BEG, Z, 1);
8663 else
8664 *msg = Qnil;
8665 return 0;
8669 /* Push the current message on Vmessage_stack for later restauration
8670 by restore_message. Value is non-zero if the current message isn't
8671 empty. This is a relatively infrequent operation, so it's not
8672 worth optimizing. */
8675 push_message ()
8677 Lisp_Object msg;
8678 msg = current_message ();
8679 Vmessage_stack = Fcons (msg, Vmessage_stack);
8680 return STRINGP (msg);
8684 /* Restore message display from the top of Vmessage_stack. */
8686 void
8687 restore_message ()
8689 Lisp_Object msg;
8691 xassert (CONSP (Vmessage_stack));
8692 msg = XCAR (Vmessage_stack);
8693 if (STRINGP (msg))
8694 message3_nolog (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
8695 else
8696 message3_nolog (msg, 0, 0);
8700 /* Handler for record_unwind_protect calling pop_message. */
8702 Lisp_Object
8703 pop_message_unwind (dummy)
8704 Lisp_Object dummy;
8706 pop_message ();
8707 return Qnil;
8710 /* Pop the top-most entry off Vmessage_stack. */
8712 void
8713 pop_message ()
8715 xassert (CONSP (Vmessage_stack));
8716 Vmessage_stack = XCDR (Vmessage_stack);
8720 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
8721 exits. If the stack is not empty, we have a missing pop_message
8722 somewhere. */
8724 void
8725 check_message_stack ()
8727 if (!NILP (Vmessage_stack))
8728 abort ();
8732 /* Truncate to NCHARS what will be displayed in the echo area the next
8733 time we display it---but don't redisplay it now. */
8735 void
8736 truncate_echo_area (nchars)
8737 int nchars;
8739 if (nchars == 0)
8740 echo_area_buffer[0] = Qnil;
8741 /* A null message buffer means that the frame hasn't really been
8742 initialized yet. Error messages get reported properly by
8743 cmd_error, so this must be just an informative message; toss it. */
8744 else if (!noninteractive
8745 && INTERACTIVE
8746 && !NILP (echo_area_buffer[0]))
8748 struct frame *sf = SELECTED_FRAME ();
8749 if (FRAME_MESSAGE_BUF (sf))
8750 with_echo_area_buffer (0, 0, truncate_message_1, nchars, Qnil, 0, 0);
8755 /* Helper function for truncate_echo_area. Truncate the current
8756 message to at most NCHARS characters. */
8758 static int
8759 truncate_message_1 (nchars, a2, a3, a4)
8760 EMACS_INT nchars;
8761 Lisp_Object a2;
8762 EMACS_INT a3, a4;
8764 if (BEG + nchars < Z)
8765 del_range (BEG + nchars, Z);
8766 if (Z == BEG)
8767 echo_area_buffer[0] = Qnil;
8768 return 0;
8772 /* Set the current message to a substring of S or STRING.
8774 If STRING is a Lisp string, set the message to the first NBYTES
8775 bytes from STRING. NBYTES zero means use the whole string. If
8776 STRING is multibyte, the message will be displayed multibyte.
8778 If S is not null, set the message to the first LEN bytes of S. LEN
8779 zero means use the whole string. MULTIBYTE_P non-zero means S is
8780 multibyte. Display the message multibyte in that case.
8782 Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
8783 to t before calling set_message_1 (which calls insert).
8786 void
8787 set_message (s, string, nbytes, multibyte_p)
8788 const char *s;
8789 Lisp_Object string;
8790 int nbytes, multibyte_p;
8792 message_enable_multibyte
8793 = ((s && multibyte_p)
8794 || (STRINGP (string) && STRING_MULTIBYTE (string)));
8796 with_echo_area_buffer (0, -1, set_message_1,
8797 (EMACS_INT) s, string, nbytes, multibyte_p);
8798 message_buf_print = 0;
8799 help_echo_showing_p = 0;
8803 /* Helper function for set_message. Arguments have the same meaning
8804 as there, with A1 corresponding to S and A2 corresponding to STRING
8805 This function is called with the echo area buffer being
8806 current. */
8808 static int
8809 set_message_1 (a1, a2, nbytes, multibyte_p)
8810 EMACS_INT a1;
8811 Lisp_Object a2;
8812 EMACS_INT nbytes, multibyte_p;
8814 const char *s = (const char *) a1;
8815 Lisp_Object string = a2;
8817 /* Change multibyteness of the echo buffer appropriately. */
8818 if (message_enable_multibyte
8819 != !NILP (current_buffer->enable_multibyte_characters))
8820 Fset_buffer_multibyte (message_enable_multibyte ? Qt : Qnil);
8822 current_buffer->truncate_lines = message_truncate_lines ? Qt : Qnil;
8824 /* Insert new message at BEG. */
8825 TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
8827 if (STRINGP (string))
8829 int nchars;
8831 if (nbytes == 0)
8832 nbytes = SBYTES (string);
8833 nchars = string_byte_to_char (string, nbytes);
8835 /* This function takes care of single/multibyte conversion. We
8836 just have to ensure that the echo area buffer has the right
8837 setting of enable_multibyte_characters. */
8838 insert_from_string (string, 0, 0, nchars, nbytes, 1);
8840 else if (s)
8842 if (nbytes == 0)
8843 nbytes = strlen (s);
8845 if (multibyte_p && NILP (current_buffer->enable_multibyte_characters))
8847 /* Convert from multi-byte to single-byte. */
8848 int i, c, n;
8849 unsigned char work[1];
8851 /* Convert a multibyte string to single-byte. */
8852 for (i = 0; i < nbytes; i += n)
8854 c = string_char_and_length (s + i, nbytes - i, &n);
8855 work[0] = (ASCII_CHAR_P (c)
8857 : multibyte_char_to_unibyte (c, Qnil));
8858 insert_1_both (work, 1, 1, 1, 0, 0);
8861 else if (!multibyte_p
8862 && !NILP (current_buffer->enable_multibyte_characters))
8864 /* Convert from single-byte to multi-byte. */
8865 int i, c, n;
8866 const unsigned char *msg = (const unsigned char *) s;
8867 unsigned char str[MAX_MULTIBYTE_LENGTH];
8869 /* Convert a single-byte string to multibyte. */
8870 for (i = 0; i < nbytes; i++)
8872 c = msg[i];
8873 c = unibyte_char_to_multibyte (c);
8874 n = CHAR_STRING (c, str);
8875 insert_1_both (str, 1, n, 1, 0, 0);
8878 else
8879 insert_1 (s, nbytes, 1, 0, 0);
8882 return 0;
8886 /* Clear messages. CURRENT_P non-zero means clear the current
8887 message. LAST_DISPLAYED_P non-zero means clear the message
8888 last displayed. */
8890 void
8891 clear_message (current_p, last_displayed_p)
8892 int current_p, last_displayed_p;
8894 if (current_p)
8896 echo_area_buffer[0] = Qnil;
8897 message_cleared_p = 1;
8900 if (last_displayed_p)
8901 echo_area_buffer[1] = Qnil;
8903 message_buf_print = 0;
8906 /* Clear garbaged frames.
8908 This function is used where the old redisplay called
8909 redraw_garbaged_frames which in turn called redraw_frame which in
8910 turn called clear_frame. The call to clear_frame was a source of
8911 flickering. I believe a clear_frame is not necessary. It should
8912 suffice in the new redisplay to invalidate all current matrices,
8913 and ensure a complete redisplay of all windows. */
8915 static void
8916 clear_garbaged_frames ()
8918 if (frame_garbaged)
8920 Lisp_Object tail, frame;
8921 int changed_count = 0;
8923 FOR_EACH_FRAME (tail, frame)
8925 struct frame *f = XFRAME (frame);
8927 if (FRAME_VISIBLE_P (f) && FRAME_GARBAGED_P (f))
8929 if (f->resized_p)
8931 Fredraw_frame (frame);
8932 f->force_flush_display_p = 1;
8934 clear_current_matrices (f);
8935 changed_count++;
8936 f->garbaged = 0;
8937 f->resized_p = 0;
8941 frame_garbaged = 0;
8942 if (changed_count)
8943 ++windows_or_buffers_changed;
8948 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
8949 is non-zero update selected_frame. Value is non-zero if the
8950 mini-windows height has been changed. */
8952 static int
8953 echo_area_display (update_frame_p)
8954 int update_frame_p;
8956 Lisp_Object mini_window;
8957 struct window *w;
8958 struct frame *f;
8959 int window_height_changed_p = 0;
8960 struct frame *sf = SELECTED_FRAME ();
8962 mini_window = FRAME_MINIBUF_WINDOW (sf);
8963 w = XWINDOW (mini_window);
8964 f = XFRAME (WINDOW_FRAME (w));
8966 /* Don't display if frame is invisible or not yet initialized. */
8967 if (!FRAME_VISIBLE_P (f) || !f->glyphs_initialized_p)
8968 return 0;
8970 #ifdef HAVE_WINDOW_SYSTEM
8971 /* When Emacs starts, selected_frame may be the initial terminal
8972 frame. If we let this through, a message would be displayed on
8973 the terminal. */
8974 if (FRAME_INITIAL_P (XFRAME (selected_frame)))
8975 return 0;
8976 #endif /* HAVE_WINDOW_SYSTEM */
8978 /* Redraw garbaged frames. */
8979 if (frame_garbaged)
8980 clear_garbaged_frames ();
8982 if (!NILP (echo_area_buffer[0]) || minibuf_level == 0)
8984 echo_area_window = mini_window;
8985 window_height_changed_p = display_echo_area (w);
8986 w->must_be_updated_p = 1;
8988 /* Update the display, unless called from redisplay_internal.
8989 Also don't update the screen during redisplay itself. The
8990 update will happen at the end of redisplay, and an update
8991 here could cause confusion. */
8992 if (update_frame_p && !redisplaying_p)
8994 int n = 0;
8996 /* If the display update has been interrupted by pending
8997 input, update mode lines in the frame. Due to the
8998 pending input, it might have been that redisplay hasn't
8999 been called, so that mode lines above the echo area are
9000 garbaged. This looks odd, so we prevent it here. */
9001 if (!display_completed)
9002 n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), 0);
9004 if (window_height_changed_p
9005 /* Don't do this if Emacs is shutting down. Redisplay
9006 needs to run hooks. */
9007 && !NILP (Vrun_hooks))
9009 /* Must update other windows. Likewise as in other
9010 cases, don't let this update be interrupted by
9011 pending input. */
9012 int count = SPECPDL_INDEX ();
9013 specbind (Qredisplay_dont_pause, Qt);
9014 windows_or_buffers_changed = 1;
9015 redisplay_internal (0);
9016 unbind_to (count, Qnil);
9018 else if (FRAME_WINDOW_P (f) && n == 0)
9020 /* Window configuration is the same as before.
9021 Can do with a display update of the echo area,
9022 unless we displayed some mode lines. */
9023 update_single_window (w, 1);
9024 FRAME_RIF (f)->flush_display (f);
9026 else
9027 update_frame (f, 1, 1);
9029 /* If cursor is in the echo area, make sure that the next
9030 redisplay displays the minibuffer, so that the cursor will
9031 be replaced with what the minibuffer wants. */
9032 if (cursor_in_echo_area)
9033 ++windows_or_buffers_changed;
9036 else if (!EQ (mini_window, selected_window))
9037 windows_or_buffers_changed++;
9039 /* Last displayed message is now the current message. */
9040 echo_area_buffer[1] = echo_area_buffer[0];
9041 /* Inform read_char that we're not echoing. */
9042 echo_message_buffer = Qnil;
9044 /* Prevent redisplay optimization in redisplay_internal by resetting
9045 this_line_start_pos. This is done because the mini-buffer now
9046 displays the message instead of its buffer text. */
9047 if (EQ (mini_window, selected_window))
9048 CHARPOS (this_line_start_pos) = 0;
9050 return window_height_changed_p;
9055 /***********************************************************************
9056 Mode Lines and Frame Titles
9057 ***********************************************************************/
9059 /* A buffer for constructing non-propertized mode-line strings and
9060 frame titles in it; allocated from the heap in init_xdisp and
9061 resized as needed in store_mode_line_noprop_char. */
9063 static char *mode_line_noprop_buf;
9065 /* The buffer's end, and a current output position in it. */
9067 static char *mode_line_noprop_buf_end;
9068 static char *mode_line_noprop_ptr;
9070 #define MODE_LINE_NOPROP_LEN(start) \
9071 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
9073 static enum {
9074 MODE_LINE_DISPLAY = 0,
9075 MODE_LINE_TITLE,
9076 MODE_LINE_NOPROP,
9077 MODE_LINE_STRING
9078 } mode_line_target;
9080 /* Alist that caches the results of :propertize.
9081 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
9082 static Lisp_Object mode_line_proptrans_alist;
9084 /* List of strings making up the mode-line. */
9085 static Lisp_Object mode_line_string_list;
9087 /* Base face property when building propertized mode line string. */
9088 static Lisp_Object mode_line_string_face;
9089 static Lisp_Object mode_line_string_face_prop;
9092 /* Unwind data for mode line strings */
9094 static Lisp_Object Vmode_line_unwind_vector;
9096 static Lisp_Object
9097 format_mode_line_unwind_data (obuf, save_proptrans)
9098 struct buffer *obuf;
9100 Lisp_Object vector, tmp;
9102 /* Reduce consing by keeping one vector in
9103 Vwith_echo_area_save_vector. */
9104 vector = Vmode_line_unwind_vector;
9105 Vmode_line_unwind_vector = Qnil;
9107 if (NILP (vector))
9108 vector = Fmake_vector (make_number (7), Qnil);
9110 ASET (vector, 0, make_number (mode_line_target));
9111 ASET (vector, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
9112 ASET (vector, 2, mode_line_string_list);
9113 ASET (vector, 3, save_proptrans ? mode_line_proptrans_alist : Qt);
9114 ASET (vector, 4, mode_line_string_face);
9115 ASET (vector, 5, mode_line_string_face_prop);
9117 if (obuf)
9118 XSETBUFFER (tmp, obuf);
9119 else
9120 tmp = Qnil;
9121 ASET (vector, 6, tmp);
9123 return vector;
9126 static Lisp_Object
9127 unwind_format_mode_line (vector)
9128 Lisp_Object vector;
9130 mode_line_target = XINT (AREF (vector, 0));
9131 mode_line_noprop_ptr = mode_line_noprop_buf + XINT (AREF (vector, 1));
9132 mode_line_string_list = AREF (vector, 2);
9133 if (! EQ (AREF (vector, 3), Qt))
9134 mode_line_proptrans_alist = AREF (vector, 3);
9135 mode_line_string_face = AREF (vector, 4);
9136 mode_line_string_face_prop = AREF (vector, 5);
9138 if (!NILP (AREF (vector, 6)))
9140 set_buffer_internal_1 (XBUFFER (AREF (vector, 6)));
9141 ASET (vector, 6, Qnil);
9144 Vmode_line_unwind_vector = vector;
9145 return Qnil;
9149 /* Store a single character C for the frame title in mode_line_noprop_buf.
9150 Re-allocate mode_line_noprop_buf if necessary. */
9152 static void
9153 #ifdef PROTOTYPES
9154 store_mode_line_noprop_char (char c)
9155 #else
9156 store_mode_line_noprop_char (c)
9157 char c;
9158 #endif
9160 /* If output position has reached the end of the allocated buffer,
9161 double the buffer's size. */
9162 if (mode_line_noprop_ptr == mode_line_noprop_buf_end)
9164 int len = MODE_LINE_NOPROP_LEN (0);
9165 int new_size = 2 * len * sizeof *mode_line_noprop_buf;
9166 mode_line_noprop_buf = (char *) xrealloc (mode_line_noprop_buf, new_size);
9167 mode_line_noprop_buf_end = mode_line_noprop_buf + new_size;
9168 mode_line_noprop_ptr = mode_line_noprop_buf + len;
9171 *mode_line_noprop_ptr++ = c;
9175 /* Store part of a frame title in mode_line_noprop_buf, beginning at
9176 mode_line_noprop_ptr. STR is the string to store. Do not copy
9177 characters that yield more columns than PRECISION; PRECISION <= 0
9178 means copy the whole string. Pad with spaces until FIELD_WIDTH
9179 number of characters have been copied; FIELD_WIDTH <= 0 means don't
9180 pad. Called from display_mode_element when it is used to build a
9181 frame title. */
9183 static int
9184 store_mode_line_noprop (str, field_width, precision)
9185 const unsigned char *str;
9186 int field_width, precision;
9188 int n = 0;
9189 int dummy, nbytes;
9191 /* Copy at most PRECISION chars from STR. */
9192 nbytes = strlen (str);
9193 n += c_string_width (str, nbytes, precision, &dummy, &nbytes);
9194 while (nbytes--)
9195 store_mode_line_noprop_char (*str++);
9197 /* Fill up with spaces until FIELD_WIDTH reached. */
9198 while (field_width > 0
9199 && n < field_width)
9201 store_mode_line_noprop_char (' ');
9202 ++n;
9205 return n;
9208 /***********************************************************************
9209 Frame Titles
9210 ***********************************************************************/
9212 #ifdef HAVE_WINDOW_SYSTEM
9214 /* Set the title of FRAME, if it has changed. The title format is
9215 Vicon_title_format if FRAME is iconified, otherwise it is
9216 frame_title_format. */
9218 static void
9219 x_consider_frame_title (frame)
9220 Lisp_Object frame;
9222 struct frame *f = XFRAME (frame);
9224 if (FRAME_WINDOW_P (f)
9225 || FRAME_MINIBUF_ONLY_P (f)
9226 || f->explicit_name)
9228 /* Do we have more than one visible frame on this X display? */
9229 Lisp_Object tail;
9230 Lisp_Object fmt;
9231 int title_start;
9232 char *title;
9233 int len;
9234 struct it it;
9235 int count = SPECPDL_INDEX ();
9237 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
9239 Lisp_Object other_frame = XCAR (tail);
9240 struct frame *tf = XFRAME (other_frame);
9242 if (tf != f
9243 && FRAME_KBOARD (tf) == FRAME_KBOARD (f)
9244 && !FRAME_MINIBUF_ONLY_P (tf)
9245 && !EQ (other_frame, tip_frame)
9246 && (FRAME_VISIBLE_P (tf) || FRAME_ICONIFIED_P (tf)))
9247 break;
9250 /* Set global variable indicating that multiple frames exist. */
9251 multiple_frames = CONSP (tail);
9253 /* Switch to the buffer of selected window of the frame. Set up
9254 mode_line_target so that display_mode_element will output into
9255 mode_line_noprop_buf; then display the title. */
9256 record_unwind_protect (unwind_format_mode_line,
9257 format_mode_line_unwind_data (current_buffer, 0));
9259 set_buffer_internal_1 (XBUFFER (XWINDOW (f->selected_window)->buffer));
9260 fmt = FRAME_ICONIFIED_P (f) ? Vicon_title_format : Vframe_title_format;
9262 mode_line_target = MODE_LINE_TITLE;
9263 title_start = MODE_LINE_NOPROP_LEN (0);
9264 init_iterator (&it, XWINDOW (f->selected_window), -1, -1,
9265 NULL, DEFAULT_FACE_ID);
9266 display_mode_element (&it, 0, -1, -1, fmt, Qnil, 0);
9267 len = MODE_LINE_NOPROP_LEN (title_start);
9268 title = mode_line_noprop_buf + title_start;
9269 unbind_to (count, Qnil);
9271 /* Set the title only if it's changed. This avoids consing in
9272 the common case where it hasn't. (If it turns out that we've
9273 already wasted too much time by walking through the list with
9274 display_mode_element, then we might need to optimize at a
9275 higher level than this.) */
9276 if (! STRINGP (f->name)
9277 || SBYTES (f->name) != len
9278 || bcmp (title, SDATA (f->name), len) != 0)
9279 x_implicitly_set_name (f, make_string (title, len), Qnil);
9283 #endif /* not HAVE_WINDOW_SYSTEM */
9288 /***********************************************************************
9289 Menu Bars
9290 ***********************************************************************/
9293 /* Prepare for redisplay by updating menu-bar item lists when
9294 appropriate. This can call eval. */
9296 void
9297 prepare_menu_bars ()
9299 int all_windows;
9300 struct gcpro gcpro1, gcpro2;
9301 struct frame *f;
9302 Lisp_Object tooltip_frame;
9304 #ifdef HAVE_WINDOW_SYSTEM
9305 tooltip_frame = tip_frame;
9306 #else
9307 tooltip_frame = Qnil;
9308 #endif
9310 /* Update all frame titles based on their buffer names, etc. We do
9311 this before the menu bars so that the buffer-menu will show the
9312 up-to-date frame titles. */
9313 #ifdef HAVE_WINDOW_SYSTEM
9314 if (windows_or_buffers_changed || update_mode_lines)
9316 Lisp_Object tail, frame;
9318 FOR_EACH_FRAME (tail, frame)
9320 f = XFRAME (frame);
9321 if (!EQ (frame, tooltip_frame)
9322 && (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)))
9323 x_consider_frame_title (frame);
9326 #endif /* HAVE_WINDOW_SYSTEM */
9328 /* Update the menu bar item lists, if appropriate. This has to be
9329 done before any actual redisplay or generation of display lines. */
9330 all_windows = (update_mode_lines
9331 || buffer_shared > 1
9332 || windows_or_buffers_changed);
9333 if (all_windows)
9335 Lisp_Object tail, frame;
9336 int count = SPECPDL_INDEX ();
9337 /* 1 means that update_menu_bar has run its hooks
9338 so any further calls to update_menu_bar shouldn't do so again. */
9339 int menu_bar_hooks_run = 0;
9341 record_unwind_save_match_data ();
9343 FOR_EACH_FRAME (tail, frame)
9345 f = XFRAME (frame);
9347 /* Ignore tooltip frame. */
9348 if (EQ (frame, tooltip_frame))
9349 continue;
9351 /* If a window on this frame changed size, report that to
9352 the user and clear the size-change flag. */
9353 if (FRAME_WINDOW_SIZES_CHANGED (f))
9355 Lisp_Object functions;
9357 /* Clear flag first in case we get an error below. */
9358 FRAME_WINDOW_SIZES_CHANGED (f) = 0;
9359 functions = Vwindow_size_change_functions;
9360 GCPRO2 (tail, functions);
9362 while (CONSP (functions))
9364 call1 (XCAR (functions), frame);
9365 functions = XCDR (functions);
9367 UNGCPRO;
9370 GCPRO1 (tail);
9371 menu_bar_hooks_run = update_menu_bar (f, 0, menu_bar_hooks_run);
9372 #ifdef HAVE_WINDOW_SYSTEM
9373 update_tool_bar (f, 0);
9374 #ifdef MAC_OS
9375 mac_update_title_bar (f, 0);
9376 #endif
9377 #endif
9378 UNGCPRO;
9381 unbind_to (count, Qnil);
9383 else
9385 struct frame *sf = SELECTED_FRAME ();
9386 update_menu_bar (sf, 1, 0);
9387 #ifdef HAVE_WINDOW_SYSTEM
9388 update_tool_bar (sf, 1);
9389 #ifdef MAC_OS
9390 mac_update_title_bar (sf, 1);
9391 #endif
9392 #endif
9395 /* Motif needs this. See comment in xmenu.c. Turn it off when
9396 pending_menu_activation is not defined. */
9397 #ifdef USE_X_TOOLKIT
9398 pending_menu_activation = 0;
9399 #endif
9403 /* Update the menu bar item list for frame F. This has to be done
9404 before we start to fill in any display lines, because it can call
9405 eval.
9407 If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
9409 If HOOKS_RUN is 1, that means a previous call to update_menu_bar
9410 already ran the menu bar hooks for this redisplay, so there
9411 is no need to run them again. The return value is the
9412 updated value of this flag, to pass to the next call. */
9414 static int
9415 update_menu_bar (f, save_match_data, hooks_run)
9416 struct frame *f;
9417 int save_match_data;
9418 int hooks_run;
9420 Lisp_Object window;
9421 register struct window *w;
9423 /* If called recursively during a menu update, do nothing. This can
9424 happen when, for instance, an activate-menubar-hook causes a
9425 redisplay. */
9426 if (inhibit_menubar_update)
9427 return hooks_run;
9429 window = FRAME_SELECTED_WINDOW (f);
9430 w = XWINDOW (window);
9432 #if 0 /* The if statement below this if statement used to include the
9433 condition !NILP (w->update_mode_line), rather than using
9434 update_mode_lines directly, and this if statement may have
9435 been added to make that condition work. Now the if
9436 statement below matches its comment, this isn't needed. */
9437 if (update_mode_lines)
9438 w->update_mode_line = Qt;
9439 #endif
9441 if (FRAME_WINDOW_P (f)
9443 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
9444 || defined (USE_GTK)
9445 FRAME_EXTERNAL_MENU_BAR (f)
9446 #else
9447 FRAME_MENU_BAR_LINES (f) > 0
9448 #endif
9449 : FRAME_MENU_BAR_LINES (f) > 0)
9451 /* If the user has switched buffers or windows, we need to
9452 recompute to reflect the new bindings. But we'll
9453 recompute when update_mode_lines is set too; that means
9454 that people can use force-mode-line-update to request
9455 that the menu bar be recomputed. The adverse effect on
9456 the rest of the redisplay algorithm is about the same as
9457 windows_or_buffers_changed anyway. */
9458 if (windows_or_buffers_changed
9459 /* This used to test w->update_mode_line, but we believe
9460 there is no need to recompute the menu in that case. */
9461 || update_mode_lines
9462 || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
9463 < BUF_MODIFF (XBUFFER (w->buffer)))
9464 != !NILP (w->last_had_star))
9465 || ((!NILP (Vtransient_mark_mode)
9466 && !NILP (XBUFFER (w->buffer)->mark_active))
9467 != !NILP (w->region_showing)))
9469 struct buffer *prev = current_buffer;
9470 int count = SPECPDL_INDEX ();
9472 specbind (Qinhibit_menubar_update, Qt);
9474 set_buffer_internal_1 (XBUFFER (w->buffer));
9475 if (save_match_data)
9476 record_unwind_save_match_data ();
9477 if (NILP (Voverriding_local_map_menu_flag))
9479 specbind (Qoverriding_terminal_local_map, Qnil);
9480 specbind (Qoverriding_local_map, Qnil);
9483 if (!hooks_run)
9485 /* Run the Lucid hook. */
9486 safe_run_hooks (Qactivate_menubar_hook);
9488 /* If it has changed current-menubar from previous value,
9489 really recompute the menu-bar from the value. */
9490 if (! NILP (Vlucid_menu_bar_dirty_flag))
9491 call0 (Qrecompute_lucid_menubar);
9493 safe_run_hooks (Qmenu_bar_update_hook);
9495 hooks_run = 1;
9498 XSETFRAME (Vmenu_updating_frame, f);
9499 FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
9501 /* Redisplay the menu bar in case we changed it. */
9502 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
9503 || defined (USE_GTK)
9504 if (FRAME_WINDOW_P (f))
9506 #ifdef MAC_OS
9507 /* All frames on Mac OS share the same menubar. So only
9508 the selected frame should be allowed to set it. */
9509 if (f == SELECTED_FRAME ())
9510 #endif
9511 set_frame_menubar (f, 0, 0);
9513 else
9514 /* On a terminal screen, the menu bar is an ordinary screen
9515 line, and this makes it get updated. */
9516 w->update_mode_line = Qt;
9517 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || MAC_OS || USE_GTK) */
9518 /* In the non-toolkit version, the menu bar is an ordinary screen
9519 line, and this makes it get updated. */
9520 w->update_mode_line = Qt;
9521 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || MAC_OS || USE_GTK) */
9523 unbind_to (count, Qnil);
9524 set_buffer_internal_1 (prev);
9528 return hooks_run;
9533 /***********************************************************************
9534 Output Cursor
9535 ***********************************************************************/
9537 #ifdef HAVE_WINDOW_SYSTEM
9539 /* EXPORT:
9540 Nominal cursor position -- where to draw output.
9541 HPOS and VPOS are window relative glyph matrix coordinates.
9542 X and Y are window relative pixel coordinates. */
9544 struct cursor_pos output_cursor;
9547 /* EXPORT:
9548 Set the global variable output_cursor to CURSOR. All cursor
9549 positions are relative to updated_window. */
9551 void
9552 set_output_cursor (cursor)
9553 struct cursor_pos *cursor;
9555 output_cursor.hpos = cursor->hpos;
9556 output_cursor.vpos = cursor->vpos;
9557 output_cursor.x = cursor->x;
9558 output_cursor.y = cursor->y;
9562 /* EXPORT for RIF:
9563 Set a nominal cursor position.
9565 HPOS and VPOS are column/row positions in a window glyph matrix. X
9566 and Y are window text area relative pixel positions.
9568 If this is done during an update, updated_window will contain the
9569 window that is being updated and the position is the future output
9570 cursor position for that window. If updated_window is null, use
9571 selected_window and display the cursor at the given position. */
9573 void
9574 x_cursor_to (vpos, hpos, y, x)
9575 int vpos, hpos, y, x;
9577 struct window *w;
9579 /* If updated_window is not set, work on selected_window. */
9580 if (updated_window)
9581 w = updated_window;
9582 else
9583 w = XWINDOW (selected_window);
9585 /* Set the output cursor. */
9586 output_cursor.hpos = hpos;
9587 output_cursor.vpos = vpos;
9588 output_cursor.x = x;
9589 output_cursor.y = y;
9591 /* If not called as part of an update, really display the cursor.
9592 This will also set the cursor position of W. */
9593 if (updated_window == NULL)
9595 BLOCK_INPUT;
9596 display_and_set_cursor (w, 1, hpos, vpos, x, y);
9597 if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
9598 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
9599 UNBLOCK_INPUT;
9603 #endif /* HAVE_WINDOW_SYSTEM */
9606 /***********************************************************************
9607 Tool-bars
9608 ***********************************************************************/
9610 #ifdef HAVE_WINDOW_SYSTEM
9612 /* Where the mouse was last time we reported a mouse event. */
9614 FRAME_PTR last_mouse_frame;
9616 /* Tool-bar item index of the item on which a mouse button was pressed
9617 or -1. */
9619 int last_tool_bar_item;
9622 /* Update the tool-bar item list for frame F. This has to be done
9623 before we start to fill in any display lines. Called from
9624 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
9625 and restore it here. */
9627 static void
9628 update_tool_bar (f, save_match_data)
9629 struct frame *f;
9630 int save_match_data;
9632 #if defined (USE_GTK) || USE_MAC_TOOLBAR
9633 int do_update = FRAME_EXTERNAL_TOOL_BAR (f);
9634 #else
9635 int do_update = WINDOWP (f->tool_bar_window)
9636 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0;
9637 #endif
9639 if (do_update)
9641 Lisp_Object window;
9642 struct window *w;
9644 window = FRAME_SELECTED_WINDOW (f);
9645 w = XWINDOW (window);
9647 /* If the user has switched buffers or windows, we need to
9648 recompute to reflect the new bindings. But we'll
9649 recompute when update_mode_lines is set too; that means
9650 that people can use force-mode-line-update to request
9651 that the menu bar be recomputed. The adverse effect on
9652 the rest of the redisplay algorithm is about the same as
9653 windows_or_buffers_changed anyway. */
9654 if (windows_or_buffers_changed
9655 || !NILP (w->update_mode_line)
9656 || update_mode_lines
9657 || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
9658 < BUF_MODIFF (XBUFFER (w->buffer)))
9659 != !NILP (w->last_had_star))
9660 || ((!NILP (Vtransient_mark_mode)
9661 && !NILP (XBUFFER (w->buffer)->mark_active))
9662 != !NILP (w->region_showing)))
9664 struct buffer *prev = current_buffer;
9665 int count = SPECPDL_INDEX ();
9666 Lisp_Object new_tool_bar;
9667 int new_n_tool_bar;
9668 struct gcpro gcpro1;
9670 /* Set current_buffer to the buffer of the selected
9671 window of the frame, so that we get the right local
9672 keymaps. */
9673 set_buffer_internal_1 (XBUFFER (w->buffer));
9675 /* Save match data, if we must. */
9676 if (save_match_data)
9677 record_unwind_save_match_data ();
9679 /* Make sure that we don't accidentally use bogus keymaps. */
9680 if (NILP (Voverriding_local_map_menu_flag))
9682 specbind (Qoverriding_terminal_local_map, Qnil);
9683 specbind (Qoverriding_local_map, Qnil);
9686 GCPRO1 (new_tool_bar);
9688 /* Build desired tool-bar items from keymaps. */
9689 new_tool_bar = tool_bar_items (Fcopy_sequence (f->tool_bar_items),
9690 &new_n_tool_bar);
9692 /* Redisplay the tool-bar if we changed it. */
9693 if (new_n_tool_bar != f->n_tool_bar_items
9694 || NILP (Fequal (new_tool_bar, f->tool_bar_items)))
9696 /* Redisplay that happens asynchronously due to an expose event
9697 may access f->tool_bar_items. Make sure we update both
9698 variables within BLOCK_INPUT so no such event interrupts. */
9699 BLOCK_INPUT;
9700 f->tool_bar_items = new_tool_bar;
9701 f->n_tool_bar_items = new_n_tool_bar;
9702 w->update_mode_line = Qt;
9703 UNBLOCK_INPUT;
9706 UNGCPRO;
9708 unbind_to (count, Qnil);
9709 set_buffer_internal_1 (prev);
9715 /* Set F->desired_tool_bar_string to a Lisp string representing frame
9716 F's desired tool-bar contents. F->tool_bar_items must have
9717 been set up previously by calling prepare_menu_bars. */
9719 static void
9720 build_desired_tool_bar_string (f)
9721 struct frame *f;
9723 int i, size, size_needed;
9724 struct gcpro gcpro1, gcpro2, gcpro3;
9725 Lisp_Object image, plist, props;
9727 image = plist = props = Qnil;
9728 GCPRO3 (image, plist, props);
9730 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
9731 Otherwise, make a new string. */
9733 /* The size of the string we might be able to reuse. */
9734 size = (STRINGP (f->desired_tool_bar_string)
9735 ? SCHARS (f->desired_tool_bar_string)
9736 : 0);
9738 /* We need one space in the string for each image. */
9739 size_needed = f->n_tool_bar_items;
9741 /* Reuse f->desired_tool_bar_string, if possible. */
9742 if (size < size_needed || NILP (f->desired_tool_bar_string))
9743 f->desired_tool_bar_string = Fmake_string (make_number (size_needed),
9744 make_number (' '));
9745 else
9747 props = list4 (Qdisplay, Qnil, Qmenu_item, Qnil);
9748 Fremove_text_properties (make_number (0), make_number (size),
9749 props, f->desired_tool_bar_string);
9752 /* Put a `display' property on the string for the images to display,
9753 put a `menu_item' property on tool-bar items with a value that
9754 is the index of the item in F's tool-bar item vector. */
9755 for (i = 0; i < f->n_tool_bar_items; ++i)
9757 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
9759 int enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
9760 int selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
9761 int hmargin, vmargin, relief, idx, end;
9762 extern Lisp_Object QCrelief, QCmargin, QCconversion;
9764 /* If image is a vector, choose the image according to the
9765 button state. */
9766 image = PROP (TOOL_BAR_ITEM_IMAGES);
9767 if (VECTORP (image))
9769 if (enabled_p)
9770 idx = (selected_p
9771 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
9772 : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
9773 else
9774 idx = (selected_p
9775 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
9776 : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
9778 xassert (ASIZE (image) >= idx);
9779 image = AREF (image, idx);
9781 else
9782 idx = -1;
9784 /* Ignore invalid image specifications. */
9785 if (!valid_image_p (image))
9786 continue;
9788 /* Display the tool-bar button pressed, or depressed. */
9789 plist = Fcopy_sequence (XCDR (image));
9791 /* Compute margin and relief to draw. */
9792 relief = (tool_bar_button_relief >= 0
9793 ? tool_bar_button_relief
9794 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
9795 hmargin = vmargin = relief;
9797 if (INTEGERP (Vtool_bar_button_margin)
9798 && XINT (Vtool_bar_button_margin) > 0)
9800 hmargin += XFASTINT (Vtool_bar_button_margin);
9801 vmargin += XFASTINT (Vtool_bar_button_margin);
9803 else if (CONSP (Vtool_bar_button_margin))
9805 if (INTEGERP (XCAR (Vtool_bar_button_margin))
9806 && XINT (XCAR (Vtool_bar_button_margin)) > 0)
9807 hmargin += XFASTINT (XCAR (Vtool_bar_button_margin));
9809 if (INTEGERP (XCDR (Vtool_bar_button_margin))
9810 && XINT (XCDR (Vtool_bar_button_margin)) > 0)
9811 vmargin += XFASTINT (XCDR (Vtool_bar_button_margin));
9814 if (auto_raise_tool_bar_buttons_p)
9816 /* Add a `:relief' property to the image spec if the item is
9817 selected. */
9818 if (selected_p)
9820 plist = Fplist_put (plist, QCrelief, make_number (-relief));
9821 hmargin -= relief;
9822 vmargin -= relief;
9825 else
9827 /* If image is selected, display it pressed, i.e. with a
9828 negative relief. If it's not selected, display it with a
9829 raised relief. */
9830 plist = Fplist_put (plist, QCrelief,
9831 (selected_p
9832 ? make_number (-relief)
9833 : make_number (relief)));
9834 hmargin -= relief;
9835 vmargin -= relief;
9838 /* Put a margin around the image. */
9839 if (hmargin || vmargin)
9841 if (hmargin == vmargin)
9842 plist = Fplist_put (plist, QCmargin, make_number (hmargin));
9843 else
9844 plist = Fplist_put (plist, QCmargin,
9845 Fcons (make_number (hmargin),
9846 make_number (vmargin)));
9849 /* If button is not enabled, and we don't have special images
9850 for the disabled state, make the image appear disabled by
9851 applying an appropriate algorithm to it. */
9852 if (!enabled_p && idx < 0)
9853 plist = Fplist_put (plist, QCconversion, Qdisabled);
9855 /* Put a `display' text property on the string for the image to
9856 display. Put a `menu-item' property on the string that gives
9857 the start of this item's properties in the tool-bar items
9858 vector. */
9859 image = Fcons (Qimage, plist);
9860 props = list4 (Qdisplay, image,
9861 Qmenu_item, make_number (i * TOOL_BAR_ITEM_NSLOTS));
9863 /* Let the last image hide all remaining spaces in the tool bar
9864 string. The string can be longer than needed when we reuse a
9865 previous string. */
9866 if (i + 1 == f->n_tool_bar_items)
9867 end = SCHARS (f->desired_tool_bar_string);
9868 else
9869 end = i + 1;
9870 Fadd_text_properties (make_number (i), make_number (end),
9871 props, f->desired_tool_bar_string);
9872 #undef PROP
9875 UNGCPRO;
9879 /* Display one line of the tool-bar of frame IT->f.
9881 HEIGHT specifies the desired height of the tool-bar line.
9882 If the actual height of the glyph row is less than HEIGHT, the
9883 row's height is increased to HEIGHT, and the icons are centered
9884 vertically in the new height.
9886 If HEIGHT is -1, we are counting needed tool-bar lines, so don't
9887 count a final empty row in case the tool-bar width exactly matches
9888 the window width.
9891 static void
9892 display_tool_bar_line (it, height)
9893 struct it *it;
9894 int height;
9896 struct glyph_row *row = it->glyph_row;
9897 int max_x = it->last_visible_x;
9898 struct glyph *last;
9900 prepare_desired_row (row);
9901 row->y = it->current_y;
9903 /* Note that this isn't made use of if the face hasn't a box,
9904 so there's no need to check the face here. */
9905 it->start_of_box_run_p = 1;
9907 while (it->current_x < max_x)
9909 int x, n_glyphs_before, i, nglyphs;
9910 struct it it_before;
9912 /* Get the next display element. */
9913 if (!get_next_display_element (it))
9915 /* Don't count empty row if we are counting needed tool-bar lines. */
9916 if (height < 0 && !it->hpos)
9917 return;
9918 break;
9921 /* Produce glyphs. */
9922 n_glyphs_before = row->used[TEXT_AREA];
9923 it_before = *it;
9925 PRODUCE_GLYPHS (it);
9927 nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
9928 i = 0;
9929 x = it_before.current_x;
9930 while (i < nglyphs)
9932 struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
9934 if (x + glyph->pixel_width > max_x)
9936 /* Glyph doesn't fit on line. Backtrack. */
9937 row->used[TEXT_AREA] = n_glyphs_before;
9938 *it = it_before;
9939 /* If this is the only glyph on this line, it will never fit on the
9940 toolbar, so skip it. But ensure there is at least one glyph,
9941 so we don't accidentally disable the tool-bar. */
9942 if (n_glyphs_before == 0
9943 && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
9944 break;
9945 goto out;
9948 ++it->hpos;
9949 x += glyph->pixel_width;
9950 ++i;
9953 /* Stop at line ends. */
9954 if (ITERATOR_AT_END_OF_LINE_P (it))
9955 break;
9957 set_iterator_to_next (it, 1);
9960 out:;
9962 row->displays_text_p = row->used[TEXT_AREA] != 0;
9964 /* Use default face for the border below the tool bar.
9966 FIXME: When auto-resize-tool-bars is grow-only, there is
9967 no additional border below the possibly empty tool-bar lines.
9968 So to make the extra empty lines look "normal", we have to
9969 use the tool-bar face for the border too. */
9970 if (!row->displays_text_p && !EQ (Vauto_resize_tool_bars, Qgrow_only))
9971 it->face_id = DEFAULT_FACE_ID;
9973 extend_face_to_end_of_line (it);
9974 last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
9975 last->right_box_line_p = 1;
9976 if (last == row->glyphs[TEXT_AREA])
9977 last->left_box_line_p = 1;
9979 /* Make line the desired height and center it vertically. */
9980 if ((height -= it->max_ascent + it->max_descent) > 0)
9982 /* Don't add more than one line height. */
9983 height %= FRAME_LINE_HEIGHT (it->f);
9984 it->max_ascent += height / 2;
9985 it->max_descent += (height + 1) / 2;
9988 compute_line_metrics (it);
9990 /* If line is empty, make it occupy the rest of the tool-bar. */
9991 if (!row->displays_text_p)
9993 row->height = row->phys_height = it->last_visible_y - row->y;
9994 row->visible_height = row->height;
9995 row->ascent = row->phys_ascent = 0;
9996 row->extra_line_spacing = 0;
9999 row->full_width_p = 1;
10000 row->continued_p = 0;
10001 row->truncated_on_left_p = 0;
10002 row->truncated_on_right_p = 0;
10004 it->current_x = it->hpos = 0;
10005 it->current_y += row->height;
10006 ++it->vpos;
10007 ++it->glyph_row;
10011 /* Max tool-bar height. */
10013 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
10014 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
10016 /* Value is the number of screen lines needed to make all tool-bar
10017 items of frame F visible. The number of actual rows needed is
10018 returned in *N_ROWS if non-NULL. */
10020 static int
10021 tool_bar_lines_needed (f, n_rows)
10022 struct frame *f;
10023 int *n_rows;
10025 struct window *w = XWINDOW (f->tool_bar_window);
10026 struct it it;
10027 /* tool_bar_lines_needed is called from redisplay_tool_bar after building
10028 the desired matrix, so use (unused) mode-line row as temporary row to
10029 avoid destroying the first tool-bar row. */
10030 struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
10032 /* Initialize an iterator for iteration over
10033 F->desired_tool_bar_string in the tool-bar window of frame F. */
10034 init_iterator (&it, w, -1, -1, temp_row, TOOL_BAR_FACE_ID);
10035 it.first_visible_x = 0;
10036 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
10037 reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
10039 while (!ITERATOR_AT_END_P (&it))
10041 clear_glyph_row (temp_row);
10042 it.glyph_row = temp_row;
10043 display_tool_bar_line (&it, -1);
10045 clear_glyph_row (temp_row);
10047 /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar. */
10048 if (n_rows)
10049 *n_rows = it.vpos > 0 ? it.vpos : -1;
10051 return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
10055 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed, Stool_bar_lines_needed,
10056 0, 1, 0,
10057 doc: /* Return the number of lines occupied by the tool bar of FRAME. */)
10058 (frame)
10059 Lisp_Object frame;
10061 struct frame *f;
10062 struct window *w;
10063 int nlines = 0;
10065 if (NILP (frame))
10066 frame = selected_frame;
10067 else
10068 CHECK_FRAME (frame);
10069 f = XFRAME (frame);
10071 if (WINDOWP (f->tool_bar_window)
10072 || (w = XWINDOW (f->tool_bar_window),
10073 WINDOW_TOTAL_LINES (w) > 0))
10075 update_tool_bar (f, 1);
10076 if (f->n_tool_bar_items)
10078 build_desired_tool_bar_string (f);
10079 nlines = tool_bar_lines_needed (f, NULL);
10083 return make_number (nlines);
10087 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
10088 height should be changed. */
10090 static int
10091 redisplay_tool_bar (f)
10092 struct frame *f;
10094 struct window *w;
10095 struct it it;
10096 struct glyph_row *row;
10098 #if defined (USE_GTK) || USE_MAC_TOOLBAR
10099 if (FRAME_EXTERNAL_TOOL_BAR (f))
10100 update_frame_tool_bar (f);
10101 return 0;
10102 #endif
10104 /* If frame hasn't a tool-bar window or if it is zero-height, don't
10105 do anything. This means you must start with tool-bar-lines
10106 non-zero to get the auto-sizing effect. Or in other words, you
10107 can turn off tool-bars by specifying tool-bar-lines zero. */
10108 if (!WINDOWP (f->tool_bar_window)
10109 || (w = XWINDOW (f->tool_bar_window),
10110 WINDOW_TOTAL_LINES (w) == 0))
10111 return 0;
10113 /* Set up an iterator for the tool-bar window. */
10114 init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
10115 it.first_visible_x = 0;
10116 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
10117 row = it.glyph_row;
10119 /* Build a string that represents the contents of the tool-bar. */
10120 build_desired_tool_bar_string (f);
10121 reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
10123 if (f->n_tool_bar_rows == 0)
10125 int nlines;
10127 if ((nlines = tool_bar_lines_needed (f, &f->n_tool_bar_rows),
10128 nlines != WINDOW_TOTAL_LINES (w)))
10130 extern Lisp_Object Qtool_bar_lines;
10131 Lisp_Object frame;
10132 int old_height = WINDOW_TOTAL_LINES (w);
10134 XSETFRAME (frame, f);
10135 Fmodify_frame_parameters (frame,
10136 Fcons (Fcons (Qtool_bar_lines,
10137 make_number (nlines)),
10138 Qnil));
10139 if (WINDOW_TOTAL_LINES (w) != old_height)
10141 clear_glyph_matrix (w->desired_matrix);
10142 fonts_changed_p = 1;
10143 return 1;
10148 /* Display as many lines as needed to display all tool-bar items. */
10150 if (f->n_tool_bar_rows > 0)
10152 int border, rows, height, extra;
10154 if (INTEGERP (Vtool_bar_border))
10155 border = XINT (Vtool_bar_border);
10156 else if (EQ (Vtool_bar_border, Qinternal_border_width))
10157 border = FRAME_INTERNAL_BORDER_WIDTH (f);
10158 else if (EQ (Vtool_bar_border, Qborder_width))
10159 border = f->border_width;
10160 else
10161 border = 0;
10162 if (border < 0)
10163 border = 0;
10165 rows = f->n_tool_bar_rows;
10166 height = max (1, (it.last_visible_y - border) / rows);
10167 extra = it.last_visible_y - border - height * rows;
10169 while (it.current_y < it.last_visible_y)
10171 int h = 0;
10172 if (extra > 0 && rows-- > 0)
10174 h = (extra + rows - 1) / rows;
10175 extra -= h;
10177 display_tool_bar_line (&it, height + h);
10180 else
10182 while (it.current_y < it.last_visible_y)
10183 display_tool_bar_line (&it, 0);
10186 /* It doesn't make much sense to try scrolling in the tool-bar
10187 window, so don't do it. */
10188 w->desired_matrix->no_scrolling_p = 1;
10189 w->must_be_updated_p = 1;
10191 if (!NILP (Vauto_resize_tool_bars))
10193 int max_tool_bar_height = MAX_FRAME_TOOL_BAR_HEIGHT (f);
10194 int change_height_p = 0;
10196 /* If we couldn't display everything, change the tool-bar's
10197 height if there is room for more. */
10198 if (IT_STRING_CHARPOS (it) < it.end_charpos
10199 && it.current_y < max_tool_bar_height)
10200 change_height_p = 1;
10202 row = it.glyph_row - 1;
10204 /* If there are blank lines at the end, except for a partially
10205 visible blank line at the end that is smaller than
10206 FRAME_LINE_HEIGHT, change the tool-bar's height. */
10207 if (!row->displays_text_p
10208 && row->height >= FRAME_LINE_HEIGHT (f))
10209 change_height_p = 1;
10211 /* If row displays tool-bar items, but is partially visible,
10212 change the tool-bar's height. */
10213 if (row->displays_text_p
10214 && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y
10215 && MATRIX_ROW_BOTTOM_Y (row) < max_tool_bar_height)
10216 change_height_p = 1;
10218 /* Resize windows as needed by changing the `tool-bar-lines'
10219 frame parameter. */
10220 if (change_height_p)
10222 extern Lisp_Object Qtool_bar_lines;
10223 Lisp_Object frame;
10224 int old_height = WINDOW_TOTAL_LINES (w);
10225 int nrows;
10226 int nlines = tool_bar_lines_needed (f, &nrows);
10228 change_height_p = ((EQ (Vauto_resize_tool_bars, Qgrow_only)
10229 && !f->minimize_tool_bar_window_p)
10230 ? (nlines > old_height)
10231 : (nlines != old_height));
10232 f->minimize_tool_bar_window_p = 0;
10234 if (change_height_p)
10236 XSETFRAME (frame, f);
10237 Fmodify_frame_parameters (frame,
10238 Fcons (Fcons (Qtool_bar_lines,
10239 make_number (nlines)),
10240 Qnil));
10241 if (WINDOW_TOTAL_LINES (w) != old_height)
10243 clear_glyph_matrix (w->desired_matrix);
10244 f->n_tool_bar_rows = nrows;
10245 fonts_changed_p = 1;
10246 return 1;
10252 f->minimize_tool_bar_window_p = 0;
10253 return 0;
10257 /* Get information about the tool-bar item which is displayed in GLYPH
10258 on frame F. Return in *PROP_IDX the index where tool-bar item
10259 properties start in F->tool_bar_items. Value is zero if
10260 GLYPH doesn't display a tool-bar item. */
10262 static int
10263 tool_bar_item_info (f, glyph, prop_idx)
10264 struct frame *f;
10265 struct glyph *glyph;
10266 int *prop_idx;
10268 Lisp_Object prop;
10269 int success_p;
10270 int charpos;
10272 /* This function can be called asynchronously, which means we must
10273 exclude any possibility that Fget_text_property signals an
10274 error. */
10275 charpos = min (SCHARS (f->current_tool_bar_string), glyph->charpos);
10276 charpos = max (0, charpos);
10278 /* Get the text property `menu-item' at pos. The value of that
10279 property is the start index of this item's properties in
10280 F->tool_bar_items. */
10281 prop = Fget_text_property (make_number (charpos),
10282 Qmenu_item, f->current_tool_bar_string);
10283 if (INTEGERP (prop))
10285 *prop_idx = XINT (prop);
10286 success_p = 1;
10288 else
10289 success_p = 0;
10291 return success_p;
10295 /* Get information about the tool-bar item at position X/Y on frame F.
10296 Return in *GLYPH a pointer to the glyph of the tool-bar item in
10297 the current matrix of the tool-bar window of F, or NULL if not
10298 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
10299 item in F->tool_bar_items. Value is
10301 -1 if X/Y is not on a tool-bar item
10302 0 if X/Y is on the same item that was highlighted before.
10303 1 otherwise. */
10305 static int
10306 get_tool_bar_item (f, x, y, glyph, hpos, vpos, prop_idx)
10307 struct frame *f;
10308 int x, y;
10309 struct glyph **glyph;
10310 int *hpos, *vpos, *prop_idx;
10312 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
10313 struct window *w = XWINDOW (f->tool_bar_window);
10314 int area;
10316 /* Find the glyph under X/Y. */
10317 *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
10318 if (*glyph == NULL)
10319 return -1;
10321 /* Get the start of this tool-bar item's properties in
10322 f->tool_bar_items. */
10323 if (!tool_bar_item_info (f, *glyph, prop_idx))
10324 return -1;
10326 /* Is mouse on the highlighted item? */
10327 if (EQ (f->tool_bar_window, dpyinfo->mouse_face_window)
10328 && *vpos >= dpyinfo->mouse_face_beg_row
10329 && *vpos <= dpyinfo->mouse_face_end_row
10330 && (*vpos > dpyinfo->mouse_face_beg_row
10331 || *hpos >= dpyinfo->mouse_face_beg_col)
10332 && (*vpos < dpyinfo->mouse_face_end_row
10333 || *hpos < dpyinfo->mouse_face_end_col
10334 || dpyinfo->mouse_face_past_end))
10335 return 0;
10337 return 1;
10341 /* EXPORT:
10342 Handle mouse button event on the tool-bar of frame F, at
10343 frame-relative coordinates X/Y. DOWN_P is 1 for a button press,
10344 0 for button release. MODIFIERS is event modifiers for button
10345 release. */
10347 void
10348 handle_tool_bar_click (f, x, y, down_p, modifiers)
10349 struct frame *f;
10350 int x, y, down_p;
10351 unsigned int modifiers;
10353 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
10354 struct window *w = XWINDOW (f->tool_bar_window);
10355 int hpos, vpos, prop_idx;
10356 struct glyph *glyph;
10357 Lisp_Object enabled_p;
10359 /* If not on the highlighted tool-bar item, return. */
10360 frame_to_window_pixel_xy (w, &x, &y);
10361 if (get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
10362 return;
10364 /* If item is disabled, do nothing. */
10365 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
10366 if (NILP (enabled_p))
10367 return;
10369 if (down_p)
10371 /* Show item in pressed state. */
10372 show_mouse_face (dpyinfo, DRAW_IMAGE_SUNKEN);
10373 dpyinfo->mouse_face_image_state = DRAW_IMAGE_SUNKEN;
10374 last_tool_bar_item = prop_idx;
10376 else
10378 Lisp_Object key, frame;
10379 struct input_event event;
10380 EVENT_INIT (event);
10382 /* Show item in released state. */
10383 show_mouse_face (dpyinfo, DRAW_IMAGE_RAISED);
10384 dpyinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
10386 key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
10388 XSETFRAME (frame, f);
10389 event.kind = TOOL_BAR_EVENT;
10390 event.frame_or_window = frame;
10391 event.arg = frame;
10392 kbd_buffer_store_event (&event);
10394 event.kind = TOOL_BAR_EVENT;
10395 event.frame_or_window = frame;
10396 event.arg = key;
10397 event.modifiers = modifiers;
10398 kbd_buffer_store_event (&event);
10399 last_tool_bar_item = -1;
10404 /* Possibly highlight a tool-bar item on frame F when mouse moves to
10405 tool-bar window-relative coordinates X/Y. Called from
10406 note_mouse_highlight. */
10408 static void
10409 note_tool_bar_highlight (f, x, y)
10410 struct frame *f;
10411 int x, y;
10413 Lisp_Object window = f->tool_bar_window;
10414 struct window *w = XWINDOW (window);
10415 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
10416 int hpos, vpos;
10417 struct glyph *glyph;
10418 struct glyph_row *row;
10419 int i;
10420 Lisp_Object enabled_p;
10421 int prop_idx;
10422 enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
10423 int mouse_down_p, rc;
10425 /* Function note_mouse_highlight is called with negative x(y
10426 values when mouse moves outside of the frame. */
10427 if (x <= 0 || y <= 0)
10429 clear_mouse_face (dpyinfo);
10430 return;
10433 rc = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
10434 if (rc < 0)
10436 /* Not on tool-bar item. */
10437 clear_mouse_face (dpyinfo);
10438 return;
10440 else if (rc == 0)
10441 /* On same tool-bar item as before. */
10442 goto set_help_echo;
10444 clear_mouse_face (dpyinfo);
10446 /* Mouse is down, but on different tool-bar item? */
10447 mouse_down_p = (dpyinfo->grabbed
10448 && f == last_mouse_frame
10449 && FRAME_LIVE_P (f));
10450 if (mouse_down_p
10451 && last_tool_bar_item != prop_idx)
10452 return;
10454 dpyinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
10455 draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
10457 /* If tool-bar item is not enabled, don't highlight it. */
10458 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
10459 if (!NILP (enabled_p))
10461 /* Compute the x-position of the glyph. In front and past the
10462 image is a space. We include this in the highlighted area. */
10463 row = MATRIX_ROW (w->current_matrix, vpos);
10464 for (i = x = 0; i < hpos; ++i)
10465 x += row->glyphs[TEXT_AREA][i].pixel_width;
10467 /* Record this as the current active region. */
10468 dpyinfo->mouse_face_beg_col = hpos;
10469 dpyinfo->mouse_face_beg_row = vpos;
10470 dpyinfo->mouse_face_beg_x = x;
10471 dpyinfo->mouse_face_beg_y = row->y;
10472 dpyinfo->mouse_face_past_end = 0;
10474 dpyinfo->mouse_face_end_col = hpos + 1;
10475 dpyinfo->mouse_face_end_row = vpos;
10476 dpyinfo->mouse_face_end_x = x + glyph->pixel_width;
10477 dpyinfo->mouse_face_end_y = row->y;
10478 dpyinfo->mouse_face_window = window;
10479 dpyinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
10481 /* Display it as active. */
10482 show_mouse_face (dpyinfo, draw);
10483 dpyinfo->mouse_face_image_state = draw;
10486 set_help_echo:
10488 /* Set help_echo_string to a help string to display for this tool-bar item.
10489 XTread_socket does the rest. */
10490 help_echo_object = help_echo_window = Qnil;
10491 help_echo_pos = -1;
10492 help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
10493 if (NILP (help_echo_string))
10494 help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
10497 #endif /* HAVE_WINDOW_SYSTEM */
10501 /************************************************************************
10502 Horizontal scrolling
10503 ************************************************************************/
10505 static int hscroll_window_tree P_ ((Lisp_Object));
10506 static int hscroll_windows P_ ((Lisp_Object));
10508 /* For all leaf windows in the window tree rooted at WINDOW, set their
10509 hscroll value so that PT is (i) visible in the window, and (ii) so
10510 that it is not within a certain margin at the window's left and
10511 right border. Value is non-zero if any window's hscroll has been
10512 changed. */
10514 static int
10515 hscroll_window_tree (window)
10516 Lisp_Object window;
10518 int hscrolled_p = 0;
10519 int hscroll_relative_p = FLOATP (Vhscroll_step);
10520 int hscroll_step_abs = 0;
10521 double hscroll_step_rel = 0;
10523 if (hscroll_relative_p)
10525 hscroll_step_rel = XFLOAT_DATA (Vhscroll_step);
10526 if (hscroll_step_rel < 0)
10528 hscroll_relative_p = 0;
10529 hscroll_step_abs = 0;
10532 else if (INTEGERP (Vhscroll_step))
10534 hscroll_step_abs = XINT (Vhscroll_step);
10535 if (hscroll_step_abs < 0)
10536 hscroll_step_abs = 0;
10538 else
10539 hscroll_step_abs = 0;
10541 while (WINDOWP (window))
10543 struct window *w = XWINDOW (window);
10545 if (WINDOWP (w->hchild))
10546 hscrolled_p |= hscroll_window_tree (w->hchild);
10547 else if (WINDOWP (w->vchild))
10548 hscrolled_p |= hscroll_window_tree (w->vchild);
10549 else if (w->cursor.vpos >= 0)
10551 int h_margin;
10552 int text_area_width;
10553 struct glyph_row *current_cursor_row
10554 = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
10555 struct glyph_row *desired_cursor_row
10556 = MATRIX_ROW (w->desired_matrix, w->cursor.vpos);
10557 struct glyph_row *cursor_row
10558 = (desired_cursor_row->enabled_p
10559 ? desired_cursor_row
10560 : current_cursor_row);
10562 text_area_width = window_box_width (w, TEXT_AREA);
10564 /* Scroll when cursor is inside this scroll margin. */
10565 h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
10567 if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->buffer))
10568 && ((XFASTINT (w->hscroll)
10569 && w->cursor.x <= h_margin)
10570 || (cursor_row->enabled_p
10571 && cursor_row->truncated_on_right_p
10572 && (w->cursor.x >= text_area_width - h_margin))))
10574 struct it it;
10575 int hscroll;
10576 struct buffer *saved_current_buffer;
10577 int pt;
10578 int wanted_x;
10580 /* Find point in a display of infinite width. */
10581 saved_current_buffer = current_buffer;
10582 current_buffer = XBUFFER (w->buffer);
10584 if (w == XWINDOW (selected_window))
10585 pt = BUF_PT (current_buffer);
10586 else
10588 pt = marker_position (w->pointm);
10589 pt = max (BEGV, pt);
10590 pt = min (ZV, pt);
10593 /* Move iterator to pt starting at cursor_row->start in
10594 a line with infinite width. */
10595 init_to_row_start (&it, w, cursor_row);
10596 it.last_visible_x = INFINITY;
10597 move_it_in_display_line_to (&it, pt, -1, MOVE_TO_POS);
10598 current_buffer = saved_current_buffer;
10600 /* Position cursor in window. */
10601 if (!hscroll_relative_p && hscroll_step_abs == 0)
10602 hscroll = max (0, (it.current_x
10603 - (ITERATOR_AT_END_OF_LINE_P (&it)
10604 ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
10605 : (text_area_width / 2))))
10606 / FRAME_COLUMN_WIDTH (it.f);
10607 else if (w->cursor.x >= text_area_width - h_margin)
10609 if (hscroll_relative_p)
10610 wanted_x = text_area_width * (1 - hscroll_step_rel)
10611 - h_margin;
10612 else
10613 wanted_x = text_area_width
10614 - hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
10615 - h_margin;
10616 hscroll
10617 = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
10619 else
10621 if (hscroll_relative_p)
10622 wanted_x = text_area_width * hscroll_step_rel
10623 + h_margin;
10624 else
10625 wanted_x = hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
10626 + h_margin;
10627 hscroll
10628 = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
10630 hscroll = max (hscroll, XFASTINT (w->min_hscroll));
10632 /* Don't call Fset_window_hscroll if value hasn't
10633 changed because it will prevent redisplay
10634 optimizations. */
10635 if (XFASTINT (w->hscroll) != hscroll)
10637 XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
10638 w->hscroll = make_number (hscroll);
10639 hscrolled_p = 1;
10644 window = w->next;
10647 /* Value is non-zero if hscroll of any leaf window has been changed. */
10648 return hscrolled_p;
10652 /* Set hscroll so that cursor is visible and not inside horizontal
10653 scroll margins for all windows in the tree rooted at WINDOW. See
10654 also hscroll_window_tree above. Value is non-zero if any window's
10655 hscroll has been changed. If it has, desired matrices on the frame
10656 of WINDOW are cleared. */
10658 static int
10659 hscroll_windows (window)
10660 Lisp_Object window;
10662 int hscrolled_p = hscroll_window_tree (window);
10663 if (hscrolled_p)
10664 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window))));
10665 return hscrolled_p;
10670 /************************************************************************
10671 Redisplay
10672 ************************************************************************/
10674 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
10675 to a non-zero value. This is sometimes handy to have in a debugger
10676 session. */
10678 #if GLYPH_DEBUG
10680 /* First and last unchanged row for try_window_id. */
10682 int debug_first_unchanged_at_end_vpos;
10683 int debug_last_unchanged_at_beg_vpos;
10685 /* Delta vpos and y. */
10687 int debug_dvpos, debug_dy;
10689 /* Delta in characters and bytes for try_window_id. */
10691 int debug_delta, debug_delta_bytes;
10693 /* Values of window_end_pos and window_end_vpos at the end of
10694 try_window_id. */
10696 EMACS_INT debug_end_pos, debug_end_vpos;
10698 /* Append a string to W->desired_matrix->method. FMT is a printf
10699 format string. A1...A9 are a supplement for a variable-length
10700 argument list. If trace_redisplay_p is non-zero also printf the
10701 resulting string to stderr. */
10703 static void
10704 debug_method_add (w, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
10705 struct window *w;
10706 char *fmt;
10707 int a1, a2, a3, a4, a5, a6, a7, a8, a9;
10709 char buffer[512];
10710 char *method = w->desired_matrix->method;
10711 int len = strlen (method);
10712 int size = sizeof w->desired_matrix->method;
10713 int remaining = size - len - 1;
10715 sprintf (buffer, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9);
10716 if (len && remaining)
10718 method[len] = '|';
10719 --remaining, ++len;
10722 strncpy (method + len, buffer, remaining);
10724 if (trace_redisplay_p)
10725 fprintf (stderr, "%p (%s): %s\n",
10727 ((BUFFERP (w->buffer)
10728 && STRINGP (XBUFFER (w->buffer)->name))
10729 ? (char *) SDATA (XBUFFER (w->buffer)->name)
10730 : "no buffer"),
10731 buffer);
10734 #endif /* GLYPH_DEBUG */
10737 /* Value is non-zero if all changes in window W, which displays
10738 current_buffer, are in the text between START and END. START is a
10739 buffer position, END is given as a distance from Z. Used in
10740 redisplay_internal for display optimization. */
10742 static INLINE int
10743 text_outside_line_unchanged_p (w, start, end)
10744 struct window *w;
10745 int start, end;
10747 int unchanged_p = 1;
10749 /* If text or overlays have changed, see where. */
10750 if (XFASTINT (w->last_modified) < MODIFF
10751 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF)
10753 /* Gap in the line? */
10754 if (GPT < start || Z - GPT < end)
10755 unchanged_p = 0;
10757 /* Changes start in front of the line, or end after it? */
10758 if (unchanged_p
10759 && (BEG_UNCHANGED < start - 1
10760 || END_UNCHANGED < end))
10761 unchanged_p = 0;
10763 /* If selective display, can't optimize if changes start at the
10764 beginning of the line. */
10765 if (unchanged_p
10766 && INTEGERP (current_buffer->selective_display)
10767 && XINT (current_buffer->selective_display) > 0
10768 && (BEG_UNCHANGED < start || GPT <= start))
10769 unchanged_p = 0;
10771 /* If there are overlays at the start or end of the line, these
10772 may have overlay strings with newlines in them. A change at
10773 START, for instance, may actually concern the display of such
10774 overlay strings as well, and they are displayed on different
10775 lines. So, quickly rule out this case. (For the future, it
10776 might be desirable to implement something more telling than
10777 just BEG/END_UNCHANGED.) */
10778 if (unchanged_p)
10780 if (BEG + BEG_UNCHANGED == start
10781 && overlay_touches_p (start))
10782 unchanged_p = 0;
10783 if (END_UNCHANGED == end
10784 && overlay_touches_p (Z - end))
10785 unchanged_p = 0;
10789 return unchanged_p;
10793 /* Do a frame update, taking possible shortcuts into account. This is
10794 the main external entry point for redisplay.
10796 If the last redisplay displayed an echo area message and that message
10797 is no longer requested, we clear the echo area or bring back the
10798 mini-buffer if that is in use. */
10800 void
10801 redisplay ()
10803 redisplay_internal (0);
10807 static Lisp_Object
10808 overlay_arrow_string_or_property (var)
10809 Lisp_Object var;
10811 Lisp_Object val;
10813 if (val = Fget (var, Qoverlay_arrow_string), STRINGP (val))
10814 return val;
10816 return Voverlay_arrow_string;
10819 /* Return 1 if there are any overlay-arrows in current_buffer. */
10820 static int
10821 overlay_arrow_in_current_buffer_p ()
10823 Lisp_Object vlist;
10825 for (vlist = Voverlay_arrow_variable_list;
10826 CONSP (vlist);
10827 vlist = XCDR (vlist))
10829 Lisp_Object var = XCAR (vlist);
10830 Lisp_Object val;
10832 if (!SYMBOLP (var))
10833 continue;
10834 val = find_symbol_value (var);
10835 if (MARKERP (val)
10836 && current_buffer == XMARKER (val)->buffer)
10837 return 1;
10839 return 0;
10843 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
10844 has changed. */
10846 static int
10847 overlay_arrows_changed_p ()
10849 Lisp_Object vlist;
10851 for (vlist = Voverlay_arrow_variable_list;
10852 CONSP (vlist);
10853 vlist = XCDR (vlist))
10855 Lisp_Object var = XCAR (vlist);
10856 Lisp_Object val, pstr;
10858 if (!SYMBOLP (var))
10859 continue;
10860 val = find_symbol_value (var);
10861 if (!MARKERP (val))
10862 continue;
10863 if (! EQ (COERCE_MARKER (val),
10864 Fget (var, Qlast_arrow_position))
10865 || ! (pstr = overlay_arrow_string_or_property (var),
10866 EQ (pstr, Fget (var, Qlast_arrow_string))))
10867 return 1;
10869 return 0;
10872 /* Mark overlay arrows to be updated on next redisplay. */
10874 static void
10875 update_overlay_arrows (up_to_date)
10876 int up_to_date;
10878 Lisp_Object vlist;
10880 for (vlist = Voverlay_arrow_variable_list;
10881 CONSP (vlist);
10882 vlist = XCDR (vlist))
10884 Lisp_Object var = XCAR (vlist);
10886 if (!SYMBOLP (var))
10887 continue;
10889 if (up_to_date > 0)
10891 Lisp_Object val = find_symbol_value (var);
10892 Fput (var, Qlast_arrow_position,
10893 COERCE_MARKER (val));
10894 Fput (var, Qlast_arrow_string,
10895 overlay_arrow_string_or_property (var));
10897 else if (up_to_date < 0
10898 || !NILP (Fget (var, Qlast_arrow_position)))
10900 Fput (var, Qlast_arrow_position, Qt);
10901 Fput (var, Qlast_arrow_string, Qt);
10907 /* Return overlay arrow string to display at row.
10908 Return integer (bitmap number) for arrow bitmap in left fringe.
10909 Return nil if no overlay arrow. */
10911 static Lisp_Object
10912 overlay_arrow_at_row (it, row)
10913 struct it *it;
10914 struct glyph_row *row;
10916 Lisp_Object vlist;
10918 for (vlist = Voverlay_arrow_variable_list;
10919 CONSP (vlist);
10920 vlist = XCDR (vlist))
10922 Lisp_Object var = XCAR (vlist);
10923 Lisp_Object val;
10925 if (!SYMBOLP (var))
10926 continue;
10928 val = find_symbol_value (var);
10930 if (MARKERP (val)
10931 && current_buffer == XMARKER (val)->buffer
10932 && (MATRIX_ROW_START_CHARPOS (row) == marker_position (val)))
10934 if (FRAME_WINDOW_P (it->f)
10935 && WINDOW_LEFT_FRINGE_WIDTH (it->w) > 0)
10937 #ifdef HAVE_WINDOW_SYSTEM
10938 if (val = Fget (var, Qoverlay_arrow_bitmap), SYMBOLP (val))
10940 int fringe_bitmap;
10941 if ((fringe_bitmap = lookup_fringe_bitmap (val)) != 0)
10942 return make_number (fringe_bitmap);
10944 #endif
10945 return make_number (-1); /* Use default arrow bitmap */
10947 return overlay_arrow_string_or_property (var);
10951 return Qnil;
10954 /* Return 1 if point moved out of or into a composition. Otherwise
10955 return 0. PREV_BUF and PREV_PT are the last point buffer and
10956 position. BUF and PT are the current point buffer and position. */
10959 check_point_in_composition (prev_buf, prev_pt, buf, pt)
10960 struct buffer *prev_buf, *buf;
10961 int prev_pt, pt;
10963 EMACS_INT start, end;
10964 Lisp_Object prop;
10965 Lisp_Object buffer;
10967 XSETBUFFER (buffer, buf);
10968 /* Check a composition at the last point if point moved within the
10969 same buffer. */
10970 if (prev_buf == buf)
10972 if (prev_pt == pt)
10973 /* Point didn't move. */
10974 return 0;
10976 if (prev_pt > BUF_BEGV (buf) && prev_pt < BUF_ZV (buf)
10977 && find_composition (prev_pt, -1, &start, &end, &prop, buffer)
10978 && COMPOSITION_VALID_P (start, end, prop)
10979 && start < prev_pt && end > prev_pt)
10980 /* The last point was within the composition. Return 1 iff
10981 point moved out of the composition. */
10982 return (pt <= start || pt >= end);
10985 /* Check a composition at the current point. */
10986 return (pt > BUF_BEGV (buf) && pt < BUF_ZV (buf)
10987 && find_composition (pt, -1, &start, &end, &prop, buffer)
10988 && COMPOSITION_VALID_P (start, end, prop)
10989 && start < pt && end > pt);
10993 /* Reconsider the setting of B->clip_changed which is displayed
10994 in window W. */
10996 static INLINE void
10997 reconsider_clip_changes (w, b)
10998 struct window *w;
10999 struct buffer *b;
11001 if (b->clip_changed
11002 && !NILP (w->window_end_valid)
11003 && w->current_matrix->buffer == b
11004 && w->current_matrix->zv == BUF_ZV (b)
11005 && w->current_matrix->begv == BUF_BEGV (b))
11006 b->clip_changed = 0;
11008 /* If display wasn't paused, and W is not a tool bar window, see if
11009 point has been moved into or out of a composition. In that case,
11010 we set b->clip_changed to 1 to force updating the screen. If
11011 b->clip_changed has already been set to 1, we can skip this
11012 check. */
11013 if (!b->clip_changed
11014 && BUFFERP (w->buffer) && !NILP (w->window_end_valid))
11016 int pt;
11018 if (w == XWINDOW (selected_window))
11019 pt = BUF_PT (current_buffer);
11020 else
11021 pt = marker_position (w->pointm);
11023 if ((w->current_matrix->buffer != XBUFFER (w->buffer)
11024 || pt != XINT (w->last_point))
11025 && check_point_in_composition (w->current_matrix->buffer,
11026 XINT (w->last_point),
11027 XBUFFER (w->buffer), pt))
11028 b->clip_changed = 1;
11033 /* Select FRAME to forward the values of frame-local variables into C
11034 variables so that the redisplay routines can access those values
11035 directly. */
11037 static void
11038 select_frame_for_redisplay (frame)
11039 Lisp_Object frame;
11041 Lisp_Object tail, sym, val;
11042 Lisp_Object old = selected_frame;
11044 xassert (FRAMEP (frame) && FRAME_LIVE_P (XFRAME (frame)));
11046 selected_frame = frame;
11050 for (tail = XFRAME (frame)->param_alist; CONSP (tail); tail = XCDR (tail))
11051 if (CONSP (XCAR (tail))
11052 && (sym = XCAR (XCAR (tail)),
11053 SYMBOLP (sym))
11054 && (sym = indirect_variable (sym),
11055 val = SYMBOL_VALUE (sym),
11056 (BUFFER_LOCAL_VALUEP (val)))
11057 && XBUFFER_LOCAL_VALUE (val)->check_frame)
11058 /* Use find_symbol_value rather than Fsymbol_value
11059 to avoid an error if it is void. */
11060 find_symbol_value (sym);
11061 } while (!EQ (frame, old) && (frame = old, 1));
11065 #define STOP_POLLING \
11066 do { if (! polling_stopped_here) stop_polling (); \
11067 polling_stopped_here = 1; } while (0)
11069 #define RESUME_POLLING \
11070 do { if (polling_stopped_here) start_polling (); \
11071 polling_stopped_here = 0; } while (0)
11074 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay is not in
11075 response to any user action; therefore, we should preserve the echo
11076 area. (Actually, our caller does that job.) Perhaps in the future
11077 avoid recentering windows if it is not necessary; currently that
11078 causes some problems. */
11080 static void
11081 redisplay_internal (preserve_echo_area)
11082 int preserve_echo_area;
11084 struct window *w = XWINDOW (selected_window);
11085 struct frame *f;
11086 int pause;
11087 int must_finish = 0;
11088 struct text_pos tlbufpos, tlendpos;
11089 int number_of_visible_frames;
11090 int count, count1;
11091 struct frame *sf;
11092 int polling_stopped_here = 0;
11093 Lisp_Object old_frame = selected_frame;
11095 /* Non-zero means redisplay has to consider all windows on all
11096 frames. Zero means, only selected_window is considered. */
11097 int consider_all_windows_p;
11099 TRACE ((stderr, "redisplay_internal %d\n", redisplaying_p));
11101 /* No redisplay if running in batch mode or frame is not yet fully
11102 initialized, or redisplay is explicitly turned off by setting
11103 Vinhibit_redisplay. */
11104 if (noninteractive
11105 || !NILP (Vinhibit_redisplay))
11106 return;
11108 /* Don't examine these until after testing Vinhibit_redisplay.
11109 When Emacs is shutting down, perhaps because its connection to
11110 X has dropped, we should not look at them at all. */
11111 f = XFRAME (w->frame);
11112 sf = SELECTED_FRAME ();
11114 if (!f->glyphs_initialized_p)
11115 return;
11117 /* The flag redisplay_performed_directly_p is set by
11118 direct_output_for_insert when it already did the whole screen
11119 update necessary. */
11120 if (redisplay_performed_directly_p)
11122 redisplay_performed_directly_p = 0;
11123 if (!hscroll_windows (selected_window))
11124 return;
11127 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (MAC_OS)
11128 if (popup_activated ())
11129 return;
11130 #endif
11132 /* I don't think this happens but let's be paranoid. */
11133 if (redisplaying_p)
11134 return;
11136 /* Record a function that resets redisplaying_p to its old value
11137 when we leave this function. */
11138 count = SPECPDL_INDEX ();
11139 record_unwind_protect (unwind_redisplay,
11140 Fcons (make_number (redisplaying_p), selected_frame));
11141 ++redisplaying_p;
11142 specbind (Qinhibit_free_realized_faces, Qnil);
11145 Lisp_Object tail, frame;
11147 FOR_EACH_FRAME (tail, frame)
11149 struct frame *f = XFRAME (frame);
11150 f->already_hscrolled_p = 0;
11154 retry:
11155 if (!EQ (old_frame, selected_frame)
11156 && FRAME_LIVE_P (XFRAME (old_frame)))
11157 /* When running redisplay, we play a bit fast-and-loose and allow e.g.
11158 selected_frame and selected_window to be temporarily out-of-sync so
11159 when we come back here via `goto retry', we need to resync because we
11160 may need to run Elisp code (via prepare_menu_bars). */
11161 select_frame_for_redisplay (old_frame);
11163 pause = 0;
11164 reconsider_clip_changes (w, current_buffer);
11165 last_escape_glyph_frame = NULL;
11166 last_escape_glyph_face_id = (1 << FACE_ID_BITS);
11168 /* If new fonts have been loaded that make a glyph matrix adjustment
11169 necessary, do it. */
11170 if (fonts_changed_p)
11172 adjust_glyphs (NULL);
11173 ++windows_or_buffers_changed;
11174 fonts_changed_p = 0;
11177 /* If face_change_count is non-zero, init_iterator will free all
11178 realized faces, which includes the faces referenced from current
11179 matrices. So, we can't reuse current matrices in this case. */
11180 if (face_change_count)
11181 ++windows_or_buffers_changed;
11183 if (FRAME_TERMCAP_P (sf)
11184 && FRAME_TTY (sf)->previous_frame != sf)
11186 /* Since frames on a single ASCII terminal share the same
11187 display area, displaying a different frame means redisplay
11188 the whole thing. */
11189 windows_or_buffers_changed++;
11190 SET_FRAME_GARBAGED (sf);
11191 FRAME_TTY (sf)->previous_frame = sf;
11194 /* Set the visible flags for all frames. Do this before checking
11195 for resized or garbaged frames; they want to know if their frames
11196 are visible. See the comment in frame.h for
11197 FRAME_SAMPLE_VISIBILITY. */
11199 Lisp_Object tail, frame;
11201 number_of_visible_frames = 0;
11203 FOR_EACH_FRAME (tail, frame)
11205 struct frame *f = XFRAME (frame);
11207 FRAME_SAMPLE_VISIBILITY (f);
11208 if (FRAME_VISIBLE_P (f))
11209 ++number_of_visible_frames;
11210 clear_desired_matrices (f);
11215 /* Notice any pending interrupt request to change frame size. */
11216 do_pending_window_change (1);
11218 /* Clear frames marked as garbaged. */
11219 if (frame_garbaged)
11220 clear_garbaged_frames ();
11222 /* Build menubar and tool-bar items. */
11223 if (NILP (Vmemory_full))
11224 prepare_menu_bars ();
11226 if (windows_or_buffers_changed)
11227 update_mode_lines++;
11229 /* Detect case that we need to write or remove a star in the mode line. */
11230 if ((SAVE_MODIFF < MODIFF) != !NILP (w->last_had_star))
11232 w->update_mode_line = Qt;
11233 if (buffer_shared > 1)
11234 update_mode_lines++;
11237 /* Avoid invocation of point motion hooks by `current_column' below. */
11238 count1 = SPECPDL_INDEX ();
11239 specbind (Qinhibit_point_motion_hooks, Qt);
11241 /* If %c is in the mode line, update it if needed. */
11242 if (!NILP (w->column_number_displayed)
11243 /* This alternative quickly identifies a common case
11244 where no change is needed. */
11245 && !(PT == XFASTINT (w->last_point)
11246 && XFASTINT (w->last_modified) >= MODIFF
11247 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
11248 && (XFASTINT (w->column_number_displayed)
11249 != (int) current_column ())) /* iftc */
11250 w->update_mode_line = Qt;
11252 unbind_to (count1, Qnil);
11254 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w->frame)) = -1;
11256 /* The variable buffer_shared is set in redisplay_window and
11257 indicates that we redisplay a buffer in different windows. See
11258 there. */
11259 consider_all_windows_p = (update_mode_lines || buffer_shared > 1
11260 || cursor_type_changed);
11262 /* If specs for an arrow have changed, do thorough redisplay
11263 to ensure we remove any arrow that should no longer exist. */
11264 if (overlay_arrows_changed_p ())
11265 consider_all_windows_p = windows_or_buffers_changed = 1;
11267 /* Normally the message* functions will have already displayed and
11268 updated the echo area, but the frame may have been trashed, or
11269 the update may have been preempted, so display the echo area
11270 again here. Checking message_cleared_p captures the case that
11271 the echo area should be cleared. */
11272 if ((!NILP (echo_area_buffer[0]) && !display_last_displayed_message_p)
11273 || (!NILP (echo_area_buffer[1]) && display_last_displayed_message_p)
11274 || (message_cleared_p
11275 && minibuf_level == 0
11276 /* If the mini-window is currently selected, this means the
11277 echo-area doesn't show through. */
11278 && !MINI_WINDOW_P (XWINDOW (selected_window))))
11280 int window_height_changed_p = echo_area_display (0);
11281 must_finish = 1;
11283 /* If we don't display the current message, don't clear the
11284 message_cleared_p flag, because, if we did, we wouldn't clear
11285 the echo area in the next redisplay which doesn't preserve
11286 the echo area. */
11287 if (!display_last_displayed_message_p)
11288 message_cleared_p = 0;
11290 if (fonts_changed_p)
11291 goto retry;
11292 else if (window_height_changed_p)
11294 consider_all_windows_p = 1;
11295 ++update_mode_lines;
11296 ++windows_or_buffers_changed;
11298 /* If window configuration was changed, frames may have been
11299 marked garbaged. Clear them or we will experience
11300 surprises wrt scrolling. */
11301 if (frame_garbaged)
11302 clear_garbaged_frames ();
11305 else if (EQ (selected_window, minibuf_window)
11306 && (current_buffer->clip_changed
11307 || XFASTINT (w->last_modified) < MODIFF
11308 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF)
11309 && resize_mini_window (w, 0))
11311 /* Resized active mini-window to fit the size of what it is
11312 showing if its contents might have changed. */
11313 must_finish = 1;
11314 consider_all_windows_p = 1;
11315 ++windows_or_buffers_changed;
11316 ++update_mode_lines;
11318 /* If window configuration was changed, frames may have been
11319 marked garbaged. Clear them or we will experience
11320 surprises wrt scrolling. */
11321 if (frame_garbaged)
11322 clear_garbaged_frames ();
11326 /* If showing the region, and mark has changed, we must redisplay
11327 the whole window. The assignment to this_line_start_pos prevents
11328 the optimization directly below this if-statement. */
11329 if (((!NILP (Vtransient_mark_mode)
11330 && !NILP (XBUFFER (w->buffer)->mark_active))
11331 != !NILP (w->region_showing))
11332 || (!NILP (w->region_showing)
11333 && !EQ (w->region_showing,
11334 Fmarker_position (XBUFFER (w->buffer)->mark))))
11335 CHARPOS (this_line_start_pos) = 0;
11337 /* Optimize the case that only the line containing the cursor in the
11338 selected window has changed. Variables starting with this_ are
11339 set in display_line and record information about the line
11340 containing the cursor. */
11341 tlbufpos = this_line_start_pos;
11342 tlendpos = this_line_end_pos;
11343 if (!consider_all_windows_p
11344 && CHARPOS (tlbufpos) > 0
11345 && NILP (w->update_mode_line)
11346 && !current_buffer->clip_changed
11347 && !current_buffer->prevent_redisplay_optimizations_p
11348 && FRAME_VISIBLE_P (XFRAME (w->frame))
11349 && !FRAME_OBSCURED_P (XFRAME (w->frame))
11350 /* Make sure recorded data applies to current buffer, etc. */
11351 && this_line_buffer == current_buffer
11352 && current_buffer == XBUFFER (w->buffer)
11353 && NILP (w->force_start)
11354 && NILP (w->optional_new_start)
11355 /* Point must be on the line that we have info recorded about. */
11356 && PT >= CHARPOS (tlbufpos)
11357 && PT <= Z - CHARPOS (tlendpos)
11358 /* All text outside that line, including its final newline,
11359 must be unchanged */
11360 && text_outside_line_unchanged_p (w, CHARPOS (tlbufpos),
11361 CHARPOS (tlendpos)))
11363 if (CHARPOS (tlbufpos) > BEGV
11364 && FETCH_BYTE (BYTEPOS (tlbufpos) - 1) != '\n'
11365 && (CHARPOS (tlbufpos) == ZV
11366 || FETCH_BYTE (BYTEPOS (tlbufpos)) == '\n'))
11367 /* Former continuation line has disappeared by becoming empty */
11368 goto cancel;
11369 else if (XFASTINT (w->last_modified) < MODIFF
11370 || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF
11371 || MINI_WINDOW_P (w))
11373 /* We have to handle the case of continuation around a
11374 wide-column character (See the comment in indent.c around
11375 line 885).
11377 For instance, in the following case:
11379 -------- Insert --------
11380 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
11381 J_I_ ==> J_I_ `^^' are cursors.
11382 ^^ ^^
11383 -------- --------
11385 As we have to redraw the line above, we should goto cancel. */
11387 struct it it;
11388 int line_height_before = this_line_pixel_height;
11390 /* Note that start_display will handle the case that the
11391 line starting at tlbufpos is a continuation lines. */
11392 start_display (&it, w, tlbufpos);
11394 /* Implementation note: It this still necessary? */
11395 if (it.current_x != this_line_start_x)
11396 goto cancel;
11398 TRACE ((stderr, "trying display optimization 1\n"));
11399 w->cursor.vpos = -1;
11400 overlay_arrow_seen = 0;
11401 it.vpos = this_line_vpos;
11402 it.current_y = this_line_y;
11403 it.glyph_row = MATRIX_ROW (w->desired_matrix, this_line_vpos);
11404 display_line (&it);
11406 /* If line contains point, is not continued,
11407 and ends at same distance from eob as before, we win */
11408 if (w->cursor.vpos >= 0
11409 /* Line is not continued, otherwise this_line_start_pos
11410 would have been set to 0 in display_line. */
11411 && CHARPOS (this_line_start_pos)
11412 /* Line ends as before. */
11413 && CHARPOS (this_line_end_pos) == CHARPOS (tlendpos)
11414 /* Line has same height as before. Otherwise other lines
11415 would have to be shifted up or down. */
11416 && this_line_pixel_height == line_height_before)
11418 /* If this is not the window's last line, we must adjust
11419 the charstarts of the lines below. */
11420 if (it.current_y < it.last_visible_y)
11422 struct glyph_row *row
11423 = MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
11424 int delta, delta_bytes;
11426 if (Z - CHARPOS (tlendpos) == ZV)
11428 /* This line ends at end of (accessible part of)
11429 buffer. There is no newline to count. */
11430 delta = (Z
11431 - CHARPOS (tlendpos)
11432 - MATRIX_ROW_START_CHARPOS (row));
11433 delta_bytes = (Z_BYTE
11434 - BYTEPOS (tlendpos)
11435 - MATRIX_ROW_START_BYTEPOS (row));
11437 else
11439 /* This line ends in a newline. Must take
11440 account of the newline and the rest of the
11441 text that follows. */
11442 delta = (Z
11443 - CHARPOS (tlendpos)
11444 - MATRIX_ROW_START_CHARPOS (row));
11445 delta_bytes = (Z_BYTE
11446 - BYTEPOS (tlendpos)
11447 - MATRIX_ROW_START_BYTEPOS (row));
11450 increment_matrix_positions (w->current_matrix,
11451 this_line_vpos + 1,
11452 w->current_matrix->nrows,
11453 delta, delta_bytes);
11456 /* If this row displays text now but previously didn't,
11457 or vice versa, w->window_end_vpos may have to be
11458 adjusted. */
11459 if ((it.glyph_row - 1)->displays_text_p)
11461 if (XFASTINT (w->window_end_vpos) < this_line_vpos)
11462 XSETINT (w->window_end_vpos, this_line_vpos);
11464 else if (XFASTINT (w->window_end_vpos) == this_line_vpos
11465 && this_line_vpos > 0)
11466 XSETINT (w->window_end_vpos, this_line_vpos - 1);
11467 w->window_end_valid = Qnil;
11469 /* Update hint: No need to try to scroll in update_window. */
11470 w->desired_matrix->no_scrolling_p = 1;
11472 #if GLYPH_DEBUG
11473 *w->desired_matrix->method = 0;
11474 debug_method_add (w, "optimization 1");
11475 #endif
11476 #ifdef HAVE_WINDOW_SYSTEM
11477 update_window_fringes (w, 0);
11478 #endif
11479 goto update;
11481 else
11482 goto cancel;
11484 else if (/* Cursor position hasn't changed. */
11485 PT == XFASTINT (w->last_point)
11486 /* Make sure the cursor was last displayed
11487 in this window. Otherwise we have to reposition it. */
11488 && 0 <= w->cursor.vpos
11489 && WINDOW_TOTAL_LINES (w) > w->cursor.vpos)
11491 if (!must_finish)
11493 do_pending_window_change (1);
11495 /* We used to always goto end_of_redisplay here, but this
11496 isn't enough if we have a blinking cursor. */
11497 if (w->cursor_off_p == w->last_cursor_off_p)
11498 goto end_of_redisplay;
11500 goto update;
11502 /* If highlighting the region, or if the cursor is in the echo area,
11503 then we can't just move the cursor. */
11504 else if (! (!NILP (Vtransient_mark_mode)
11505 && !NILP (current_buffer->mark_active))
11506 && (EQ (selected_window, current_buffer->last_selected_window)
11507 || highlight_nonselected_windows)
11508 && NILP (w->region_showing)
11509 && NILP (Vshow_trailing_whitespace)
11510 && !cursor_in_echo_area)
11512 struct it it;
11513 struct glyph_row *row;
11515 /* Skip from tlbufpos to PT and see where it is. Note that
11516 PT may be in invisible text. If so, we will end at the
11517 next visible position. */
11518 init_iterator (&it, w, CHARPOS (tlbufpos), BYTEPOS (tlbufpos),
11519 NULL, DEFAULT_FACE_ID);
11520 it.current_x = this_line_start_x;
11521 it.current_y = this_line_y;
11522 it.vpos = this_line_vpos;
11524 /* The call to move_it_to stops in front of PT, but
11525 moves over before-strings. */
11526 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
11528 if (it.vpos == this_line_vpos
11529 && (row = MATRIX_ROW (w->current_matrix, this_line_vpos),
11530 row->enabled_p))
11532 xassert (this_line_vpos == it.vpos);
11533 xassert (this_line_y == it.current_y);
11534 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
11535 #if GLYPH_DEBUG
11536 *w->desired_matrix->method = 0;
11537 debug_method_add (w, "optimization 3");
11538 #endif
11539 goto update;
11541 else
11542 goto cancel;
11545 cancel:
11546 /* Text changed drastically or point moved off of line. */
11547 SET_MATRIX_ROW_ENABLED_P (w->desired_matrix, this_line_vpos, 0);
11550 CHARPOS (this_line_start_pos) = 0;
11551 consider_all_windows_p |= buffer_shared > 1;
11552 ++clear_face_cache_count;
11553 #ifdef HAVE_WINDOW_SYSTEM
11554 ++clear_image_cache_count;
11555 #endif
11557 /* Build desired matrices, and update the display. If
11558 consider_all_windows_p is non-zero, do it for all windows on all
11559 frames. Otherwise do it for selected_window, only. */
11561 if (consider_all_windows_p)
11563 Lisp_Object tail, frame;
11565 FOR_EACH_FRAME (tail, frame)
11566 XFRAME (frame)->updated_p = 0;
11568 /* Recompute # windows showing selected buffer. This will be
11569 incremented each time such a window is displayed. */
11570 buffer_shared = 0;
11572 FOR_EACH_FRAME (tail, frame)
11574 struct frame *f = XFRAME (frame);
11576 if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
11578 if (! EQ (frame, selected_frame))
11579 /* Select the frame, for the sake of frame-local
11580 variables. */
11581 select_frame_for_redisplay (frame);
11583 /* Mark all the scroll bars to be removed; we'll redeem
11584 the ones we want when we redisplay their windows. */
11585 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
11586 FRAME_TERMINAL (f)->condemn_scroll_bars_hook (f);
11588 if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
11589 redisplay_windows (FRAME_ROOT_WINDOW (f));
11591 /* Any scroll bars which redisplay_windows should have
11592 nuked should now go away. */
11593 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
11594 FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
11596 /* If fonts changed, display again. */
11597 /* ??? rms: I suspect it is a mistake to jump all the way
11598 back to retry here. It should just retry this frame. */
11599 if (fonts_changed_p)
11600 goto retry;
11602 if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
11604 /* See if we have to hscroll. */
11605 if (!f->already_hscrolled_p)
11607 f->already_hscrolled_p = 1;
11608 if (hscroll_windows (f->root_window))
11609 goto retry;
11612 /* Prevent various kinds of signals during display
11613 update. stdio is not robust about handling
11614 signals, which can cause an apparent I/O
11615 error. */
11616 if (interrupt_input)
11617 unrequest_sigio ();
11618 STOP_POLLING;
11620 /* Update the display. */
11621 set_window_update_flags (XWINDOW (f->root_window), 1);
11622 pause |= update_frame (f, 0, 0);
11623 #if 0 /* Exiting the loop can leave the wrong value for buffer_shared. */
11624 if (pause)
11625 break;
11626 #endif
11628 f->updated_p = 1;
11633 if (!pause)
11635 /* Do the mark_window_display_accurate after all windows have
11636 been redisplayed because this call resets flags in buffers
11637 which are needed for proper redisplay. */
11638 FOR_EACH_FRAME (tail, frame)
11640 struct frame *f = XFRAME (frame);
11641 if (f->updated_p)
11643 mark_window_display_accurate (f->root_window, 1);
11644 if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
11645 FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
11650 else if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
11652 Lisp_Object mini_window;
11653 struct frame *mini_frame;
11655 displayed_buffer = XBUFFER (XWINDOW (selected_window)->buffer);
11656 /* Use list_of_error, not Qerror, so that
11657 we catch only errors and don't run the debugger. */
11658 internal_condition_case_1 (redisplay_window_1, selected_window,
11659 list_of_error,
11660 redisplay_window_error);
11662 /* Compare desired and current matrices, perform output. */
11664 update:
11665 /* If fonts changed, display again. */
11666 if (fonts_changed_p)
11667 goto retry;
11669 /* Prevent various kinds of signals during display update.
11670 stdio is not robust about handling signals,
11671 which can cause an apparent I/O error. */
11672 if (interrupt_input)
11673 unrequest_sigio ();
11674 STOP_POLLING;
11676 if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
11678 if (hscroll_windows (selected_window))
11679 goto retry;
11681 XWINDOW (selected_window)->must_be_updated_p = 1;
11682 pause = update_frame (sf, 0, 0);
11685 /* We may have called echo_area_display at the top of this
11686 function. If the echo area is on another frame, that may
11687 have put text on a frame other than the selected one, so the
11688 above call to update_frame would not have caught it. Catch
11689 it here. */
11690 mini_window = FRAME_MINIBUF_WINDOW (sf);
11691 mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
11693 if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
11695 XWINDOW (mini_window)->must_be_updated_p = 1;
11696 pause |= update_frame (mini_frame, 0, 0);
11697 if (!pause && hscroll_windows (mini_window))
11698 goto retry;
11702 /* If display was paused because of pending input, make sure we do a
11703 thorough update the next time. */
11704 if (pause)
11706 /* Prevent the optimization at the beginning of
11707 redisplay_internal that tries a single-line update of the
11708 line containing the cursor in the selected window. */
11709 CHARPOS (this_line_start_pos) = 0;
11711 /* Let the overlay arrow be updated the next time. */
11712 update_overlay_arrows (0);
11714 /* If we pause after scrolling, some rows in the current
11715 matrices of some windows are not valid. */
11716 if (!WINDOW_FULL_WIDTH_P (w)
11717 && !FRAME_WINDOW_P (XFRAME (w->frame)))
11718 update_mode_lines = 1;
11720 else
11722 if (!consider_all_windows_p)
11724 /* This has already been done above if
11725 consider_all_windows_p is set. */
11726 mark_window_display_accurate_1 (w, 1);
11728 /* Say overlay arrows are up to date. */
11729 update_overlay_arrows (1);
11731 if (FRAME_TERMINAL (sf)->frame_up_to_date_hook != 0)
11732 FRAME_TERMINAL (sf)->frame_up_to_date_hook (sf);
11735 update_mode_lines = 0;
11736 windows_or_buffers_changed = 0;
11737 cursor_type_changed = 0;
11740 /* Start SIGIO interrupts coming again. Having them off during the
11741 code above makes it less likely one will discard output, but not
11742 impossible, since there might be stuff in the system buffer here.
11743 But it is much hairier to try to do anything about that. */
11744 if (interrupt_input)
11745 request_sigio ();
11746 RESUME_POLLING;
11748 /* If a frame has become visible which was not before, redisplay
11749 again, so that we display it. Expose events for such a frame
11750 (which it gets when becoming visible) don't call the parts of
11751 redisplay constructing glyphs, so simply exposing a frame won't
11752 display anything in this case. So, we have to display these
11753 frames here explicitly. */
11754 if (!pause)
11756 Lisp_Object tail, frame;
11757 int new_count = 0;
11759 FOR_EACH_FRAME (tail, frame)
11761 int this_is_visible = 0;
11763 if (XFRAME (frame)->visible)
11764 this_is_visible = 1;
11765 FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
11766 if (XFRAME (frame)->visible)
11767 this_is_visible = 1;
11769 if (this_is_visible)
11770 new_count++;
11773 if (new_count != number_of_visible_frames)
11774 windows_or_buffers_changed++;
11777 /* Change frame size now if a change is pending. */
11778 do_pending_window_change (1);
11780 /* If we just did a pending size change, or have additional
11781 visible frames, redisplay again. */
11782 if (windows_or_buffers_changed && !pause)
11783 goto retry;
11785 /* Clear the face cache eventually. */
11786 if (consider_all_windows_p)
11788 if (clear_face_cache_count > CLEAR_FACE_CACHE_COUNT)
11790 clear_face_cache (0);
11791 clear_face_cache_count = 0;
11793 #ifdef HAVE_WINDOW_SYSTEM
11794 if (clear_image_cache_count > CLEAR_IMAGE_CACHE_COUNT)
11796 clear_image_caches (Qnil);
11797 clear_image_cache_count = 0;
11799 #endif /* HAVE_WINDOW_SYSTEM */
11802 end_of_redisplay:
11803 unbind_to (count, Qnil);
11804 RESUME_POLLING;
11808 /* Redisplay, but leave alone any recent echo area message unless
11809 another message has been requested in its place.
11811 This is useful in situations where you need to redisplay but no
11812 user action has occurred, making it inappropriate for the message
11813 area to be cleared. See tracking_off and
11814 wait_reading_process_output for examples of these situations.
11816 FROM_WHERE is an integer saying from where this function was
11817 called. This is useful for debugging. */
11819 void
11820 redisplay_preserve_echo_area (from_where)
11821 int from_where;
11823 TRACE ((stderr, "redisplay_preserve_echo_area (%d)\n", from_where));
11825 if (!NILP (echo_area_buffer[1]))
11827 /* We have a previously displayed message, but no current
11828 message. Redisplay the previous message. */
11829 display_last_displayed_message_p = 1;
11830 redisplay_internal (1);
11831 display_last_displayed_message_p = 0;
11833 else
11834 redisplay_internal (1);
11836 if (FRAME_RIF (SELECTED_FRAME ()) != NULL
11837 && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
11838 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL);
11842 /* Function registered with record_unwind_protect in
11843 redisplay_internal. Reset redisplaying_p to the value it had
11844 before redisplay_internal was called, and clear
11845 prevent_freeing_realized_faces_p. It also selects the previously
11846 selected frame, unless it has been deleted (by an X connection
11847 failure during redisplay, for example). */
11849 static Lisp_Object
11850 unwind_redisplay (val)
11851 Lisp_Object val;
11853 Lisp_Object old_redisplaying_p, old_frame;
11855 old_redisplaying_p = XCAR (val);
11856 redisplaying_p = XFASTINT (old_redisplaying_p);
11857 old_frame = XCDR (val);
11858 if (! EQ (old_frame, selected_frame)
11859 && FRAME_LIVE_P (XFRAME (old_frame)))
11860 select_frame_for_redisplay (old_frame);
11861 return Qnil;
11865 /* Mark the display of window W as accurate or inaccurate. If
11866 ACCURATE_P is non-zero mark display of W as accurate. If
11867 ACCURATE_P is zero, arrange for W to be redisplayed the next time
11868 redisplay_internal is called. */
11870 static void
11871 mark_window_display_accurate_1 (w, accurate_p)
11872 struct window *w;
11873 int accurate_p;
11875 if (BUFFERP (w->buffer))
11877 struct buffer *b = XBUFFER (w->buffer);
11879 w->last_modified
11880 = make_number (accurate_p ? BUF_MODIFF (b) : 0);
11881 w->last_overlay_modified
11882 = make_number (accurate_p ? BUF_OVERLAY_MODIFF (b) : 0);
11883 w->last_had_star
11884 = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b) ? Qt : Qnil;
11886 if (accurate_p)
11888 b->clip_changed = 0;
11889 b->prevent_redisplay_optimizations_p = 0;
11891 BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
11892 BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
11893 BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
11894 BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
11896 w->current_matrix->buffer = b;
11897 w->current_matrix->begv = BUF_BEGV (b);
11898 w->current_matrix->zv = BUF_ZV (b);
11900 w->last_cursor = w->cursor;
11901 w->last_cursor_off_p = w->cursor_off_p;
11903 if (w == XWINDOW (selected_window))
11904 w->last_point = make_number (BUF_PT (b));
11905 else
11906 w->last_point = make_number (XMARKER (w->pointm)->charpos);
11910 if (accurate_p)
11912 w->window_end_valid = w->buffer;
11913 #if 0 /* This is incorrect with variable-height lines. */
11914 xassert (XINT (w->window_end_vpos)
11915 < (WINDOW_TOTAL_LINES (w)
11916 - (WINDOW_WANTS_MODELINE_P (w) ? 1 : 0)));
11917 #endif
11918 w->update_mode_line = Qnil;
11923 /* Mark the display of windows in the window tree rooted at WINDOW as
11924 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
11925 windows as accurate. If ACCURATE_P is zero, arrange for windows to
11926 be redisplayed the next time redisplay_internal is called. */
11928 void
11929 mark_window_display_accurate (window, accurate_p)
11930 Lisp_Object window;
11931 int accurate_p;
11933 struct window *w;
11935 for (; !NILP (window); window = w->next)
11937 w = XWINDOW (window);
11938 mark_window_display_accurate_1 (w, accurate_p);
11940 if (!NILP (w->vchild))
11941 mark_window_display_accurate (w->vchild, accurate_p);
11942 if (!NILP (w->hchild))
11943 mark_window_display_accurate (w->hchild, accurate_p);
11946 if (accurate_p)
11948 update_overlay_arrows (1);
11950 else
11952 /* Force a thorough redisplay the next time by setting
11953 last_arrow_position and last_arrow_string to t, which is
11954 unequal to any useful value of Voverlay_arrow_... */
11955 update_overlay_arrows (-1);
11960 /* Return value in display table DP (Lisp_Char_Table *) for character
11961 C. Since a display table doesn't have any parent, we don't have to
11962 follow parent. Do not call this function directly but use the
11963 macro DISP_CHAR_VECTOR. */
11965 Lisp_Object
11966 disp_char_vector (dp, c)
11967 struct Lisp_Char_Table *dp;
11968 int c;
11970 Lisp_Object val;
11972 if (ASCII_CHAR_P (c))
11974 val = dp->ascii;
11975 if (SUB_CHAR_TABLE_P (val))
11976 val = XSUB_CHAR_TABLE (val)->contents[c];
11978 else
11980 Lisp_Object table;
11982 XSETCHAR_TABLE (table, dp);
11983 val = char_table_ref (table, c);
11985 if (NILP (val))
11986 val = dp->defalt;
11987 return val;
11992 /***********************************************************************
11993 Window Redisplay
11994 ***********************************************************************/
11996 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
11998 static void
11999 redisplay_windows (window)
12000 Lisp_Object window;
12002 while (!NILP (window))
12004 struct window *w = XWINDOW (window);
12006 if (!NILP (w->hchild))
12007 redisplay_windows (w->hchild);
12008 else if (!NILP (w->vchild))
12009 redisplay_windows (w->vchild);
12010 else
12012 displayed_buffer = XBUFFER (w->buffer);
12013 /* Use list_of_error, not Qerror, so that
12014 we catch only errors and don't run the debugger. */
12015 internal_condition_case_1 (redisplay_window_0, window,
12016 list_of_error,
12017 redisplay_window_error);
12020 window = w->next;
12024 static Lisp_Object
12025 redisplay_window_error ()
12027 displayed_buffer->display_error_modiff = BUF_MODIFF (displayed_buffer);
12028 return Qnil;
12031 static Lisp_Object
12032 redisplay_window_0 (window)
12033 Lisp_Object window;
12035 if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
12036 redisplay_window (window, 0);
12037 return Qnil;
12040 static Lisp_Object
12041 redisplay_window_1 (window)
12042 Lisp_Object window;
12044 if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
12045 redisplay_window (window, 1);
12046 return Qnil;
12050 /* Increment GLYPH until it reaches END or CONDITION fails while
12051 adding (GLYPH)->pixel_width to X. */
12053 #define SKIP_GLYPHS(glyph, end, x, condition) \
12054 do \
12056 (x) += (glyph)->pixel_width; \
12057 ++(glyph); \
12059 while ((glyph) < (end) && (condition))
12062 /* Set cursor position of W. PT is assumed to be displayed in ROW.
12063 DELTA is the number of bytes by which positions recorded in ROW
12064 differ from current buffer positions.
12066 Return 0 if cursor is not on this row. 1 otherwise. */
12069 set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos)
12070 struct window *w;
12071 struct glyph_row *row;
12072 struct glyph_matrix *matrix;
12073 int delta, delta_bytes, dy, dvpos;
12075 struct glyph *glyph = row->glyphs[TEXT_AREA];
12076 struct glyph *end = glyph + row->used[TEXT_AREA];
12077 struct glyph *cursor = NULL;
12078 /* The first glyph that starts a sequence of glyphs from string. */
12079 struct glyph *string_start;
12080 /* The X coordinate of string_start. */
12081 int string_start_x;
12082 /* The last known character position. */
12083 int last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
12084 /* The last known character position before string_start. */
12085 int string_before_pos;
12086 int x = row->x;
12087 int cursor_x = x;
12088 int cursor_from_overlay_pos = 0;
12089 int pt_old = PT - delta;
12091 /* Skip over glyphs not having an object at the start of the row.
12092 These are special glyphs like truncation marks on terminal
12093 frames. */
12094 if (row->displays_text_p)
12095 while (glyph < end
12096 && INTEGERP (glyph->object)
12097 && glyph->charpos < 0)
12099 x += glyph->pixel_width;
12100 ++glyph;
12103 string_start = NULL;
12104 while (glyph < end
12105 && !INTEGERP (glyph->object)
12106 && (!BUFFERP (glyph->object)
12107 || (last_pos = glyph->charpos) < pt_old))
12109 if (! STRINGP (glyph->object))
12111 string_start = NULL;
12112 x += glyph->pixel_width;
12113 ++glyph;
12114 if (cursor_from_overlay_pos
12115 && last_pos >= cursor_from_overlay_pos)
12117 cursor_from_overlay_pos = 0;
12118 cursor = 0;
12121 else
12123 if (string_start == NULL)
12125 string_before_pos = last_pos;
12126 string_start = glyph;
12127 string_start_x = x;
12129 /* Skip all glyphs from string. */
12132 Lisp_Object cprop;
12133 int pos;
12134 if ((cursor == NULL || glyph > cursor)
12135 && (cprop = Fget_char_property (make_number ((glyph)->charpos),
12136 Qcursor, (glyph)->object),
12137 !NILP (cprop))
12138 && (pos = string_buffer_position (w, glyph->object,
12139 string_before_pos),
12140 (pos == 0 /* From overlay */
12141 || pos == pt_old)))
12143 /* Estimate overlay buffer position from the buffer
12144 positions of the glyphs before and after the overlay.
12145 Add 1 to last_pos so that if point corresponds to the
12146 glyph right after the overlay, we still use a 'cursor'
12147 property found in that overlay. */
12148 cursor_from_overlay_pos = (pos ? 0 : last_pos
12149 + (INTEGERP (cprop) ? XINT (cprop) : 0));
12150 cursor = glyph;
12151 cursor_x = x;
12153 x += glyph->pixel_width;
12154 ++glyph;
12156 while (glyph < end && EQ (glyph->object, string_start->object));
12160 if (cursor != NULL)
12162 glyph = cursor;
12163 x = cursor_x;
12165 else if (row->ends_in_ellipsis_p && glyph == end)
12167 /* Scan back over the ellipsis glyphs, decrementing positions. */
12168 while (glyph > row->glyphs[TEXT_AREA]
12169 && (glyph - 1)->charpos == last_pos)
12170 glyph--, x -= glyph->pixel_width;
12171 /* That loop always goes one position too far,
12172 including the glyph before the ellipsis.
12173 So scan forward over that one. */
12174 x += glyph->pixel_width;
12175 glyph++;
12177 else if (string_start
12178 && (glyph == end || !BUFFERP (glyph->object) || last_pos > pt_old))
12180 /* We may have skipped over point because the previous glyphs
12181 are from string. As there's no easy way to know the
12182 character position of the current glyph, find the correct
12183 glyph on point by scanning from string_start again. */
12184 Lisp_Object limit;
12185 Lisp_Object string;
12186 struct glyph *stop = glyph;
12187 int pos;
12189 limit = make_number (pt_old + 1);
12190 glyph = string_start;
12191 x = string_start_x;
12192 string = glyph->object;
12193 pos = string_buffer_position (w, string, string_before_pos);
12194 /* If STRING is from overlay, LAST_POS == 0. We skip such glyphs
12195 because we always put cursor after overlay strings. */
12196 while (pos == 0 && glyph < stop)
12198 string = glyph->object;
12199 SKIP_GLYPHS (glyph, stop, x, EQ (glyph->object, string));
12200 if (glyph < stop)
12201 pos = string_buffer_position (w, glyph->object, string_before_pos);
12204 while (glyph < stop)
12206 pos = XINT (Fnext_single_char_property_change
12207 (make_number (pos), Qdisplay, Qnil, limit));
12208 if (pos > pt_old)
12209 break;
12210 /* Skip glyphs from the same string. */
12211 string = glyph->object;
12212 SKIP_GLYPHS (glyph, stop, x, EQ (glyph->object, string));
12213 /* Skip glyphs from an overlay. */
12214 while (glyph < stop
12215 && ! string_buffer_position (w, glyph->object, pos))
12217 string = glyph->object;
12218 SKIP_GLYPHS (glyph, stop, x, EQ (glyph->object, string));
12222 /* If we reached the end of the line, and end was from a string,
12223 cursor is not on this line. */
12224 if (glyph == end && row->continued_p)
12225 return 0;
12228 w->cursor.hpos = glyph - row->glyphs[TEXT_AREA];
12229 w->cursor.x = x;
12230 w->cursor.vpos = MATRIX_ROW_VPOS (row, matrix) + dvpos;
12231 w->cursor.y = row->y + dy;
12233 if (w == XWINDOW (selected_window))
12235 if (!row->continued_p
12236 && !MATRIX_ROW_CONTINUATION_LINE_P (row)
12237 && row->x == 0)
12239 this_line_buffer = XBUFFER (w->buffer);
12241 CHARPOS (this_line_start_pos)
12242 = MATRIX_ROW_START_CHARPOS (row) + delta;
12243 BYTEPOS (this_line_start_pos)
12244 = MATRIX_ROW_START_BYTEPOS (row) + delta_bytes;
12246 CHARPOS (this_line_end_pos)
12247 = Z - (MATRIX_ROW_END_CHARPOS (row) + delta);
12248 BYTEPOS (this_line_end_pos)
12249 = Z_BYTE - (MATRIX_ROW_END_BYTEPOS (row) + delta_bytes);
12251 this_line_y = w->cursor.y;
12252 this_line_pixel_height = row->height;
12253 this_line_vpos = w->cursor.vpos;
12254 this_line_start_x = row->x;
12256 else
12257 CHARPOS (this_line_start_pos) = 0;
12260 return 1;
12264 /* Run window scroll functions, if any, for WINDOW with new window
12265 start STARTP. Sets the window start of WINDOW to that position.
12267 We assume that the window's buffer is really current. */
12269 static INLINE struct text_pos
12270 run_window_scroll_functions (window, startp)
12271 Lisp_Object window;
12272 struct text_pos startp;
12274 struct window *w = XWINDOW (window);
12275 SET_MARKER_FROM_TEXT_POS (w->start, startp);
12277 if (current_buffer != XBUFFER (w->buffer))
12278 abort ();
12280 if (!NILP (Vwindow_scroll_functions))
12282 run_hook_with_args_2 (Qwindow_scroll_functions, window,
12283 make_number (CHARPOS (startp)));
12284 SET_TEXT_POS_FROM_MARKER (startp, w->start);
12285 /* In case the hook functions switch buffers. */
12286 if (current_buffer != XBUFFER (w->buffer))
12287 set_buffer_internal_1 (XBUFFER (w->buffer));
12290 return startp;
12294 /* Make sure the line containing the cursor is fully visible.
12295 A value of 1 means there is nothing to be done.
12296 (Either the line is fully visible, or it cannot be made so,
12297 or we cannot tell.)
12299 If FORCE_P is non-zero, return 0 even if partial visible cursor row
12300 is higher than window.
12302 A value of 0 means the caller should do scrolling
12303 as if point had gone off the screen. */
12305 static int
12306 cursor_row_fully_visible_p (w, force_p, current_matrix_p)
12307 struct window *w;
12308 int force_p;
12309 int current_matrix_p;
12311 struct glyph_matrix *matrix;
12312 struct glyph_row *row;
12313 int window_height;
12315 if (!make_cursor_line_fully_visible_p)
12316 return 1;
12318 /* It's not always possible to find the cursor, e.g, when a window
12319 is full of overlay strings. Don't do anything in that case. */
12320 if (w->cursor.vpos < 0)
12321 return 1;
12323 matrix = current_matrix_p ? w->current_matrix : w->desired_matrix;
12324 row = MATRIX_ROW (matrix, w->cursor.vpos);
12326 /* If the cursor row is not partially visible, there's nothing to do. */
12327 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row))
12328 return 1;
12330 /* If the row the cursor is in is taller than the window's height,
12331 it's not clear what to do, so do nothing. */
12332 window_height = window_box_height (w);
12333 if (row->height >= window_height)
12335 if (!force_p || MINI_WINDOW_P (w)
12336 || w->vscroll || w->cursor.vpos == 0)
12337 return 1;
12339 return 0;
12341 #if 0
12342 /* This code used to try to scroll the window just enough to make
12343 the line visible. It returned 0 to say that the caller should
12344 allocate larger glyph matrices. */
12346 if (MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w, row))
12348 int dy = row->height - row->visible_height;
12349 w->vscroll = 0;
12350 w->cursor.y += dy;
12351 shift_glyph_matrix (w, matrix, 0, matrix->nrows, dy);
12353 else /* MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row)) */
12355 int dy = - (row->height - row->visible_height);
12356 w->vscroll = dy;
12357 w->cursor.y += dy;
12358 shift_glyph_matrix (w, matrix, 0, matrix->nrows, dy);
12361 /* When we change the cursor y-position of the selected window,
12362 change this_line_y as well so that the display optimization for
12363 the cursor line of the selected window in redisplay_internal uses
12364 the correct y-position. */
12365 if (w == XWINDOW (selected_window))
12366 this_line_y = w->cursor.y;
12368 /* If vscrolling requires a larger glyph matrix, arrange for a fresh
12369 redisplay with larger matrices. */
12370 if (matrix->nrows < required_matrix_height (w))
12372 fonts_changed_p = 1;
12373 return 0;
12376 return 1;
12377 #endif /* 0 */
12381 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
12382 non-zero means only WINDOW is redisplayed in redisplay_internal.
12383 TEMP_SCROLL_STEP has the same meaning as scroll_step, and is used
12384 in redisplay_window to bring a partially visible line into view in
12385 the case that only the cursor has moved.
12387 LAST_LINE_MISFIT should be nonzero if we're scrolling because the
12388 last screen line's vertical height extends past the end of the screen.
12390 Value is
12392 1 if scrolling succeeded
12394 0 if scrolling didn't find point.
12396 -1 if new fonts have been loaded so that we must interrupt
12397 redisplay, adjust glyph matrices, and try again. */
12399 enum
12401 SCROLLING_SUCCESS,
12402 SCROLLING_FAILED,
12403 SCROLLING_NEED_LARGER_MATRICES
12406 static int
12407 try_scrolling (window, just_this_one_p, scroll_conservatively,
12408 scroll_step, temp_scroll_step, last_line_misfit)
12409 Lisp_Object window;
12410 int just_this_one_p;
12411 EMACS_INT scroll_conservatively, scroll_step;
12412 int temp_scroll_step;
12413 int last_line_misfit;
12415 struct window *w = XWINDOW (window);
12416 struct frame *f = XFRAME (w->frame);
12417 struct text_pos scroll_margin_pos;
12418 struct text_pos pos;
12419 struct text_pos startp;
12420 struct it it;
12421 Lisp_Object window_end;
12422 int this_scroll_margin;
12423 int dy = 0;
12424 int scroll_max;
12425 int rc;
12426 int amount_to_scroll = 0;
12427 Lisp_Object aggressive;
12428 int height;
12429 int extra_scroll_margin_lines = last_line_misfit ? 1 : 0;
12431 #if GLYPH_DEBUG
12432 debug_method_add (w, "try_scrolling");
12433 #endif
12435 SET_TEXT_POS_FROM_MARKER (startp, w->start);
12437 /* Compute scroll margin height in pixels. We scroll when point is
12438 within this distance from the top or bottom of the window. */
12439 if (scroll_margin > 0)
12441 this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
12442 this_scroll_margin *= FRAME_LINE_HEIGHT (f);
12444 else
12445 this_scroll_margin = 0;
12447 /* Force scroll_conservatively to have a reasonable value so it doesn't
12448 cause an overflow while computing how much to scroll. */
12449 if (scroll_conservatively)
12450 scroll_conservatively = min (scroll_conservatively,
12451 MOST_POSITIVE_FIXNUM / FRAME_LINE_HEIGHT (f));
12453 /* Compute how much we should try to scroll maximally to bring point
12454 into view. */
12455 if (scroll_step || scroll_conservatively || temp_scroll_step)
12456 scroll_max = max (scroll_step,
12457 max (scroll_conservatively, temp_scroll_step));
12458 else if (NUMBERP (current_buffer->scroll_down_aggressively)
12459 || NUMBERP (current_buffer->scroll_up_aggressively))
12460 /* We're trying to scroll because of aggressive scrolling
12461 but no scroll_step is set. Choose an arbitrary one. Maybe
12462 there should be a variable for this. */
12463 scroll_max = 10;
12464 else
12465 scroll_max = 0;
12466 scroll_max *= FRAME_LINE_HEIGHT (f);
12468 /* Decide whether we have to scroll down. Start at the window end
12469 and move this_scroll_margin up to find the position of the scroll
12470 margin. */
12471 window_end = Fwindow_end (window, Qt);
12473 too_near_end:
12475 CHARPOS (scroll_margin_pos) = XINT (window_end);
12476 BYTEPOS (scroll_margin_pos) = CHAR_TO_BYTE (CHARPOS (scroll_margin_pos));
12478 if (this_scroll_margin || extra_scroll_margin_lines)
12480 start_display (&it, w, scroll_margin_pos);
12481 if (this_scroll_margin)
12482 move_it_vertically_backward (&it, this_scroll_margin);
12483 if (extra_scroll_margin_lines)
12484 move_it_by_lines (&it, - extra_scroll_margin_lines, 0);
12485 scroll_margin_pos = it.current.pos;
12488 if (PT >= CHARPOS (scroll_margin_pos))
12490 int y0;
12492 /* Point is in the scroll margin at the bottom of the window, or
12493 below. Compute a new window start that makes point visible. */
12495 /* Compute the distance from the scroll margin to PT.
12496 Give up if the distance is greater than scroll_max. */
12497 start_display (&it, w, scroll_margin_pos);
12498 y0 = it.current_y;
12499 move_it_to (&it, PT, 0, it.last_visible_y, -1,
12500 MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
12502 /* To make point visible, we have to move the window start
12503 down so that the line the cursor is in is visible, which
12504 means we have to add in the height of the cursor line. */
12505 dy = line_bottom_y (&it) - y0;
12507 if (dy > scroll_max)
12508 return SCROLLING_FAILED;
12510 /* Move the window start down. If scrolling conservatively,
12511 move it just enough down to make point visible. If
12512 scroll_step is set, move it down by scroll_step. */
12513 start_display (&it, w, startp);
12515 if (scroll_conservatively)
12516 /* Set AMOUNT_TO_SCROLL to at least one line,
12517 and at most scroll_conservatively lines. */
12518 amount_to_scroll
12519 = min (max (dy, FRAME_LINE_HEIGHT (f)),
12520 FRAME_LINE_HEIGHT (f) * scroll_conservatively);
12521 else if (scroll_step || temp_scroll_step)
12522 amount_to_scroll = scroll_max;
12523 else
12525 aggressive = current_buffer->scroll_up_aggressively;
12526 height = WINDOW_BOX_TEXT_HEIGHT (w);
12527 if (NUMBERP (aggressive))
12529 double float_amount = XFLOATINT (aggressive) * height;
12530 amount_to_scroll = float_amount;
12531 if (amount_to_scroll == 0 && float_amount > 0)
12532 amount_to_scroll = 1;
12536 if (amount_to_scroll <= 0)
12537 return SCROLLING_FAILED;
12539 /* If moving by amount_to_scroll leaves STARTP unchanged,
12540 move it down one screen line. */
12542 move_it_vertically (&it, amount_to_scroll);
12543 if (CHARPOS (it.current.pos) == CHARPOS (startp))
12544 move_it_by_lines (&it, 1, 1);
12545 startp = it.current.pos;
12547 else
12549 /* See if point is inside the scroll margin at the top of the
12550 window. */
12551 scroll_margin_pos = startp;
12552 if (this_scroll_margin)
12554 start_display (&it, w, startp);
12555 move_it_vertically (&it, this_scroll_margin);
12556 scroll_margin_pos = it.current.pos;
12559 if (PT < CHARPOS (scroll_margin_pos))
12561 /* Point is in the scroll margin at the top of the window or
12562 above what is displayed in the window. */
12563 int y0;
12565 /* Compute the vertical distance from PT to the scroll
12566 margin position. Give up if distance is greater than
12567 scroll_max. */
12568 SET_TEXT_POS (pos, PT, PT_BYTE);
12569 start_display (&it, w, pos);
12570 y0 = it.current_y;
12571 move_it_to (&it, CHARPOS (scroll_margin_pos), 0,
12572 it.last_visible_y, -1,
12573 MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
12574 dy = it.current_y - y0;
12575 if (dy > scroll_max)
12576 return SCROLLING_FAILED;
12578 /* Compute new window start. */
12579 start_display (&it, w, startp);
12581 if (scroll_conservatively)
12582 amount_to_scroll
12583 = max (dy, FRAME_LINE_HEIGHT (f) * max (scroll_step, temp_scroll_step));
12584 else if (scroll_step || temp_scroll_step)
12585 amount_to_scroll = scroll_max;
12586 else
12588 aggressive = current_buffer->scroll_down_aggressively;
12589 height = WINDOW_BOX_TEXT_HEIGHT (w);
12590 if (NUMBERP (aggressive))
12592 double float_amount = XFLOATINT (aggressive) * height;
12593 amount_to_scroll = float_amount;
12594 if (amount_to_scroll == 0 && float_amount > 0)
12595 amount_to_scroll = 1;
12599 if (amount_to_scroll <= 0)
12600 return SCROLLING_FAILED;
12602 move_it_vertically_backward (&it, amount_to_scroll);
12603 startp = it.current.pos;
12607 /* Run window scroll functions. */
12608 startp = run_window_scroll_functions (window, startp);
12610 /* Display the window. Give up if new fonts are loaded, or if point
12611 doesn't appear. */
12612 if (!try_window (window, startp, 0))
12613 rc = SCROLLING_NEED_LARGER_MATRICES;
12614 else if (w->cursor.vpos < 0)
12616 clear_glyph_matrix (w->desired_matrix);
12617 rc = SCROLLING_FAILED;
12619 else
12621 /* Maybe forget recorded base line for line number display. */
12622 if (!just_this_one_p
12623 || current_buffer->clip_changed
12624 || BEG_UNCHANGED < CHARPOS (startp))
12625 w->base_line_number = Qnil;
12627 /* If cursor ends up on a partially visible line,
12628 treat that as being off the bottom of the screen. */
12629 if (! cursor_row_fully_visible_p (w, extra_scroll_margin_lines <= 1, 0))
12631 clear_glyph_matrix (w->desired_matrix);
12632 ++extra_scroll_margin_lines;
12633 goto too_near_end;
12635 rc = SCROLLING_SUCCESS;
12638 return rc;
12642 /* Compute a suitable window start for window W if display of W starts
12643 on a continuation line. Value is non-zero if a new window start
12644 was computed.
12646 The new window start will be computed, based on W's width, starting
12647 from the start of the continued line. It is the start of the
12648 screen line with the minimum distance from the old start W->start. */
12650 static int
12651 compute_window_start_on_continuation_line (w)
12652 struct window *w;
12654 struct text_pos pos, start_pos;
12655 int window_start_changed_p = 0;
12657 SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
12659 /* If window start is on a continuation line... Window start may be
12660 < BEGV in case there's invisible text at the start of the
12661 buffer (M-x rmail, for example). */
12662 if (CHARPOS (start_pos) > BEGV
12663 && FETCH_BYTE (BYTEPOS (start_pos) - 1) != '\n')
12665 struct it it;
12666 struct glyph_row *row;
12668 /* Handle the case that the window start is out of range. */
12669 if (CHARPOS (start_pos) < BEGV)
12670 SET_TEXT_POS (start_pos, BEGV, BEGV_BYTE);
12671 else if (CHARPOS (start_pos) > ZV)
12672 SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
12674 /* Find the start of the continued line. This should be fast
12675 because scan_buffer is fast (newline cache). */
12676 row = w->desired_matrix->rows + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0);
12677 init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
12678 row, DEFAULT_FACE_ID);
12679 reseat_at_previous_visible_line_start (&it);
12681 /* If the line start is "too far" away from the window start,
12682 say it takes too much time to compute a new window start. */
12683 if (CHARPOS (start_pos) - IT_CHARPOS (it)
12684 < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w))
12686 int min_distance, distance;
12688 /* Move forward by display lines to find the new window
12689 start. If window width was enlarged, the new start can
12690 be expected to be > the old start. If window width was
12691 decreased, the new window start will be < the old start.
12692 So, we're looking for the display line start with the
12693 minimum distance from the old window start. */
12694 pos = it.current.pos;
12695 min_distance = INFINITY;
12696 while ((distance = eabs (CHARPOS (start_pos) - IT_CHARPOS (it))),
12697 distance < min_distance)
12699 min_distance = distance;
12700 pos = it.current.pos;
12701 move_it_by_lines (&it, 1, 0);
12704 /* Set the window start there. */
12705 SET_MARKER_FROM_TEXT_POS (w->start, pos);
12706 window_start_changed_p = 1;
12710 return window_start_changed_p;
12714 /* Try cursor movement in case text has not changed in window WINDOW,
12715 with window start STARTP. Value is
12717 CURSOR_MOVEMENT_SUCCESS if successful
12719 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
12721 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
12722 display. *SCROLL_STEP is set to 1, under certain circumstances, if
12723 we want to scroll as if scroll-step were set to 1. See the code.
12725 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
12726 which case we have to abort this redisplay, and adjust matrices
12727 first. */
12729 enum
12731 CURSOR_MOVEMENT_SUCCESS,
12732 CURSOR_MOVEMENT_CANNOT_BE_USED,
12733 CURSOR_MOVEMENT_MUST_SCROLL,
12734 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
12737 static int
12738 try_cursor_movement (window, startp, scroll_step)
12739 Lisp_Object window;
12740 struct text_pos startp;
12741 int *scroll_step;
12743 struct window *w = XWINDOW (window);
12744 struct frame *f = XFRAME (w->frame);
12745 int rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
12747 #if GLYPH_DEBUG
12748 if (inhibit_try_cursor_movement)
12749 return rc;
12750 #endif
12752 /* Handle case where text has not changed, only point, and it has
12753 not moved off the frame. */
12754 if (/* Point may be in this window. */
12755 PT >= CHARPOS (startp)
12756 /* Selective display hasn't changed. */
12757 && !current_buffer->clip_changed
12758 /* Function force-mode-line-update is used to force a thorough
12759 redisplay. It sets either windows_or_buffers_changed or
12760 update_mode_lines. So don't take a shortcut here for these
12761 cases. */
12762 && !update_mode_lines
12763 && !windows_or_buffers_changed
12764 && !cursor_type_changed
12765 /* Can't use this case if highlighting a region. When a
12766 region exists, cursor movement has to do more than just
12767 set the cursor. */
12768 && !(!NILP (Vtransient_mark_mode)
12769 && !NILP (current_buffer->mark_active))
12770 && NILP (w->region_showing)
12771 && NILP (Vshow_trailing_whitespace)
12772 /* Right after splitting windows, last_point may be nil. */
12773 && INTEGERP (w->last_point)
12774 /* This code is not used for mini-buffer for the sake of the case
12775 of redisplaying to replace an echo area message; since in
12776 that case the mini-buffer contents per se are usually
12777 unchanged. This code is of no real use in the mini-buffer
12778 since the handling of this_line_start_pos, etc., in redisplay
12779 handles the same cases. */
12780 && !EQ (window, minibuf_window)
12781 /* When splitting windows or for new windows, it happens that
12782 redisplay is called with a nil window_end_vpos or one being
12783 larger than the window. This should really be fixed in
12784 window.c. I don't have this on my list, now, so we do
12785 approximately the same as the old redisplay code. --gerd. */
12786 && INTEGERP (w->window_end_vpos)
12787 && XFASTINT (w->window_end_vpos) < w->current_matrix->nrows
12788 && (FRAME_WINDOW_P (f)
12789 || !overlay_arrow_in_current_buffer_p ()))
12791 int this_scroll_margin, top_scroll_margin;
12792 struct glyph_row *row = NULL;
12794 #if GLYPH_DEBUG
12795 debug_method_add (w, "cursor movement");
12796 #endif
12798 /* Scroll if point within this distance from the top or bottom
12799 of the window. This is a pixel value. */
12800 this_scroll_margin = max (0, scroll_margin);
12801 this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
12802 this_scroll_margin *= FRAME_LINE_HEIGHT (f);
12804 top_scroll_margin = this_scroll_margin;
12805 if (WINDOW_WANTS_HEADER_LINE_P (w))
12806 top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
12808 /* Start with the row the cursor was displayed during the last
12809 not paused redisplay. Give up if that row is not valid. */
12810 if (w->last_cursor.vpos < 0
12811 || w->last_cursor.vpos >= w->current_matrix->nrows)
12812 rc = CURSOR_MOVEMENT_MUST_SCROLL;
12813 else
12815 row = MATRIX_ROW (w->current_matrix, w->last_cursor.vpos);
12816 if (row->mode_line_p)
12817 ++row;
12818 if (!row->enabled_p)
12819 rc = CURSOR_MOVEMENT_MUST_SCROLL;
12822 if (rc == CURSOR_MOVEMENT_CANNOT_BE_USED)
12824 int scroll_p = 0;
12825 int last_y = window_text_bottom_y (w) - this_scroll_margin;
12827 if (PT > XFASTINT (w->last_point))
12829 /* Point has moved forward. */
12830 while (MATRIX_ROW_END_CHARPOS (row) < PT
12831 && MATRIX_ROW_BOTTOM_Y (row) < last_y)
12833 xassert (row->enabled_p);
12834 ++row;
12837 /* The end position of a row equals the start position
12838 of the next row. If PT is there, we would rather
12839 display it in the next line. */
12840 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
12841 && MATRIX_ROW_END_CHARPOS (row) == PT
12842 && !cursor_row_p (w, row))
12843 ++row;
12845 /* If within the scroll margin, scroll. Note that
12846 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
12847 the next line would be drawn, and that
12848 this_scroll_margin can be zero. */
12849 if (MATRIX_ROW_BOTTOM_Y (row) > last_y
12850 || PT > MATRIX_ROW_END_CHARPOS (row)
12851 /* Line is completely visible last line in window
12852 and PT is to be set in the next line. */
12853 || (MATRIX_ROW_BOTTOM_Y (row) == last_y
12854 && PT == MATRIX_ROW_END_CHARPOS (row)
12855 && !row->ends_at_zv_p
12856 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
12857 scroll_p = 1;
12859 else if (PT < XFASTINT (w->last_point))
12861 /* Cursor has to be moved backward. Note that PT >=
12862 CHARPOS (startp) because of the outer if-statement. */
12863 while (!row->mode_line_p
12864 && (MATRIX_ROW_START_CHARPOS (row) > PT
12865 || (MATRIX_ROW_START_CHARPOS (row) == PT
12866 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)
12867 || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
12868 row > w->current_matrix->rows
12869 && (row-1)->ends_in_newline_from_string_p))))
12870 && (row->y > top_scroll_margin
12871 || CHARPOS (startp) == BEGV))
12873 xassert (row->enabled_p);
12874 --row;
12877 /* Consider the following case: Window starts at BEGV,
12878 there is invisible, intangible text at BEGV, so that
12879 display starts at some point START > BEGV. It can
12880 happen that we are called with PT somewhere between
12881 BEGV and START. Try to handle that case. */
12882 if (row < w->current_matrix->rows
12883 || row->mode_line_p)
12885 row = w->current_matrix->rows;
12886 if (row->mode_line_p)
12887 ++row;
12890 /* Due to newlines in overlay strings, we may have to
12891 skip forward over overlay strings. */
12892 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
12893 && MATRIX_ROW_END_CHARPOS (row) == PT
12894 && !cursor_row_p (w, row))
12895 ++row;
12897 /* If within the scroll margin, scroll. */
12898 if (row->y < top_scroll_margin
12899 && CHARPOS (startp) != BEGV)
12900 scroll_p = 1;
12902 else
12904 /* Cursor did not move. So don't scroll even if cursor line
12905 is partially visible, as it was so before. */
12906 rc = CURSOR_MOVEMENT_SUCCESS;
12909 if (PT < MATRIX_ROW_START_CHARPOS (row)
12910 || PT > MATRIX_ROW_END_CHARPOS (row))
12912 /* if PT is not in the glyph row, give up. */
12913 rc = CURSOR_MOVEMENT_MUST_SCROLL;
12915 else if (rc != CURSOR_MOVEMENT_SUCCESS
12916 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row)
12917 && make_cursor_line_fully_visible_p)
12919 if (PT == MATRIX_ROW_END_CHARPOS (row)
12920 && !row->ends_at_zv_p
12921 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
12922 rc = CURSOR_MOVEMENT_MUST_SCROLL;
12923 else if (row->height > window_box_height (w))
12925 /* If we end up in a partially visible line, let's
12926 make it fully visible, except when it's taller
12927 than the window, in which case we can't do much
12928 about it. */
12929 *scroll_step = 1;
12930 rc = CURSOR_MOVEMENT_MUST_SCROLL;
12932 else
12934 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
12935 if (!cursor_row_fully_visible_p (w, 0, 1))
12936 rc = CURSOR_MOVEMENT_MUST_SCROLL;
12937 else
12938 rc = CURSOR_MOVEMENT_SUCCESS;
12941 else if (scroll_p)
12942 rc = CURSOR_MOVEMENT_MUST_SCROLL;
12943 else
12947 if (set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0))
12949 rc = CURSOR_MOVEMENT_SUCCESS;
12950 break;
12952 ++row;
12954 while (MATRIX_ROW_BOTTOM_Y (row) < last_y
12955 && MATRIX_ROW_START_CHARPOS (row) == PT
12956 && cursor_row_p (w, row));
12961 return rc;
12964 void
12965 set_vertical_scroll_bar (w)
12966 struct window *w;
12968 int start, end, whole;
12970 /* Calculate the start and end positions for the current window.
12971 At some point, it would be nice to choose between scrollbars
12972 which reflect the whole buffer size, with special markers
12973 indicating narrowing, and scrollbars which reflect only the
12974 visible region.
12976 Note that mini-buffers sometimes aren't displaying any text. */
12977 if (!MINI_WINDOW_P (w)
12978 || (w == XWINDOW (minibuf_window)
12979 && NILP (echo_area_buffer[0])))
12981 struct buffer *buf = XBUFFER (w->buffer);
12982 whole = BUF_ZV (buf) - BUF_BEGV (buf);
12983 start = marker_position (w->start) - BUF_BEGV (buf);
12984 /* I don't think this is guaranteed to be right. For the
12985 moment, we'll pretend it is. */
12986 end = BUF_Z (buf) - XFASTINT (w->window_end_pos) - BUF_BEGV (buf);
12988 if (end < start)
12989 end = start;
12990 if (whole < (end - start))
12991 whole = end - start;
12993 else
12994 start = end = whole = 0;
12996 /* Indicate what this scroll bar ought to be displaying now. */
12997 if (FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
12998 (*FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
12999 (w, end - start, whole, start);
13003 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
13004 selected_window is redisplayed.
13006 We can return without actually redisplaying the window if
13007 fonts_changed_p is nonzero. In that case, redisplay_internal will
13008 retry. */
13010 static void
13011 redisplay_window (window, just_this_one_p)
13012 Lisp_Object window;
13013 int just_this_one_p;
13015 struct window *w = XWINDOW (window);
13016 struct frame *f = XFRAME (w->frame);
13017 struct buffer *buffer = XBUFFER (w->buffer);
13018 struct buffer *old = current_buffer;
13019 struct text_pos lpoint, opoint, startp;
13020 int update_mode_line;
13021 int tem;
13022 struct it it;
13023 /* Record it now because it's overwritten. */
13024 int current_matrix_up_to_date_p = 0;
13025 int used_current_matrix_p = 0;
13026 /* This is less strict than current_matrix_up_to_date_p.
13027 It indictes that the buffer contents and narrowing are unchanged. */
13028 int buffer_unchanged_p = 0;
13029 int temp_scroll_step = 0;
13030 int count = SPECPDL_INDEX ();
13031 int rc;
13032 int centering_position = -1;
13033 int last_line_misfit = 0;
13034 int beg_unchanged, end_unchanged;
13036 SET_TEXT_POS (lpoint, PT, PT_BYTE);
13037 opoint = lpoint;
13039 /* W must be a leaf window here. */
13040 xassert (!NILP (w->buffer));
13041 #if GLYPH_DEBUG
13042 *w->desired_matrix->method = 0;
13043 #endif
13045 restart:
13046 reconsider_clip_changes (w, buffer);
13048 /* Has the mode line to be updated? */
13049 update_mode_line = (!NILP (w->update_mode_line)
13050 || update_mode_lines
13051 || buffer->clip_changed
13052 || buffer->prevent_redisplay_optimizations_p);
13054 if (MINI_WINDOW_P (w))
13056 if (w == XWINDOW (echo_area_window)
13057 && !NILP (echo_area_buffer[0]))
13059 if (update_mode_line)
13060 /* We may have to update a tty frame's menu bar or a
13061 tool-bar. Example `M-x C-h C-h C-g'. */
13062 goto finish_menu_bars;
13063 else
13064 /* We've already displayed the echo area glyphs in this window. */
13065 goto finish_scroll_bars;
13067 else if ((w != XWINDOW (minibuf_window)
13068 || minibuf_level == 0)
13069 /* When buffer is nonempty, redisplay window normally. */
13070 && BUF_Z (XBUFFER (w->buffer)) == BUF_BEG (XBUFFER (w->buffer))
13071 /* Quail displays non-mini buffers in minibuffer window.
13072 In that case, redisplay the window normally. */
13073 && !NILP (Fmemq (w->buffer, Vminibuffer_list)))
13075 /* W is a mini-buffer window, but it's not active, so clear
13076 it. */
13077 int yb = window_text_bottom_y (w);
13078 struct glyph_row *row;
13079 int y;
13081 for (y = 0, row = w->desired_matrix->rows;
13082 y < yb;
13083 y += row->height, ++row)
13084 blank_row (w, row, y);
13085 goto finish_scroll_bars;
13088 clear_glyph_matrix (w->desired_matrix);
13091 /* Otherwise set up data on this window; select its buffer and point
13092 value. */
13093 /* Really select the buffer, for the sake of buffer-local
13094 variables. */
13095 set_buffer_internal_1 (XBUFFER (w->buffer));
13097 current_matrix_up_to_date_p
13098 = (!NILP (w->window_end_valid)
13099 && !current_buffer->clip_changed
13100 && !current_buffer->prevent_redisplay_optimizations_p
13101 && XFASTINT (w->last_modified) >= MODIFF
13102 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF);
13104 /* Run the window-bottom-change-functions
13105 if it is possible that the text on the screen has changed
13106 (either due to modification of the text, or any other reason). */
13107 if (!current_matrix_up_to_date_p
13108 && !NILP (Vwindow_text_change_functions))
13110 safe_run_hooks (Qwindow_text_change_functions);
13111 goto restart;
13114 beg_unchanged = BEG_UNCHANGED;
13115 end_unchanged = END_UNCHANGED;
13117 SET_TEXT_POS (opoint, PT, PT_BYTE);
13119 specbind (Qinhibit_point_motion_hooks, Qt);
13121 buffer_unchanged_p
13122 = (!NILP (w->window_end_valid)
13123 && !current_buffer->clip_changed
13124 && XFASTINT (w->last_modified) >= MODIFF
13125 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF);
13127 /* When windows_or_buffers_changed is non-zero, we can't rely on
13128 the window end being valid, so set it to nil there. */
13129 if (windows_or_buffers_changed)
13131 /* If window starts on a continuation line, maybe adjust the
13132 window start in case the window's width changed. */
13133 if (XMARKER (w->start)->buffer == current_buffer)
13134 compute_window_start_on_continuation_line (w);
13136 w->window_end_valid = Qnil;
13139 /* Some sanity checks. */
13140 CHECK_WINDOW_END (w);
13141 if (Z == Z_BYTE && CHARPOS (opoint) != BYTEPOS (opoint))
13142 abort ();
13143 if (BYTEPOS (opoint) < CHARPOS (opoint))
13144 abort ();
13146 /* If %c is in mode line, update it if needed. */
13147 if (!NILP (w->column_number_displayed)
13148 /* This alternative quickly identifies a common case
13149 where no change is needed. */
13150 && !(PT == XFASTINT (w->last_point)
13151 && XFASTINT (w->last_modified) >= MODIFF
13152 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
13153 && (XFASTINT (w->column_number_displayed)
13154 != (int) current_column ())) /* iftc */
13155 update_mode_line = 1;
13157 /* Count number of windows showing the selected buffer. An indirect
13158 buffer counts as its base buffer. */
13159 if (!just_this_one_p)
13161 struct buffer *current_base, *window_base;
13162 current_base = current_buffer;
13163 window_base = XBUFFER (XWINDOW (selected_window)->buffer);
13164 if (current_base->base_buffer)
13165 current_base = current_base->base_buffer;
13166 if (window_base->base_buffer)
13167 window_base = window_base->base_buffer;
13168 if (current_base == window_base)
13169 buffer_shared++;
13172 /* Point refers normally to the selected window. For any other
13173 window, set up appropriate value. */
13174 if (!EQ (window, selected_window))
13176 int new_pt = XMARKER (w->pointm)->charpos;
13177 int new_pt_byte = marker_byte_position (w->pointm);
13178 if (new_pt < BEGV)
13180 new_pt = BEGV;
13181 new_pt_byte = BEGV_BYTE;
13182 set_marker_both (w->pointm, Qnil, BEGV, BEGV_BYTE);
13184 else if (new_pt > (ZV - 1))
13186 new_pt = ZV;
13187 new_pt_byte = ZV_BYTE;
13188 set_marker_both (w->pointm, Qnil, ZV, ZV_BYTE);
13191 /* We don't use SET_PT so that the point-motion hooks don't run. */
13192 TEMP_SET_PT_BOTH (new_pt, new_pt_byte);
13195 /* If any of the character widths specified in the display table
13196 have changed, invalidate the width run cache. It's true that
13197 this may be a bit late to catch such changes, but the rest of
13198 redisplay goes (non-fatally) haywire when the display table is
13199 changed, so why should we worry about doing any better? */
13200 if (current_buffer->width_run_cache)
13202 struct Lisp_Char_Table *disptab = buffer_display_table ();
13204 if (! disptab_matches_widthtab (disptab,
13205 XVECTOR (current_buffer->width_table)))
13207 invalidate_region_cache (current_buffer,
13208 current_buffer->width_run_cache,
13209 BEG, Z);
13210 recompute_width_table (current_buffer, disptab);
13214 /* If window-start is screwed up, choose a new one. */
13215 if (XMARKER (w->start)->buffer != current_buffer)
13216 goto recenter;
13218 SET_TEXT_POS_FROM_MARKER (startp, w->start);
13220 /* If someone specified a new starting point but did not insist,
13221 check whether it can be used. */
13222 if (!NILP (w->optional_new_start)
13223 && CHARPOS (startp) >= BEGV
13224 && CHARPOS (startp) <= ZV)
13226 w->optional_new_start = Qnil;
13227 start_display (&it, w, startp);
13228 move_it_to (&it, PT, 0, it.last_visible_y, -1,
13229 MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
13230 if (IT_CHARPOS (it) == PT)
13231 w->force_start = Qt;
13232 /* IT may overshoot PT if text at PT is invisible. */
13233 else if (IT_CHARPOS (it) > PT && CHARPOS (startp) <= PT)
13234 w->force_start = Qt;
13237 force_start:
13239 /* Handle case where place to start displaying has been specified,
13240 unless the specified location is outside the accessible range. */
13241 if (!NILP (w->force_start)
13242 || w->frozen_window_start_p)
13244 /* We set this later on if we have to adjust point. */
13245 int new_vpos = -1;
13246 int val;
13248 w->force_start = Qnil;
13249 w->vscroll = 0;
13250 w->window_end_valid = Qnil;
13252 /* Forget any recorded base line for line number display. */
13253 if (!buffer_unchanged_p)
13254 w->base_line_number = Qnil;
13256 /* Redisplay the mode line. Select the buffer properly for that.
13257 Also, run the hook window-scroll-functions
13258 because we have scrolled. */
13259 /* Note, we do this after clearing force_start because
13260 if there's an error, it is better to forget about force_start
13261 than to get into an infinite loop calling the hook functions
13262 and having them get more errors. */
13263 if (!update_mode_line
13264 || ! NILP (Vwindow_scroll_functions))
13266 update_mode_line = 1;
13267 w->update_mode_line = Qt;
13268 startp = run_window_scroll_functions (window, startp);
13271 w->last_modified = make_number (0);
13272 w->last_overlay_modified = make_number (0);
13273 if (CHARPOS (startp) < BEGV)
13274 SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
13275 else if (CHARPOS (startp) > ZV)
13276 SET_TEXT_POS (startp, ZV, ZV_BYTE);
13278 /* Redisplay, then check if cursor has been set during the
13279 redisplay. Give up if new fonts were loaded. */
13280 val = try_window (window, startp, 1);
13281 if (!val)
13283 w->force_start = Qt;
13284 clear_glyph_matrix (w->desired_matrix);
13285 goto need_larger_matrices;
13287 /* Point was outside the scroll margins. */
13288 if (val < 0)
13289 new_vpos = window_box_height (w) / 2;
13291 if (w->cursor.vpos < 0 && !w->frozen_window_start_p)
13293 /* If point does not appear, try to move point so it does
13294 appear. The desired matrix has been built above, so we
13295 can use it here. */
13296 new_vpos = window_box_height (w) / 2;
13299 if (!cursor_row_fully_visible_p (w, 0, 0))
13301 /* Point does appear, but on a line partly visible at end of window.
13302 Move it back to a fully-visible line. */
13303 new_vpos = window_box_height (w);
13306 /* If we need to move point for either of the above reasons,
13307 now actually do it. */
13308 if (new_vpos >= 0)
13310 struct glyph_row *row;
13312 row = MATRIX_FIRST_TEXT_ROW (w->desired_matrix);
13313 while (MATRIX_ROW_BOTTOM_Y (row) < new_vpos)
13314 ++row;
13316 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row),
13317 MATRIX_ROW_START_BYTEPOS (row));
13319 if (w != XWINDOW (selected_window))
13320 set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
13321 else if (current_buffer == old)
13322 SET_TEXT_POS (lpoint, PT, PT_BYTE);
13324 set_cursor_from_row (w, row, w->desired_matrix, 0, 0, 0, 0);
13326 /* If we are highlighting the region, then we just changed
13327 the region, so redisplay to show it. */
13328 if (!NILP (Vtransient_mark_mode)
13329 && !NILP (current_buffer->mark_active))
13331 clear_glyph_matrix (w->desired_matrix);
13332 if (!try_window (window, startp, 0))
13333 goto need_larger_matrices;
13337 #if GLYPH_DEBUG
13338 debug_method_add (w, "forced window start");
13339 #endif
13340 goto done;
13343 /* Handle case where text has not changed, only point, and it has
13344 not moved off the frame, and we are not retrying after hscroll.
13345 (current_matrix_up_to_date_p is nonzero when retrying.) */
13346 if (current_matrix_up_to_date_p
13347 && (rc = try_cursor_movement (window, startp, &temp_scroll_step),
13348 rc != CURSOR_MOVEMENT_CANNOT_BE_USED))
13350 switch (rc)
13352 case CURSOR_MOVEMENT_SUCCESS:
13353 used_current_matrix_p = 1;
13354 goto done;
13356 #if 0 /* try_cursor_movement never returns this value. */
13357 case CURSOR_MOVEMENT_NEED_LARGER_MATRICES:
13358 goto need_larger_matrices;
13359 #endif
13361 case CURSOR_MOVEMENT_MUST_SCROLL:
13362 goto try_to_scroll;
13364 default:
13365 abort ();
13368 /* If current starting point was originally the beginning of a line
13369 but no longer is, find a new starting point. */
13370 else if (!NILP (w->start_at_line_beg)
13371 && !(CHARPOS (startp) <= BEGV
13372 || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n'))
13374 #if GLYPH_DEBUG
13375 debug_method_add (w, "recenter 1");
13376 #endif
13377 goto recenter;
13380 /* Try scrolling with try_window_id. Value is > 0 if update has
13381 been done, it is -1 if we know that the same window start will
13382 not work. It is 0 if unsuccessful for some other reason. */
13383 else if ((tem = try_window_id (w)) != 0)
13385 #if GLYPH_DEBUG
13386 debug_method_add (w, "try_window_id %d", tem);
13387 #endif
13389 if (fonts_changed_p)
13390 goto need_larger_matrices;
13391 if (tem > 0)
13392 goto done;
13394 /* Otherwise try_window_id has returned -1 which means that we
13395 don't want the alternative below this comment to execute. */
13397 else if (CHARPOS (startp) >= BEGV
13398 && CHARPOS (startp) <= ZV
13399 && PT >= CHARPOS (startp)
13400 && (CHARPOS (startp) < ZV
13401 /* Avoid starting at end of buffer. */
13402 || CHARPOS (startp) == BEGV
13403 || (XFASTINT (w->last_modified) >= MODIFF
13404 && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)))
13407 /* If first window line is a continuation line, and window start
13408 is inside the modified region, but the first change is before
13409 current window start, we must select a new window start.
13411 However, if this is the result of a down-mouse event (e.g. by
13412 extending the mouse-drag-overlay), we don't want to select a
13413 new window start, since that would change the position under
13414 the mouse, resulting in an unwanted mouse-movement rather
13415 than a simple mouse-click. */
13416 if (NILP (w->start_at_line_beg)
13417 && NILP (do_mouse_tracking)
13418 && CHARPOS (startp) > BEGV
13419 && CHARPOS (startp) > BEG + beg_unchanged
13420 && CHARPOS (startp) <= Z - end_unchanged)
13422 w->force_start = Qt;
13423 if (XMARKER (w->start)->buffer == current_buffer)
13424 compute_window_start_on_continuation_line (w);
13425 SET_TEXT_POS_FROM_MARKER (startp, w->start);
13426 goto force_start;
13429 #if GLYPH_DEBUG
13430 debug_method_add (w, "same window start");
13431 #endif
13433 /* Try to redisplay starting at same place as before.
13434 If point has not moved off frame, accept the results. */
13435 if (!current_matrix_up_to_date_p
13436 /* Don't use try_window_reusing_current_matrix in this case
13437 because a window scroll function can have changed the
13438 buffer. */
13439 || !NILP (Vwindow_scroll_functions)
13440 || MINI_WINDOW_P (w)
13441 || !(used_current_matrix_p
13442 = try_window_reusing_current_matrix (w)))
13444 IF_DEBUG (debug_method_add (w, "1"));
13445 if (try_window (window, startp, 1) < 0)
13446 /* -1 means we need to scroll.
13447 0 means we need new matrices, but fonts_changed_p
13448 is set in that case, so we will detect it below. */
13449 goto try_to_scroll;
13452 if (fonts_changed_p)
13453 goto need_larger_matrices;
13455 if (w->cursor.vpos >= 0)
13457 if (!just_this_one_p
13458 || current_buffer->clip_changed
13459 || BEG_UNCHANGED < CHARPOS (startp))
13460 /* Forget any recorded base line for line number display. */
13461 w->base_line_number = Qnil;
13463 if (!cursor_row_fully_visible_p (w, 1, 0))
13465 clear_glyph_matrix (w->desired_matrix);
13466 last_line_misfit = 1;
13468 /* Drop through and scroll. */
13469 else
13470 goto done;
13472 else
13473 clear_glyph_matrix (w->desired_matrix);
13476 try_to_scroll:
13478 w->last_modified = make_number (0);
13479 w->last_overlay_modified = make_number (0);
13481 /* Redisplay the mode line. Select the buffer properly for that. */
13482 if (!update_mode_line)
13484 update_mode_line = 1;
13485 w->update_mode_line = Qt;
13488 /* Try to scroll by specified few lines. */
13489 if ((scroll_conservatively
13490 || scroll_step
13491 || temp_scroll_step
13492 || NUMBERP (current_buffer->scroll_up_aggressively)
13493 || NUMBERP (current_buffer->scroll_down_aggressively))
13494 && !current_buffer->clip_changed
13495 && CHARPOS (startp) >= BEGV
13496 && CHARPOS (startp) <= ZV)
13498 /* The function returns -1 if new fonts were loaded, 1 if
13499 successful, 0 if not successful. */
13500 int rc = try_scrolling (window, just_this_one_p,
13501 scroll_conservatively,
13502 scroll_step,
13503 temp_scroll_step, last_line_misfit);
13504 switch (rc)
13506 case SCROLLING_SUCCESS:
13507 goto done;
13509 case SCROLLING_NEED_LARGER_MATRICES:
13510 goto need_larger_matrices;
13512 case SCROLLING_FAILED:
13513 break;
13515 default:
13516 abort ();
13520 /* Finally, just choose place to start which centers point */
13522 recenter:
13523 if (centering_position < 0)
13524 centering_position = window_box_height (w) / 2;
13526 #if GLYPH_DEBUG
13527 debug_method_add (w, "recenter");
13528 #endif
13530 /* w->vscroll = 0; */
13532 /* Forget any previously recorded base line for line number display. */
13533 if (!buffer_unchanged_p)
13534 w->base_line_number = Qnil;
13536 /* Move backward half the height of the window. */
13537 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
13538 it.current_y = it.last_visible_y;
13539 move_it_vertically_backward (&it, centering_position);
13540 xassert (IT_CHARPOS (it) >= BEGV);
13542 /* The function move_it_vertically_backward may move over more
13543 than the specified y-distance. If it->w is small, e.g. a
13544 mini-buffer window, we may end up in front of the window's
13545 display area. Start displaying at the start of the line
13546 containing PT in this case. */
13547 if (it.current_y <= 0)
13549 init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
13550 move_it_vertically_backward (&it, 0);
13551 #if 0
13552 /* I think this assert is bogus if buffer contains
13553 invisible text or images. KFS. */
13554 xassert (IT_CHARPOS (it) <= PT);
13555 #endif
13556 it.current_y = 0;
13559 it.current_x = it.hpos = 0;
13561 /* Set startp here explicitly in case that helps avoid an infinite loop
13562 in case the window-scroll-functions functions get errors. */
13563 set_marker_both (w->start, Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
13565 /* Run scroll hooks. */
13566 startp = run_window_scroll_functions (window, it.current.pos);
13568 /* Redisplay the window. */
13569 if (!current_matrix_up_to_date_p
13570 || windows_or_buffers_changed
13571 || cursor_type_changed
13572 /* Don't use try_window_reusing_current_matrix in this case
13573 because it can have changed the buffer. */
13574 || !NILP (Vwindow_scroll_functions)
13575 || !just_this_one_p
13576 || MINI_WINDOW_P (w)
13577 || !(used_current_matrix_p
13578 = try_window_reusing_current_matrix (w)))
13579 try_window (window, startp, 0);
13581 /* If new fonts have been loaded (due to fontsets), give up. We
13582 have to start a new redisplay since we need to re-adjust glyph
13583 matrices. */
13584 if (fonts_changed_p)
13585 goto need_larger_matrices;
13587 /* If cursor did not appear assume that the middle of the window is
13588 in the first line of the window. Do it again with the next line.
13589 (Imagine a window of height 100, displaying two lines of height
13590 60. Moving back 50 from it->last_visible_y will end in the first
13591 line.) */
13592 if (w->cursor.vpos < 0)
13594 if (!NILP (w->window_end_valid)
13595 && PT >= Z - XFASTINT (w->window_end_pos))
13597 clear_glyph_matrix (w->desired_matrix);
13598 move_it_by_lines (&it, 1, 0);
13599 try_window (window, it.current.pos, 0);
13601 else if (PT < IT_CHARPOS (it))
13603 clear_glyph_matrix (w->desired_matrix);
13604 move_it_by_lines (&it, -1, 0);
13605 try_window (window, it.current.pos, 0);
13607 else
13609 /* Not much we can do about it. */
13613 /* Consider the following case: Window starts at BEGV, there is
13614 invisible, intangible text at BEGV, so that display starts at
13615 some point START > BEGV. It can happen that we are called with
13616 PT somewhere between BEGV and START. Try to handle that case. */
13617 if (w->cursor.vpos < 0)
13619 struct glyph_row *row = w->current_matrix->rows;
13620 if (row->mode_line_p)
13621 ++row;
13622 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
13625 if (!cursor_row_fully_visible_p (w, 0, 0))
13627 /* If vscroll is enabled, disable it and try again. */
13628 if (w->vscroll)
13630 w->vscroll = 0;
13631 clear_glyph_matrix (w->desired_matrix);
13632 goto recenter;
13635 /* If centering point failed to make the whole line visible,
13636 put point at the top instead. That has to make the whole line
13637 visible, if it can be done. */
13638 if (centering_position == 0)
13639 goto done;
13641 clear_glyph_matrix (w->desired_matrix);
13642 centering_position = 0;
13643 goto recenter;
13646 done:
13648 SET_TEXT_POS_FROM_MARKER (startp, w->start);
13649 w->start_at_line_beg = ((CHARPOS (startp) == BEGV
13650 || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n')
13651 ? Qt : Qnil);
13653 /* Display the mode line, if we must. */
13654 if ((update_mode_line
13655 /* If window not full width, must redo its mode line
13656 if (a) the window to its side is being redone and
13657 (b) we do a frame-based redisplay. This is a consequence
13658 of how inverted lines are drawn in frame-based redisplay. */
13659 || (!just_this_one_p
13660 && !FRAME_WINDOW_P (f)
13661 && !WINDOW_FULL_WIDTH_P (w))
13662 /* Line number to display. */
13663 || INTEGERP (w->base_line_pos)
13664 /* Column number is displayed and different from the one displayed. */
13665 || (!NILP (w->column_number_displayed)
13666 && (XFASTINT (w->column_number_displayed)
13667 != (int) current_column ()))) /* iftc */
13668 /* This means that the window has a mode line. */
13669 && (WINDOW_WANTS_MODELINE_P (w)
13670 || WINDOW_WANTS_HEADER_LINE_P (w)))
13672 display_mode_lines (w);
13674 /* If mode line height has changed, arrange for a thorough
13675 immediate redisplay using the correct mode line height. */
13676 if (WINDOW_WANTS_MODELINE_P (w)
13677 && CURRENT_MODE_LINE_HEIGHT (w) != DESIRED_MODE_LINE_HEIGHT (w))
13679 fonts_changed_p = 1;
13680 MATRIX_MODE_LINE_ROW (w->current_matrix)->height
13681 = DESIRED_MODE_LINE_HEIGHT (w);
13684 /* If top line height has changed, arrange for a thorough
13685 immediate redisplay using the correct mode line height. */
13686 if (WINDOW_WANTS_HEADER_LINE_P (w)
13687 && CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
13689 fonts_changed_p = 1;
13690 MATRIX_HEADER_LINE_ROW (w->current_matrix)->height
13691 = DESIRED_HEADER_LINE_HEIGHT (w);
13694 if (fonts_changed_p)
13695 goto need_larger_matrices;
13698 if (!line_number_displayed
13699 && !BUFFERP (w->base_line_pos))
13701 w->base_line_pos = Qnil;
13702 w->base_line_number = Qnil;
13705 finish_menu_bars:
13707 /* When we reach a frame's selected window, redo the frame's menu bar. */
13708 if (update_mode_line
13709 && EQ (FRAME_SELECTED_WINDOW (f), window))
13711 int redisplay_menu_p = 0;
13712 int redisplay_tool_bar_p = 0;
13714 if (FRAME_WINDOW_P (f))
13716 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
13717 || defined (USE_GTK)
13718 redisplay_menu_p = FRAME_EXTERNAL_MENU_BAR (f);
13719 #else
13720 redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
13721 #endif
13723 else
13724 redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
13726 if (redisplay_menu_p)
13727 display_menu_bar (w);
13729 #ifdef HAVE_WINDOW_SYSTEM
13730 if (FRAME_WINDOW_P (f))
13732 #if defined (USE_GTK) || USE_MAC_TOOLBAR
13733 redisplay_tool_bar_p = FRAME_EXTERNAL_TOOL_BAR (f);
13734 #else
13735 redisplay_tool_bar_p = WINDOWP (f->tool_bar_window)
13736 && (FRAME_TOOL_BAR_LINES (f) > 0
13737 || !NILP (Vauto_resize_tool_bars));
13738 #endif
13740 if (redisplay_tool_bar_p && redisplay_tool_bar (f))
13742 extern int ignore_mouse_drag_p;
13743 ignore_mouse_drag_p = 1;
13746 #endif
13749 #ifdef HAVE_WINDOW_SYSTEM
13750 if (FRAME_WINDOW_P (f)
13751 && update_window_fringes (w, (just_this_one_p
13752 || (!used_current_matrix_p && !overlay_arrow_seen)
13753 || w->pseudo_window_p)))
13755 update_begin (f);
13756 BLOCK_INPUT;
13757 if (draw_window_fringes (w, 1))
13758 x_draw_vertical_border (w);
13759 UNBLOCK_INPUT;
13760 update_end (f);
13762 #endif /* HAVE_WINDOW_SYSTEM */
13764 /* We go to this label, with fonts_changed_p nonzero,
13765 if it is necessary to try again using larger glyph matrices.
13766 We have to redeem the scroll bar even in this case,
13767 because the loop in redisplay_internal expects that. */
13768 need_larger_matrices:
13770 finish_scroll_bars:
13772 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
13774 /* Set the thumb's position and size. */
13775 set_vertical_scroll_bar (w);
13777 /* Note that we actually used the scroll bar attached to this
13778 window, so it shouldn't be deleted at the end of redisplay. */
13779 if (FRAME_TERMINAL (f)->redeem_scroll_bar_hook)
13780 (*FRAME_TERMINAL (f)->redeem_scroll_bar_hook) (w);
13783 /* Restore current_buffer and value of point in it. */
13784 TEMP_SET_PT_BOTH (CHARPOS (opoint), BYTEPOS (opoint));
13785 set_buffer_internal_1 (old);
13786 /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
13787 shorter. This can be caused by log truncation in *Messages*. */
13788 if (CHARPOS (lpoint) <= ZV)
13789 TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
13791 unbind_to (count, Qnil);
13795 /* Build the complete desired matrix of WINDOW with a window start
13796 buffer position POS.
13798 Value is 1 if successful. It is zero if fonts were loaded during
13799 redisplay which makes re-adjusting glyph matrices necessary, and -1
13800 if point would appear in the scroll margins.
13801 (We check that only if CHECK_MARGINS is nonzero. */
13804 try_window (window, pos, check_margins)
13805 Lisp_Object window;
13806 struct text_pos pos;
13807 int check_margins;
13809 struct window *w = XWINDOW (window);
13810 struct it it;
13811 struct glyph_row *last_text_row = NULL;
13812 struct frame *f = XFRAME (w->frame);
13814 /* Make POS the new window start. */
13815 set_marker_both (w->start, Qnil, CHARPOS (pos), BYTEPOS (pos));
13817 /* Mark cursor position as unknown. No overlay arrow seen. */
13818 w->cursor.vpos = -1;
13819 overlay_arrow_seen = 0;
13821 /* Initialize iterator and info to start at POS. */
13822 start_display (&it, w, pos);
13824 /* Display all lines of W. */
13825 while (it.current_y < it.last_visible_y)
13827 if (display_line (&it))
13828 last_text_row = it.glyph_row - 1;
13829 if (fonts_changed_p)
13830 return 0;
13833 /* Don't let the cursor end in the scroll margins. */
13834 if (check_margins
13835 && !MINI_WINDOW_P (w))
13837 int this_scroll_margin;
13839 this_scroll_margin = max (0, scroll_margin);
13840 this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
13841 this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
13843 if ((w->cursor.y >= 0 /* not vscrolled */
13844 && w->cursor.y < this_scroll_margin
13845 && CHARPOS (pos) > BEGV
13846 && IT_CHARPOS (it) < ZV)
13847 /* rms: considering make_cursor_line_fully_visible_p here
13848 seems to give wrong results. We don't want to recenter
13849 when the last line is partly visible, we want to allow
13850 that case to be handled in the usual way. */
13851 || (w->cursor.y + 1) > it.last_visible_y)
13853 w->cursor.vpos = -1;
13854 clear_glyph_matrix (w->desired_matrix);
13855 return -1;
13859 /* If bottom moved off end of frame, change mode line percentage. */
13860 if (XFASTINT (w->window_end_pos) <= 0
13861 && Z != IT_CHARPOS (it))
13862 w->update_mode_line = Qt;
13864 /* Set window_end_pos to the offset of the last character displayed
13865 on the window from the end of current_buffer. Set
13866 window_end_vpos to its row number. */
13867 if (last_text_row)
13869 xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
13870 w->window_end_bytepos
13871 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
13872 w->window_end_pos
13873 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
13874 w->window_end_vpos
13875 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
13876 xassert (MATRIX_ROW (w->desired_matrix, XFASTINT (w->window_end_vpos))
13877 ->displays_text_p);
13879 else
13881 w->window_end_bytepos = Z_BYTE - ZV_BYTE;
13882 w->window_end_pos = make_number (Z - ZV);
13883 w->window_end_vpos = make_number (0);
13886 /* But that is not valid info until redisplay finishes. */
13887 w->window_end_valid = Qnil;
13888 return 1;
13893 /************************************************************************
13894 Window redisplay reusing current matrix when buffer has not changed
13895 ************************************************************************/
13897 /* Try redisplay of window W showing an unchanged buffer with a
13898 different window start than the last time it was displayed by
13899 reusing its current matrix. Value is non-zero if successful.
13900 W->start is the new window start. */
13902 static int
13903 try_window_reusing_current_matrix (w)
13904 struct window *w;
13906 struct frame *f = XFRAME (w->frame);
13907 struct glyph_row *row, *bottom_row;
13908 struct it it;
13909 struct run run;
13910 struct text_pos start, new_start;
13911 int nrows_scrolled, i;
13912 struct glyph_row *last_text_row;
13913 struct glyph_row *last_reused_text_row;
13914 struct glyph_row *start_row;
13915 int start_vpos, min_y, max_y;
13917 #if GLYPH_DEBUG
13918 if (inhibit_try_window_reusing)
13919 return 0;
13920 #endif
13922 if (/* This function doesn't handle terminal frames. */
13923 !FRAME_WINDOW_P (f)
13924 /* Don't try to reuse the display if windows have been split
13925 or such. */
13926 || windows_or_buffers_changed
13927 || cursor_type_changed)
13928 return 0;
13930 /* Can't do this if region may have changed. */
13931 if ((!NILP (Vtransient_mark_mode)
13932 && !NILP (current_buffer->mark_active))
13933 || !NILP (w->region_showing)
13934 || !NILP (Vshow_trailing_whitespace))
13935 return 0;
13937 /* If top-line visibility has changed, give up. */
13938 if (WINDOW_WANTS_HEADER_LINE_P (w)
13939 != MATRIX_HEADER_LINE_ROW (w->current_matrix)->mode_line_p)
13940 return 0;
13942 /* Give up if old or new display is scrolled vertically. We could
13943 make this function handle this, but right now it doesn't. */
13944 start_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
13945 if (w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row))
13946 return 0;
13948 /* The variable new_start now holds the new window start. The old
13949 start `start' can be determined from the current matrix. */
13950 SET_TEXT_POS_FROM_MARKER (new_start, w->start);
13951 start = start_row->start.pos;
13952 start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
13954 /* Clear the desired matrix for the display below. */
13955 clear_glyph_matrix (w->desired_matrix);
13957 if (CHARPOS (new_start) <= CHARPOS (start))
13959 int first_row_y;
13961 /* Don't use this method if the display starts with an ellipsis
13962 displayed for invisible text. It's not easy to handle that case
13963 below, and it's certainly not worth the effort since this is
13964 not a frequent case. */
13965 if (in_ellipses_for_invisible_text_p (&start_row->start, w))
13966 return 0;
13968 IF_DEBUG (debug_method_add (w, "twu1"));
13970 /* Display up to a row that can be reused. The variable
13971 last_text_row is set to the last row displayed that displays
13972 text. Note that it.vpos == 0 if or if not there is a
13973 header-line; it's not the same as the MATRIX_ROW_VPOS! */
13974 start_display (&it, w, new_start);
13975 first_row_y = it.current_y;
13976 w->cursor.vpos = -1;
13977 last_text_row = last_reused_text_row = NULL;
13979 while (it.current_y < it.last_visible_y
13980 && !fonts_changed_p)
13982 /* If we have reached into the characters in the START row,
13983 that means the line boundaries have changed. So we
13984 can't start copying with the row START. Maybe it will
13985 work to start copying with the following row. */
13986 while (IT_CHARPOS (it) > CHARPOS (start))
13988 /* Advance to the next row as the "start". */
13989 start_row++;
13990 start = start_row->start.pos;
13991 /* If there are no more rows to try, or just one, give up. */
13992 if (start_row == MATRIX_MODE_LINE_ROW (w->current_matrix) - 1
13993 || w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row)
13994 || CHARPOS (start) == ZV)
13996 clear_glyph_matrix (w->desired_matrix);
13997 return 0;
14000 start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
14002 /* If we have reached alignment,
14003 we can copy the rest of the rows. */
14004 if (IT_CHARPOS (it) == CHARPOS (start))
14005 break;
14007 if (display_line (&it))
14008 last_text_row = it.glyph_row - 1;
14011 /* A value of current_y < last_visible_y means that we stopped
14012 at the previous window start, which in turn means that we
14013 have at least one reusable row. */
14014 if (it.current_y < it.last_visible_y)
14016 /* IT.vpos always starts from 0; it counts text lines. */
14017 nrows_scrolled = it.vpos - (start_row - MATRIX_FIRST_TEXT_ROW (w->current_matrix));
14019 /* Find PT if not already found in the lines displayed. */
14020 if (w->cursor.vpos < 0)
14022 int dy = it.current_y - start_row->y;
14024 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
14025 row = row_containing_pos (w, PT, row, NULL, dy);
14026 if (row)
14027 set_cursor_from_row (w, row, w->current_matrix, 0, 0,
14028 dy, nrows_scrolled);
14029 else
14031 clear_glyph_matrix (w->desired_matrix);
14032 return 0;
14036 /* Scroll the display. Do it before the current matrix is
14037 changed. The problem here is that update has not yet
14038 run, i.e. part of the current matrix is not up to date.
14039 scroll_run_hook will clear the cursor, and use the
14040 current matrix to get the height of the row the cursor is
14041 in. */
14042 run.current_y = start_row->y;
14043 run.desired_y = it.current_y;
14044 run.height = it.last_visible_y - it.current_y;
14046 if (run.height > 0 && run.current_y != run.desired_y)
14048 update_begin (f);
14049 FRAME_RIF (f)->update_window_begin_hook (w);
14050 FRAME_RIF (f)->clear_window_mouse_face (w);
14051 FRAME_RIF (f)->scroll_run_hook (w, &run);
14052 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
14053 update_end (f);
14056 /* Shift current matrix down by nrows_scrolled lines. */
14057 bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
14058 rotate_matrix (w->current_matrix,
14059 start_vpos,
14060 MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
14061 nrows_scrolled);
14063 /* Disable lines that must be updated. */
14064 for (i = 0; i < nrows_scrolled; ++i)
14065 (start_row + i)->enabled_p = 0;
14067 /* Re-compute Y positions. */
14068 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
14069 max_y = it.last_visible_y;
14070 for (row = start_row + nrows_scrolled;
14071 row < bottom_row;
14072 ++row)
14074 row->y = it.current_y;
14075 row->visible_height = row->height;
14077 if (row->y < min_y)
14078 row->visible_height -= min_y - row->y;
14079 if (row->y + row->height > max_y)
14080 row->visible_height -= row->y + row->height - max_y;
14081 row->redraw_fringe_bitmaps_p = 1;
14083 it.current_y += row->height;
14085 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
14086 last_reused_text_row = row;
14087 if (MATRIX_ROW_BOTTOM_Y (row) >= it.last_visible_y)
14088 break;
14091 /* Disable lines in the current matrix which are now
14092 below the window. */
14093 for (++row; row < bottom_row; ++row)
14094 row->enabled_p = row->mode_line_p = 0;
14097 /* Update window_end_pos etc.; last_reused_text_row is the last
14098 reused row from the current matrix containing text, if any.
14099 The value of last_text_row is the last displayed line
14100 containing text. */
14101 if (last_reused_text_row)
14103 w->window_end_bytepos
14104 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_reused_text_row);
14105 w->window_end_pos
14106 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row));
14107 w->window_end_vpos
14108 = make_number (MATRIX_ROW_VPOS (last_reused_text_row,
14109 w->current_matrix));
14111 else if (last_text_row)
14113 w->window_end_bytepos
14114 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
14115 w->window_end_pos
14116 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
14117 w->window_end_vpos
14118 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
14120 else
14122 /* This window must be completely empty. */
14123 w->window_end_bytepos = Z_BYTE - ZV_BYTE;
14124 w->window_end_pos = make_number (Z - ZV);
14125 w->window_end_vpos = make_number (0);
14127 w->window_end_valid = Qnil;
14129 /* Update hint: don't try scrolling again in update_window. */
14130 w->desired_matrix->no_scrolling_p = 1;
14132 #if GLYPH_DEBUG
14133 debug_method_add (w, "try_window_reusing_current_matrix 1");
14134 #endif
14135 return 1;
14137 else if (CHARPOS (new_start) > CHARPOS (start))
14139 struct glyph_row *pt_row, *row;
14140 struct glyph_row *first_reusable_row;
14141 struct glyph_row *first_row_to_display;
14142 int dy;
14143 int yb = window_text_bottom_y (w);
14145 /* Find the row starting at new_start, if there is one. Don't
14146 reuse a partially visible line at the end. */
14147 first_reusable_row = start_row;
14148 while (first_reusable_row->enabled_p
14149 && MATRIX_ROW_BOTTOM_Y (first_reusable_row) < yb
14150 && (MATRIX_ROW_START_CHARPOS (first_reusable_row)
14151 < CHARPOS (new_start)))
14152 ++first_reusable_row;
14154 /* Give up if there is no row to reuse. */
14155 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row) >= yb
14156 || !first_reusable_row->enabled_p
14157 || (MATRIX_ROW_START_CHARPOS (first_reusable_row)
14158 != CHARPOS (new_start)))
14159 return 0;
14161 /* We can reuse fully visible rows beginning with
14162 first_reusable_row to the end of the window. Set
14163 first_row_to_display to the first row that cannot be reused.
14164 Set pt_row to the row containing point, if there is any. */
14165 pt_row = NULL;
14166 for (first_row_to_display = first_reusable_row;
14167 MATRIX_ROW_BOTTOM_Y (first_row_to_display) < yb;
14168 ++first_row_to_display)
14170 if (PT >= MATRIX_ROW_START_CHARPOS (first_row_to_display)
14171 && PT < MATRIX_ROW_END_CHARPOS (first_row_to_display))
14172 pt_row = first_row_to_display;
14175 /* Start displaying at the start of first_row_to_display. */
14176 xassert (first_row_to_display->y < yb);
14177 init_to_row_start (&it, w, first_row_to_display);
14179 nrows_scrolled = (MATRIX_ROW_VPOS (first_reusable_row, w->current_matrix)
14180 - start_vpos);
14181 it.vpos = (MATRIX_ROW_VPOS (first_row_to_display, w->current_matrix)
14182 - nrows_scrolled);
14183 it.current_y = (first_row_to_display->y - first_reusable_row->y
14184 + WINDOW_HEADER_LINE_HEIGHT (w));
14186 /* Display lines beginning with first_row_to_display in the
14187 desired matrix. Set last_text_row to the last row displayed
14188 that displays text. */
14189 it.glyph_row = MATRIX_ROW (w->desired_matrix, it.vpos);
14190 if (pt_row == NULL)
14191 w->cursor.vpos = -1;
14192 last_text_row = NULL;
14193 while (it.current_y < it.last_visible_y && !fonts_changed_p)
14194 if (display_line (&it))
14195 last_text_row = it.glyph_row - 1;
14197 /* Give up If point isn't in a row displayed or reused. */
14198 if (w->cursor.vpos < 0)
14200 clear_glyph_matrix (w->desired_matrix);
14201 return 0;
14204 /* If point is in a reused row, adjust y and vpos of the cursor
14205 position. */
14206 if (pt_row)
14208 w->cursor.vpos -= nrows_scrolled;
14209 w->cursor.y -= first_reusable_row->y - start_row->y;
14212 /* Scroll the display. */
14213 run.current_y = first_reusable_row->y;
14214 run.desired_y = WINDOW_HEADER_LINE_HEIGHT (w);
14215 run.height = it.last_visible_y - run.current_y;
14216 dy = run.current_y - run.desired_y;
14218 if (run.height)
14220 update_begin (f);
14221 FRAME_RIF (f)->update_window_begin_hook (w);
14222 FRAME_RIF (f)->clear_window_mouse_face (w);
14223 FRAME_RIF (f)->scroll_run_hook (w, &run);
14224 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
14225 update_end (f);
14228 /* Adjust Y positions of reused rows. */
14229 bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
14230 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
14231 max_y = it.last_visible_y;
14232 for (row = first_reusable_row; row < first_row_to_display; ++row)
14234 row->y -= dy;
14235 row->visible_height = row->height;
14236 if (row->y < min_y)
14237 row->visible_height -= min_y - row->y;
14238 if (row->y + row->height > max_y)
14239 row->visible_height -= row->y + row->height - max_y;
14240 row->redraw_fringe_bitmaps_p = 1;
14243 /* Scroll the current matrix. */
14244 xassert (nrows_scrolled > 0);
14245 rotate_matrix (w->current_matrix,
14246 start_vpos,
14247 MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
14248 -nrows_scrolled);
14250 /* Disable rows not reused. */
14251 for (row -= nrows_scrolled; row < bottom_row; ++row)
14252 row->enabled_p = 0;
14254 /* Point may have moved to a different line, so we cannot assume that
14255 the previous cursor position is valid; locate the correct row. */
14256 if (pt_row)
14258 for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
14259 row < bottom_row && PT >= MATRIX_ROW_END_CHARPOS (row);
14260 row++)
14262 w->cursor.vpos++;
14263 w->cursor.y = row->y;
14265 if (row < bottom_row)
14267 struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
14268 while (glyph->charpos < PT)
14270 w->cursor.hpos++;
14271 w->cursor.x += glyph->pixel_width;
14272 glyph++;
14277 /* Adjust window end. A null value of last_text_row means that
14278 the window end is in reused rows which in turn means that
14279 only its vpos can have changed. */
14280 if (last_text_row)
14282 w->window_end_bytepos
14283 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
14284 w->window_end_pos
14285 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
14286 w->window_end_vpos
14287 = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
14289 else
14291 w->window_end_vpos
14292 = make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled);
14295 w->window_end_valid = Qnil;
14296 w->desired_matrix->no_scrolling_p = 1;
14298 #if GLYPH_DEBUG
14299 debug_method_add (w, "try_window_reusing_current_matrix 2");
14300 #endif
14301 return 1;
14304 return 0;
14309 /************************************************************************
14310 Window redisplay reusing current matrix when buffer has changed
14311 ************************************************************************/
14313 static struct glyph_row *find_last_unchanged_at_beg_row P_ ((struct window *));
14314 static struct glyph_row *find_first_unchanged_at_end_row P_ ((struct window *,
14315 int *, int *));
14316 static struct glyph_row *
14317 find_last_row_displaying_text P_ ((struct glyph_matrix *, struct it *,
14318 struct glyph_row *));
14321 /* Return the last row in MATRIX displaying text. If row START is
14322 non-null, start searching with that row. IT gives the dimensions
14323 of the display. Value is null if matrix is empty; otherwise it is
14324 a pointer to the row found. */
14326 static struct glyph_row *
14327 find_last_row_displaying_text (matrix, it, start)
14328 struct glyph_matrix *matrix;
14329 struct it *it;
14330 struct glyph_row *start;
14332 struct glyph_row *row, *row_found;
14334 /* Set row_found to the last row in IT->w's current matrix
14335 displaying text. The loop looks funny but think of partially
14336 visible lines. */
14337 row_found = NULL;
14338 row = start ? start : MATRIX_FIRST_TEXT_ROW (matrix);
14339 while (MATRIX_ROW_DISPLAYS_TEXT_P (row))
14341 xassert (row->enabled_p);
14342 row_found = row;
14343 if (MATRIX_ROW_BOTTOM_Y (row) >= it->last_visible_y)
14344 break;
14345 ++row;
14348 return row_found;
14352 /* Return the last row in the current matrix of W that is not affected
14353 by changes at the start of current_buffer that occurred since W's
14354 current matrix was built. Value is null if no such row exists.
14356 BEG_UNCHANGED us the number of characters unchanged at the start of
14357 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
14358 first changed character in current_buffer. Characters at positions <
14359 BEG + BEG_UNCHANGED are at the same buffer positions as they were
14360 when the current matrix was built. */
14362 static struct glyph_row *
14363 find_last_unchanged_at_beg_row (w)
14364 struct window *w;
14366 int first_changed_pos = BEG + BEG_UNCHANGED;
14367 struct glyph_row *row;
14368 struct glyph_row *row_found = NULL;
14369 int yb = window_text_bottom_y (w);
14371 /* Find the last row displaying unchanged text. */
14372 row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
14373 while (MATRIX_ROW_DISPLAYS_TEXT_P (row)
14374 && MATRIX_ROW_START_CHARPOS (row) < first_changed_pos)
14376 if (/* If row ends before first_changed_pos, it is unchanged,
14377 except in some case. */
14378 MATRIX_ROW_END_CHARPOS (row) <= first_changed_pos
14379 /* When row ends in ZV and we write at ZV it is not
14380 unchanged. */
14381 && !row->ends_at_zv_p
14382 /* When first_changed_pos is the end of a continued line,
14383 row is not unchanged because it may be no longer
14384 continued. */
14385 && !(MATRIX_ROW_END_CHARPOS (row) == first_changed_pos
14386 && (row->continued_p
14387 || row->exact_window_width_line_p)))
14388 row_found = row;
14390 /* Stop if last visible row. */
14391 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
14392 break;
14394 ++row;
14397 return row_found;
14401 /* Find the first glyph row in the current matrix of W that is not
14402 affected by changes at the end of current_buffer since the
14403 time W's current matrix was built.
14405 Return in *DELTA the number of chars by which buffer positions in
14406 unchanged text at the end of current_buffer must be adjusted.
14408 Return in *DELTA_BYTES the corresponding number of bytes.
14410 Value is null if no such row exists, i.e. all rows are affected by
14411 changes. */
14413 static struct glyph_row *
14414 find_first_unchanged_at_end_row (w, delta, delta_bytes)
14415 struct window *w;
14416 int *delta, *delta_bytes;
14418 struct glyph_row *row;
14419 struct glyph_row *row_found = NULL;
14421 *delta = *delta_bytes = 0;
14423 /* Display must not have been paused, otherwise the current matrix
14424 is not up to date. */
14425 eassert (!NILP (w->window_end_valid));
14427 /* A value of window_end_pos >= END_UNCHANGED means that the window
14428 end is in the range of changed text. If so, there is no
14429 unchanged row at the end of W's current matrix. */
14430 if (XFASTINT (w->window_end_pos) >= END_UNCHANGED)
14431 return NULL;
14433 /* Set row to the last row in W's current matrix displaying text. */
14434 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
14436 /* If matrix is entirely empty, no unchanged row exists. */
14437 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
14439 /* The value of row is the last glyph row in the matrix having a
14440 meaningful buffer position in it. The end position of row
14441 corresponds to window_end_pos. This allows us to translate
14442 buffer positions in the current matrix to current buffer
14443 positions for characters not in changed text. */
14444 int Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
14445 int Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
14446 int last_unchanged_pos, last_unchanged_pos_old;
14447 struct glyph_row *first_text_row
14448 = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
14450 *delta = Z - Z_old;
14451 *delta_bytes = Z_BYTE - Z_BYTE_old;
14453 /* Set last_unchanged_pos to the buffer position of the last
14454 character in the buffer that has not been changed. Z is the
14455 index + 1 of the last character in current_buffer, i.e. by
14456 subtracting END_UNCHANGED we get the index of the last
14457 unchanged character, and we have to add BEG to get its buffer
14458 position. */
14459 last_unchanged_pos = Z - END_UNCHANGED + BEG;
14460 last_unchanged_pos_old = last_unchanged_pos - *delta;
14462 /* Search backward from ROW for a row displaying a line that
14463 starts at a minimum position >= last_unchanged_pos_old. */
14464 for (; row > first_text_row; --row)
14466 /* This used to abort, but it can happen.
14467 It is ok to just stop the search instead here. KFS. */
14468 if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
14469 break;
14471 if (MATRIX_ROW_START_CHARPOS (row) >= last_unchanged_pos_old)
14472 row_found = row;
14476 eassert (!row_found || MATRIX_ROW_DISPLAYS_TEXT_P (row_found));
14478 return row_found;
14482 /* Make sure that glyph rows in the current matrix of window W
14483 reference the same glyph memory as corresponding rows in the
14484 frame's frame matrix. This function is called after scrolling W's
14485 current matrix on a terminal frame in try_window_id and
14486 try_window_reusing_current_matrix. */
14488 static void
14489 sync_frame_with_window_matrix_rows (w)
14490 struct window *w;
14492 struct frame *f = XFRAME (w->frame);
14493 struct glyph_row *window_row, *window_row_end, *frame_row;
14495 /* Preconditions: W must be a leaf window and full-width. Its frame
14496 must have a frame matrix. */
14497 xassert (NILP (w->hchild) && NILP (w->vchild));
14498 xassert (WINDOW_FULL_WIDTH_P (w));
14499 xassert (!FRAME_WINDOW_P (f));
14501 /* If W is a full-width window, glyph pointers in W's current matrix
14502 have, by definition, to be the same as glyph pointers in the
14503 corresponding frame matrix. Note that frame matrices have no
14504 marginal areas (see build_frame_matrix). */
14505 window_row = w->current_matrix->rows;
14506 window_row_end = window_row + w->current_matrix->nrows;
14507 frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
14508 while (window_row < window_row_end)
14510 struct glyph *start = window_row->glyphs[LEFT_MARGIN_AREA];
14511 struct glyph *end = window_row->glyphs[LAST_AREA];
14513 frame_row->glyphs[LEFT_MARGIN_AREA] = start;
14514 frame_row->glyphs[TEXT_AREA] = start;
14515 frame_row->glyphs[RIGHT_MARGIN_AREA] = end;
14516 frame_row->glyphs[LAST_AREA] = end;
14518 /* Disable frame rows whose corresponding window rows have
14519 been disabled in try_window_id. */
14520 if (!window_row->enabled_p)
14521 frame_row->enabled_p = 0;
14523 ++window_row, ++frame_row;
14528 /* Find the glyph row in window W containing CHARPOS. Consider all
14529 rows between START and END (not inclusive). END null means search
14530 all rows to the end of the display area of W. Value is the row
14531 containing CHARPOS or null. */
14533 struct glyph_row *
14534 row_containing_pos (w, charpos, start, end, dy)
14535 struct window *w;
14536 int charpos;
14537 struct glyph_row *start, *end;
14538 int dy;
14540 struct glyph_row *row = start;
14541 int last_y;
14543 /* If we happen to start on a header-line, skip that. */
14544 if (row->mode_line_p)
14545 ++row;
14547 if ((end && row >= end) || !row->enabled_p)
14548 return NULL;
14550 last_y = window_text_bottom_y (w) - dy;
14552 while (1)
14554 /* Give up if we have gone too far. */
14555 if (end && row >= end)
14556 return NULL;
14557 /* This formerly returned if they were equal.
14558 I think that both quantities are of a "last plus one" type;
14559 if so, when they are equal, the row is within the screen. -- rms. */
14560 if (MATRIX_ROW_BOTTOM_Y (row) > last_y)
14561 return NULL;
14563 /* If it is in this row, return this row. */
14564 if (! (MATRIX_ROW_END_CHARPOS (row) < charpos
14565 || (MATRIX_ROW_END_CHARPOS (row) == charpos
14566 /* The end position of a row equals the start
14567 position of the next row. If CHARPOS is there, we
14568 would rather display it in the next line, except
14569 when this line ends in ZV. */
14570 && !row->ends_at_zv_p
14571 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
14572 && charpos >= MATRIX_ROW_START_CHARPOS (row))
14573 return row;
14574 ++row;
14579 /* Try to redisplay window W by reusing its existing display. W's
14580 current matrix must be up to date when this function is called,
14581 i.e. window_end_valid must not be nil.
14583 Value is
14585 1 if display has been updated
14586 0 if otherwise unsuccessful
14587 -1 if redisplay with same window start is known not to succeed
14589 The following steps are performed:
14591 1. Find the last row in the current matrix of W that is not
14592 affected by changes at the start of current_buffer. If no such row
14593 is found, give up.
14595 2. Find the first row in W's current matrix that is not affected by
14596 changes at the end of current_buffer. Maybe there is no such row.
14598 3. Display lines beginning with the row + 1 found in step 1 to the
14599 row found in step 2 or, if step 2 didn't find a row, to the end of
14600 the window.
14602 4. If cursor is not known to appear on the window, give up.
14604 5. If display stopped at the row found in step 2, scroll the
14605 display and current matrix as needed.
14607 6. Maybe display some lines at the end of W, if we must. This can
14608 happen under various circumstances, like a partially visible line
14609 becoming fully visible, or because newly displayed lines are displayed
14610 in smaller font sizes.
14612 7. Update W's window end information. */
14614 static int
14615 try_window_id (w)
14616 struct window *w;
14618 struct frame *f = XFRAME (w->frame);
14619 struct glyph_matrix *current_matrix = w->current_matrix;
14620 struct glyph_matrix *desired_matrix = w->desired_matrix;
14621 struct glyph_row *last_unchanged_at_beg_row;
14622 struct glyph_row *first_unchanged_at_end_row;
14623 struct glyph_row *row;
14624 struct glyph_row *bottom_row;
14625 int bottom_vpos;
14626 struct it it;
14627 int delta = 0, delta_bytes = 0, stop_pos, dvpos, dy;
14628 struct text_pos start_pos;
14629 struct run run;
14630 int first_unchanged_at_end_vpos = 0;
14631 struct glyph_row *last_text_row, *last_text_row_at_end;
14632 struct text_pos start;
14633 int first_changed_charpos, last_changed_charpos;
14635 #if GLYPH_DEBUG
14636 if (inhibit_try_window_id)
14637 return 0;
14638 #endif
14640 /* This is handy for debugging. */
14641 #if 0
14642 #define GIVE_UP(X) \
14643 do { \
14644 fprintf (stderr, "try_window_id give up %d\n", (X)); \
14645 return 0; \
14646 } while (0)
14647 #else
14648 #define GIVE_UP(X) return 0
14649 #endif
14651 SET_TEXT_POS_FROM_MARKER (start, w->start);
14653 /* Don't use this for mini-windows because these can show
14654 messages and mini-buffers, and we don't handle that here. */
14655 if (MINI_WINDOW_P (w))
14656 GIVE_UP (1);
14658 /* This flag is used to prevent redisplay optimizations. */
14659 if (windows_or_buffers_changed || cursor_type_changed)
14660 GIVE_UP (2);
14662 /* Verify that narrowing has not changed.
14663 Also verify that we were not told to prevent redisplay optimizations.
14664 It would be nice to further
14665 reduce the number of cases where this prevents try_window_id. */
14666 if (current_buffer->clip_changed
14667 || current_buffer->prevent_redisplay_optimizations_p)
14668 GIVE_UP (3);
14670 /* Window must either use window-based redisplay or be full width. */
14671 if (!FRAME_WINDOW_P (f)
14672 && (!FRAME_LINE_INS_DEL_OK (f)
14673 || !WINDOW_FULL_WIDTH_P (w)))
14674 GIVE_UP (4);
14676 /* Give up if point is not known NOT to appear in W. */
14677 if (PT < CHARPOS (start))
14678 GIVE_UP (5);
14680 /* Another way to prevent redisplay optimizations. */
14681 if (XFASTINT (w->last_modified) == 0)
14682 GIVE_UP (6);
14684 /* Verify that window is not hscrolled. */
14685 if (XFASTINT (w->hscroll) != 0)
14686 GIVE_UP (7);
14688 /* Verify that display wasn't paused. */
14689 if (NILP (w->window_end_valid))
14690 GIVE_UP (8);
14692 /* Can't use this if highlighting a region because a cursor movement
14693 will do more than just set the cursor. */
14694 if (!NILP (Vtransient_mark_mode)
14695 && !NILP (current_buffer->mark_active))
14696 GIVE_UP (9);
14698 /* Likewise if highlighting trailing whitespace. */
14699 if (!NILP (Vshow_trailing_whitespace))
14700 GIVE_UP (11);
14702 /* Likewise if showing a region. */
14703 if (!NILP (w->region_showing))
14704 GIVE_UP (10);
14706 /* Can use this if overlay arrow position and or string have changed. */
14707 if (overlay_arrows_changed_p ())
14708 GIVE_UP (12);
14711 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
14712 only if buffer has really changed. The reason is that the gap is
14713 initially at Z for freshly visited files. The code below would
14714 set end_unchanged to 0 in that case. */
14715 if (MODIFF > SAVE_MODIFF
14716 /* This seems to happen sometimes after saving a buffer. */
14717 || BEG_UNCHANGED + END_UNCHANGED > Z_BYTE)
14719 if (GPT - BEG < BEG_UNCHANGED)
14720 BEG_UNCHANGED = GPT - BEG;
14721 if (Z - GPT < END_UNCHANGED)
14722 END_UNCHANGED = Z - GPT;
14725 /* The position of the first and last character that has been changed. */
14726 first_changed_charpos = BEG + BEG_UNCHANGED;
14727 last_changed_charpos = Z - END_UNCHANGED;
14729 /* If window starts after a line end, and the last change is in
14730 front of that newline, then changes don't affect the display.
14731 This case happens with stealth-fontification. Note that although
14732 the display is unchanged, glyph positions in the matrix have to
14733 be adjusted, of course. */
14734 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
14735 if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
14736 && ((last_changed_charpos < CHARPOS (start)
14737 && CHARPOS (start) == BEGV)
14738 || (last_changed_charpos < CHARPOS (start) - 1
14739 && FETCH_BYTE (BYTEPOS (start) - 1) == '\n')))
14741 int Z_old, delta, Z_BYTE_old, delta_bytes;
14742 struct glyph_row *r0;
14744 /* Compute how many chars/bytes have been added to or removed
14745 from the buffer. */
14746 Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
14747 Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
14748 delta = Z - Z_old;
14749 delta_bytes = Z_BYTE - Z_BYTE_old;
14751 /* Give up if PT is not in the window. Note that it already has
14752 been checked at the start of try_window_id that PT is not in
14753 front of the window start. */
14754 if (PT >= MATRIX_ROW_END_CHARPOS (row) + delta)
14755 GIVE_UP (13);
14757 /* If window start is unchanged, we can reuse the whole matrix
14758 as is, after adjusting glyph positions. No need to compute
14759 the window end again, since its offset from Z hasn't changed. */
14760 r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
14761 if (CHARPOS (start) == MATRIX_ROW_START_CHARPOS (r0) + delta
14762 && BYTEPOS (start) == MATRIX_ROW_START_BYTEPOS (r0) + delta_bytes
14763 /* PT must not be in a partially visible line. */
14764 && !(PT >= MATRIX_ROW_START_CHARPOS (row) + delta
14765 && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
14767 /* Adjust positions in the glyph matrix. */
14768 if (delta || delta_bytes)
14770 struct glyph_row *r1
14771 = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
14772 increment_matrix_positions (w->current_matrix,
14773 MATRIX_ROW_VPOS (r0, current_matrix),
14774 MATRIX_ROW_VPOS (r1, current_matrix),
14775 delta, delta_bytes);
14778 /* Set the cursor. */
14779 row = row_containing_pos (w, PT, r0, NULL, 0);
14780 if (row)
14781 set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
14782 else
14783 abort ();
14784 return 1;
14788 /* Handle the case that changes are all below what is displayed in
14789 the window, and that PT is in the window. This shortcut cannot
14790 be taken if ZV is visible in the window, and text has been added
14791 there that is visible in the window. */
14792 if (first_changed_charpos >= MATRIX_ROW_END_CHARPOS (row)
14793 /* ZV is not visible in the window, or there are no
14794 changes at ZV, actually. */
14795 && (current_matrix->zv > MATRIX_ROW_END_CHARPOS (row)
14796 || first_changed_charpos == last_changed_charpos))
14798 struct glyph_row *r0;
14800 /* Give up if PT is not in the window. Note that it already has
14801 been checked at the start of try_window_id that PT is not in
14802 front of the window start. */
14803 if (PT >= MATRIX_ROW_END_CHARPOS (row))
14804 GIVE_UP (14);
14806 /* If window start is unchanged, we can reuse the whole matrix
14807 as is, without changing glyph positions since no text has
14808 been added/removed in front of the window end. */
14809 r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
14810 if (TEXT_POS_EQUAL_P (start, r0->start.pos)
14811 /* PT must not be in a partially visible line. */
14812 && !(PT >= MATRIX_ROW_START_CHARPOS (row)
14813 && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
14815 /* We have to compute the window end anew since text
14816 can have been added/removed after it. */
14817 w->window_end_pos
14818 = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
14819 w->window_end_bytepos
14820 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
14822 /* Set the cursor. */
14823 row = row_containing_pos (w, PT, r0, NULL, 0);
14824 if (row)
14825 set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
14826 else
14827 abort ();
14828 return 2;
14832 /* Give up if window start is in the changed area.
14834 The condition used to read
14836 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
14838 but why that was tested escapes me at the moment. */
14839 if (CHARPOS (start) >= first_changed_charpos
14840 && CHARPOS (start) <= last_changed_charpos)
14841 GIVE_UP (15);
14843 /* Check that window start agrees with the start of the first glyph
14844 row in its current matrix. Check this after we know the window
14845 start is not in changed text, otherwise positions would not be
14846 comparable. */
14847 row = MATRIX_FIRST_TEXT_ROW (current_matrix);
14848 if (!TEXT_POS_EQUAL_P (start, row->start.pos))
14849 GIVE_UP (16);
14851 /* Give up if the window ends in strings. Overlay strings
14852 at the end are difficult to handle, so don't try. */
14853 row = MATRIX_ROW (current_matrix, XFASTINT (w->window_end_vpos));
14854 if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
14855 GIVE_UP (20);
14857 /* Compute the position at which we have to start displaying new
14858 lines. Some of the lines at the top of the window might be
14859 reusable because they are not displaying changed text. Find the
14860 last row in W's current matrix not affected by changes at the
14861 start of current_buffer. Value is null if changes start in the
14862 first line of window. */
14863 last_unchanged_at_beg_row = find_last_unchanged_at_beg_row (w);
14864 if (last_unchanged_at_beg_row)
14866 /* Avoid starting to display in the moddle of a character, a TAB
14867 for instance. This is easier than to set up the iterator
14868 exactly, and it's not a frequent case, so the additional
14869 effort wouldn't really pay off. */
14870 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row)
14871 || last_unchanged_at_beg_row->ends_in_newline_from_string_p)
14872 && last_unchanged_at_beg_row > w->current_matrix->rows)
14873 --last_unchanged_at_beg_row;
14875 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row))
14876 GIVE_UP (17);
14878 if (init_to_row_end (&it, w, last_unchanged_at_beg_row) == 0)
14879 GIVE_UP (18);
14880 start_pos = it.current.pos;
14882 /* Start displaying new lines in the desired matrix at the same
14883 vpos we would use in the current matrix, i.e. below
14884 last_unchanged_at_beg_row. */
14885 it.vpos = 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row,
14886 current_matrix);
14887 it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
14888 it.current_y = MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row);
14890 xassert (it.hpos == 0 && it.current_x == 0);
14892 else
14894 /* There are no reusable lines at the start of the window.
14895 Start displaying in the first text line. */
14896 start_display (&it, w, start);
14897 it.vpos = it.first_vpos;
14898 start_pos = it.current.pos;
14901 /* Find the first row that is not affected by changes at the end of
14902 the buffer. Value will be null if there is no unchanged row, in
14903 which case we must redisplay to the end of the window. delta
14904 will be set to the value by which buffer positions beginning with
14905 first_unchanged_at_end_row have to be adjusted due to text
14906 changes. */
14907 first_unchanged_at_end_row
14908 = find_first_unchanged_at_end_row (w, &delta, &delta_bytes);
14909 IF_DEBUG (debug_delta = delta);
14910 IF_DEBUG (debug_delta_bytes = delta_bytes);
14912 /* Set stop_pos to the buffer position up to which we will have to
14913 display new lines. If first_unchanged_at_end_row != NULL, this
14914 is the buffer position of the start of the line displayed in that
14915 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
14916 that we don't stop at a buffer position. */
14917 stop_pos = 0;
14918 if (first_unchanged_at_end_row)
14920 xassert (last_unchanged_at_beg_row == NULL
14921 || first_unchanged_at_end_row >= last_unchanged_at_beg_row);
14923 /* If this is a continuation line, move forward to the next one
14924 that isn't. Changes in lines above affect this line.
14925 Caution: this may move first_unchanged_at_end_row to a row
14926 not displaying text. */
14927 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row)
14928 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
14929 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
14930 < it.last_visible_y))
14931 ++first_unchanged_at_end_row;
14933 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
14934 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
14935 >= it.last_visible_y))
14936 first_unchanged_at_end_row = NULL;
14937 else
14939 stop_pos = (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row)
14940 + delta);
14941 first_unchanged_at_end_vpos
14942 = MATRIX_ROW_VPOS (first_unchanged_at_end_row, current_matrix);
14943 xassert (stop_pos >= Z - END_UNCHANGED);
14946 else if (last_unchanged_at_beg_row == NULL)
14947 GIVE_UP (19);
14950 #if GLYPH_DEBUG
14952 /* Either there is no unchanged row at the end, or the one we have
14953 now displays text. This is a necessary condition for the window
14954 end pos calculation at the end of this function. */
14955 xassert (first_unchanged_at_end_row == NULL
14956 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
14958 debug_last_unchanged_at_beg_vpos
14959 = (last_unchanged_at_beg_row
14960 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row, current_matrix)
14961 : -1);
14962 debug_first_unchanged_at_end_vpos = first_unchanged_at_end_vpos;
14964 #endif /* GLYPH_DEBUG != 0 */
14967 /* Display new lines. Set last_text_row to the last new line
14968 displayed which has text on it, i.e. might end up as being the
14969 line where the window_end_vpos is. */
14970 w->cursor.vpos = -1;
14971 last_text_row = NULL;
14972 overlay_arrow_seen = 0;
14973 while (it.current_y < it.last_visible_y
14974 && !fonts_changed_p
14975 && (first_unchanged_at_end_row == NULL
14976 || IT_CHARPOS (it) < stop_pos))
14978 if (display_line (&it))
14979 last_text_row = it.glyph_row - 1;
14982 if (fonts_changed_p)
14983 return -1;
14986 /* Compute differences in buffer positions, y-positions etc. for
14987 lines reused at the bottom of the window. Compute what we can
14988 scroll. */
14989 if (first_unchanged_at_end_row
14990 /* No lines reused because we displayed everything up to the
14991 bottom of the window. */
14992 && it.current_y < it.last_visible_y)
14994 dvpos = (it.vpos
14995 - MATRIX_ROW_VPOS (first_unchanged_at_end_row,
14996 current_matrix));
14997 dy = it.current_y - first_unchanged_at_end_row->y;
14998 run.current_y = first_unchanged_at_end_row->y;
14999 run.desired_y = run.current_y + dy;
15000 run.height = it.last_visible_y - max (run.current_y, run.desired_y);
15002 else
15004 delta = dvpos = dy = run.current_y = run.desired_y = run.height = 0;
15005 first_unchanged_at_end_row = NULL;
15007 IF_DEBUG (debug_dvpos = dvpos; debug_dy = dy);
15010 /* Find the cursor if not already found. We have to decide whether
15011 PT will appear on this window (it sometimes doesn't, but this is
15012 not a very frequent case.) This decision has to be made before
15013 the current matrix is altered. A value of cursor.vpos < 0 means
15014 that PT is either in one of the lines beginning at
15015 first_unchanged_at_end_row or below the window. Don't care for
15016 lines that might be displayed later at the window end; as
15017 mentioned, this is not a frequent case. */
15018 if (w->cursor.vpos < 0)
15020 /* Cursor in unchanged rows at the top? */
15021 if (PT < CHARPOS (start_pos)
15022 && last_unchanged_at_beg_row)
15024 row = row_containing_pos (w, PT,
15025 MATRIX_FIRST_TEXT_ROW (w->current_matrix),
15026 last_unchanged_at_beg_row + 1, 0);
15027 if (row)
15028 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
15031 /* Start from first_unchanged_at_end_row looking for PT. */
15032 else if (first_unchanged_at_end_row)
15034 row = row_containing_pos (w, PT - delta,
15035 first_unchanged_at_end_row, NULL, 0);
15036 if (row)
15037 set_cursor_from_row (w, row, w->current_matrix, delta,
15038 delta_bytes, dy, dvpos);
15041 /* Give up if cursor was not found. */
15042 if (w->cursor.vpos < 0)
15044 clear_glyph_matrix (w->desired_matrix);
15045 return -1;
15049 /* Don't let the cursor end in the scroll margins. */
15051 int this_scroll_margin, cursor_height;
15053 this_scroll_margin = max (0, scroll_margin);
15054 this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
15055 this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
15056 cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
15058 if ((w->cursor.y < this_scroll_margin
15059 && CHARPOS (start) > BEGV)
15060 /* Old redisplay didn't take scroll margin into account at the bottom,
15061 but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
15062 || (w->cursor.y + (make_cursor_line_fully_visible_p
15063 ? cursor_height + this_scroll_margin
15064 : 1)) > it.last_visible_y)
15066 w->cursor.vpos = -1;
15067 clear_glyph_matrix (w->desired_matrix);
15068 return -1;
15072 /* Scroll the display. Do it before changing the current matrix so
15073 that xterm.c doesn't get confused about where the cursor glyph is
15074 found. */
15075 if (dy && run.height)
15077 update_begin (f);
15079 if (FRAME_WINDOW_P (f))
15081 FRAME_RIF (f)->update_window_begin_hook (w);
15082 FRAME_RIF (f)->clear_window_mouse_face (w);
15083 FRAME_RIF (f)->scroll_run_hook (w, &run);
15084 FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
15086 else
15088 /* Terminal frame. In this case, dvpos gives the number of
15089 lines to scroll by; dvpos < 0 means scroll up. */
15090 int first_unchanged_at_end_vpos
15091 = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
15092 int from = WINDOW_TOP_EDGE_LINE (w) + first_unchanged_at_end_vpos;
15093 int end = (WINDOW_TOP_EDGE_LINE (w)
15094 + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0)
15095 + window_internal_height (w));
15097 /* Perform the operation on the screen. */
15098 if (dvpos > 0)
15100 /* Scroll last_unchanged_at_beg_row to the end of the
15101 window down dvpos lines. */
15102 set_terminal_window (f, end);
15104 /* On dumb terminals delete dvpos lines at the end
15105 before inserting dvpos empty lines. */
15106 if (!FRAME_SCROLL_REGION_OK (f))
15107 ins_del_lines (f, end - dvpos, -dvpos);
15109 /* Insert dvpos empty lines in front of
15110 last_unchanged_at_beg_row. */
15111 ins_del_lines (f, from, dvpos);
15113 else if (dvpos < 0)
15115 /* Scroll up last_unchanged_at_beg_vpos to the end of
15116 the window to last_unchanged_at_beg_vpos - |dvpos|. */
15117 set_terminal_window (f, end);
15119 /* Delete dvpos lines in front of
15120 last_unchanged_at_beg_vpos. ins_del_lines will set
15121 the cursor to the given vpos and emit |dvpos| delete
15122 line sequences. */
15123 ins_del_lines (f, from + dvpos, dvpos);
15125 /* On a dumb terminal insert dvpos empty lines at the
15126 end. */
15127 if (!FRAME_SCROLL_REGION_OK (f))
15128 ins_del_lines (f, end + dvpos, -dvpos);
15131 set_terminal_window (f, 0);
15134 update_end (f);
15137 /* Shift reused rows of the current matrix to the right position.
15138 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
15139 text. */
15140 bottom_row = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
15141 bottom_vpos = MATRIX_ROW_VPOS (bottom_row, current_matrix);
15142 if (dvpos < 0)
15144 rotate_matrix (current_matrix, first_unchanged_at_end_vpos + dvpos,
15145 bottom_vpos, dvpos);
15146 enable_glyph_matrix_rows (current_matrix, bottom_vpos + dvpos,
15147 bottom_vpos, 0);
15149 else if (dvpos > 0)
15151 rotate_matrix (current_matrix, first_unchanged_at_end_vpos,
15152 bottom_vpos, dvpos);
15153 enable_glyph_matrix_rows (current_matrix, first_unchanged_at_end_vpos,
15154 first_unchanged_at_end_vpos + dvpos, 0);
15157 /* For frame-based redisplay, make sure that current frame and window
15158 matrix are in sync with respect to glyph memory. */
15159 if (!FRAME_WINDOW_P (f))
15160 sync_frame_with_window_matrix_rows (w);
15162 /* Adjust buffer positions in reused rows. */
15163 if (delta || delta_bytes)
15164 increment_matrix_positions (current_matrix,
15165 first_unchanged_at_end_vpos + dvpos,
15166 bottom_vpos, delta, delta_bytes);
15168 /* Adjust Y positions. */
15169 if (dy)
15170 shift_glyph_matrix (w, current_matrix,
15171 first_unchanged_at_end_vpos + dvpos,
15172 bottom_vpos, dy);
15174 if (first_unchanged_at_end_row)
15176 first_unchanged_at_end_row += dvpos;
15177 if (first_unchanged_at_end_row->y >= it.last_visible_y
15178 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row))
15179 first_unchanged_at_end_row = NULL;
15182 /* If scrolling up, there may be some lines to display at the end of
15183 the window. */
15184 last_text_row_at_end = NULL;
15185 if (dy < 0)
15187 /* Scrolling up can leave for example a partially visible line
15188 at the end of the window to be redisplayed. */
15189 /* Set last_row to the glyph row in the current matrix where the
15190 window end line is found. It has been moved up or down in
15191 the matrix by dvpos. */
15192 int last_vpos = XFASTINT (w->window_end_vpos) + dvpos;
15193 struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
15195 /* If last_row is the window end line, it should display text. */
15196 xassert (last_row->displays_text_p);
15198 /* If window end line was partially visible before, begin
15199 displaying at that line. Otherwise begin displaying with the
15200 line following it. */
15201 if (MATRIX_ROW_BOTTOM_Y (last_row) - dy >= it.last_visible_y)
15203 init_to_row_start (&it, w, last_row);
15204 it.vpos = last_vpos;
15205 it.current_y = last_row->y;
15207 else
15209 init_to_row_end (&it, w, last_row);
15210 it.vpos = 1 + last_vpos;
15211 it.current_y = MATRIX_ROW_BOTTOM_Y (last_row);
15212 ++last_row;
15215 /* We may start in a continuation line. If so, we have to
15216 get the right continuation_lines_width and current_x. */
15217 it.continuation_lines_width = last_row->continuation_lines_width;
15218 it.hpos = it.current_x = 0;
15220 /* Display the rest of the lines at the window end. */
15221 it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
15222 while (it.current_y < it.last_visible_y
15223 && !fonts_changed_p)
15225 /* Is it always sure that the display agrees with lines in
15226 the current matrix? I don't think so, so we mark rows
15227 displayed invalid in the current matrix by setting their
15228 enabled_p flag to zero. */
15229 MATRIX_ROW (w->current_matrix, it.vpos)->enabled_p = 0;
15230 if (display_line (&it))
15231 last_text_row_at_end = it.glyph_row - 1;
15235 /* Update window_end_pos and window_end_vpos. */
15236 if (first_unchanged_at_end_row
15237 && !last_text_row_at_end)
15239 /* Window end line if one of the preserved rows from the current
15240 matrix. Set row to the last row displaying text in current
15241 matrix starting at first_unchanged_at_end_row, after
15242 scrolling. */
15243 xassert (first_unchanged_at_end_row->displays_text_p);
15244 row = find_last_row_displaying_text (w->current_matrix, &it,
15245 first_unchanged_at_end_row);
15246 xassert (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
15248 w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
15249 w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
15250 w->window_end_vpos
15251 = make_number (MATRIX_ROW_VPOS (row, w->current_matrix));
15252 xassert (w->window_end_bytepos >= 0);
15253 IF_DEBUG (debug_method_add (w, "A"));
15255 else if (last_text_row_at_end)
15257 w->window_end_pos
15258 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end));
15259 w->window_end_bytepos
15260 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row_at_end);
15261 w->window_end_vpos
15262 = make_number (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix));
15263 xassert (w->window_end_bytepos >= 0);
15264 IF_DEBUG (debug_method_add (w, "B"));
15266 else if (last_text_row)
15268 /* We have displayed either to the end of the window or at the
15269 end of the window, i.e. the last row with text is to be found
15270 in the desired matrix. */
15271 w->window_end_pos
15272 = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
15273 w->window_end_bytepos
15274 = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
15275 w->window_end_vpos
15276 = make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix));
15277 xassert (w->window_end_bytepos >= 0);
15279 else if (first_unchanged_at_end_row == NULL
15280 && last_text_row == NULL
15281 && last_text_row_at_end == NULL)
15283 /* Displayed to end of window, but no line containing text was
15284 displayed. Lines were deleted at the end of the window. */
15285 int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
15286 int vpos = XFASTINT (w->window_end_vpos);
15287 struct glyph_row *current_row = current_matrix->rows + vpos;
15288 struct glyph_row *desired_row = desired_matrix->rows + vpos;
15290 for (row = NULL;
15291 row == NULL && vpos >= first_vpos;
15292 --vpos, --current_row, --desired_row)
15294 if (desired_row->enabled_p)
15296 if (desired_row->displays_text_p)
15297 row = desired_row;
15299 else if (current_row->displays_text_p)
15300 row = current_row;
15303 xassert (row != NULL);
15304 w->window_end_vpos = make_number (vpos + 1);
15305 w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
15306 w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
15307 xassert (w->window_end_bytepos >= 0);
15308 IF_DEBUG (debug_method_add (w, "C"));
15310 else
15311 abort ();
15313 #if 0 /* This leads to problems, for instance when the cursor is
15314 at ZV, and the cursor line displays no text. */
15315 /* Disable rows below what's displayed in the window. This makes
15316 debugging easier. */
15317 enable_glyph_matrix_rows (current_matrix,
15318 XFASTINT (w->window_end_vpos) + 1,
15319 bottom_vpos, 0);
15320 #endif
15322 IF_DEBUG (debug_end_pos = XFASTINT (w->window_end_pos);
15323 debug_end_vpos = XFASTINT (w->window_end_vpos));
15325 /* Record that display has not been completed. */
15326 w->window_end_valid = Qnil;
15327 w->desired_matrix->no_scrolling_p = 1;
15328 return 3;
15330 #undef GIVE_UP
15335 /***********************************************************************
15336 More debugging support
15337 ***********************************************************************/
15339 #if GLYPH_DEBUG
15341 void dump_glyph_row P_ ((struct glyph_row *, int, int));
15342 void dump_glyph_matrix P_ ((struct glyph_matrix *, int));
15343 void dump_glyph P_ ((struct glyph_row *, struct glyph *, int));
15346 /* Dump the contents of glyph matrix MATRIX on stderr.
15348 GLYPHS 0 means don't show glyph contents.
15349 GLYPHS 1 means show glyphs in short form
15350 GLYPHS > 1 means show glyphs in long form. */
15352 void
15353 dump_glyph_matrix (matrix, glyphs)
15354 struct glyph_matrix *matrix;
15355 int glyphs;
15357 int i;
15358 for (i = 0; i < matrix->nrows; ++i)
15359 dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
15363 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
15364 the glyph row and area where the glyph comes from. */
15366 void
15367 dump_glyph (row, glyph, area)
15368 struct glyph_row *row;
15369 struct glyph *glyph;
15370 int area;
15372 if (glyph->type == CHAR_GLYPH)
15374 fprintf (stderr,
15375 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
15376 glyph - row->glyphs[TEXT_AREA],
15377 'C',
15378 glyph->charpos,
15379 (BUFFERP (glyph->object)
15380 ? 'B'
15381 : (STRINGP (glyph->object)
15382 ? 'S'
15383 : '-')),
15384 glyph->pixel_width,
15385 glyph->u.ch,
15386 (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
15387 ? glyph->u.ch
15388 : '.'),
15389 glyph->face_id,
15390 glyph->left_box_line_p,
15391 glyph->right_box_line_p);
15393 else if (glyph->type == STRETCH_GLYPH)
15395 fprintf (stderr,
15396 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
15397 glyph - row->glyphs[TEXT_AREA],
15398 'S',
15399 glyph->charpos,
15400 (BUFFERP (glyph->object)
15401 ? 'B'
15402 : (STRINGP (glyph->object)
15403 ? 'S'
15404 : '-')),
15405 glyph->pixel_width,
15407 '.',
15408 glyph->face_id,
15409 glyph->left_box_line_p,
15410 glyph->right_box_line_p);
15412 else if (glyph->type == IMAGE_GLYPH)
15414 fprintf (stderr,
15415 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
15416 glyph - row->glyphs[TEXT_AREA],
15417 'I',
15418 glyph->charpos,
15419 (BUFFERP (glyph->object)
15420 ? 'B'
15421 : (STRINGP (glyph->object)
15422 ? 'S'
15423 : '-')),
15424 glyph->pixel_width,
15425 glyph->u.img_id,
15426 '.',
15427 glyph->face_id,
15428 glyph->left_box_line_p,
15429 glyph->right_box_line_p);
15431 else if (glyph->type == COMPOSITE_GLYPH)
15433 fprintf (stderr,
15434 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
15435 glyph - row->glyphs[TEXT_AREA],
15436 '+',
15437 glyph->charpos,
15438 (BUFFERP (glyph->object)
15439 ? 'B'
15440 : (STRINGP (glyph->object)
15441 ? 'S'
15442 : '-')),
15443 glyph->pixel_width,
15444 glyph->u.cmp_id,
15445 '.',
15446 glyph->face_id,
15447 glyph->left_box_line_p,
15448 glyph->right_box_line_p);
15453 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
15454 GLYPHS 0 means don't show glyph contents.
15455 GLYPHS 1 means show glyphs in short form
15456 GLYPHS > 1 means show glyphs in long form. */
15458 void
15459 dump_glyph_row (row, vpos, glyphs)
15460 struct glyph_row *row;
15461 int vpos, glyphs;
15463 if (glyphs != 1)
15465 fprintf (stderr, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
15466 fprintf (stderr, "======================================================================\n");
15468 fprintf (stderr, "%3d %5d %5d %4d %1.1d%1.1d%1.1d%1.1d\
15469 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
15470 vpos,
15471 MATRIX_ROW_START_CHARPOS (row),
15472 MATRIX_ROW_END_CHARPOS (row),
15473 row->used[TEXT_AREA],
15474 row->contains_overlapping_glyphs_p,
15475 row->enabled_p,
15476 row->truncated_on_left_p,
15477 row->truncated_on_right_p,
15478 row->continued_p,
15479 MATRIX_ROW_CONTINUATION_LINE_P (row),
15480 row->displays_text_p,
15481 row->ends_at_zv_p,
15482 row->fill_line_p,
15483 row->ends_in_middle_of_char_p,
15484 row->starts_in_middle_of_char_p,
15485 row->mouse_face_p,
15486 row->x,
15487 row->y,
15488 row->pixel_width,
15489 row->height,
15490 row->visible_height,
15491 row->ascent,
15492 row->phys_ascent);
15493 fprintf (stderr, "%9d %5d\t%5d\n", row->start.overlay_string_index,
15494 row->end.overlay_string_index,
15495 row->continuation_lines_width);
15496 fprintf (stderr, "%9d %5d\n",
15497 CHARPOS (row->start.string_pos),
15498 CHARPOS (row->end.string_pos));
15499 fprintf (stderr, "%9d %5d\n", row->start.dpvec_index,
15500 row->end.dpvec_index);
15503 if (glyphs > 1)
15505 int area;
15507 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
15509 struct glyph *glyph = row->glyphs[area];
15510 struct glyph *glyph_end = glyph + row->used[area];
15512 /* Glyph for a line end in text. */
15513 if (area == TEXT_AREA && glyph == glyph_end && glyph->charpos > 0)
15514 ++glyph_end;
15516 if (glyph < glyph_end)
15517 fprintf (stderr, " Glyph Type Pos O W Code C Face LR\n");
15519 for (; glyph < glyph_end; ++glyph)
15520 dump_glyph (row, glyph, area);
15523 else if (glyphs == 1)
15525 int area;
15527 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
15529 char *s = (char *) alloca (row->used[area] + 1);
15530 int i;
15532 for (i = 0; i < row->used[area]; ++i)
15534 struct glyph *glyph = row->glyphs[area] + i;
15535 if (glyph->type == CHAR_GLYPH
15536 && glyph->u.ch < 0x80
15537 && glyph->u.ch >= ' ')
15538 s[i] = glyph->u.ch;
15539 else
15540 s[i] = '.';
15543 s[i] = '\0';
15544 fprintf (stderr, "%3d: (%d) '%s'\n", vpos, row->enabled_p, s);
15550 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix,
15551 Sdump_glyph_matrix, 0, 1, "p",
15552 doc: /* Dump the current matrix of the selected window to stderr.
15553 Shows contents of glyph row structures. With non-nil
15554 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
15555 glyphs in short form, otherwise show glyphs in long form. */)
15556 (glyphs)
15557 Lisp_Object glyphs;
15559 struct window *w = XWINDOW (selected_window);
15560 struct buffer *buffer = XBUFFER (w->buffer);
15562 fprintf (stderr, "PT = %d, BEGV = %d. ZV = %d\n",
15563 BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
15564 fprintf (stderr, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
15565 w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos);
15566 fprintf (stderr, "=============================================\n");
15567 dump_glyph_matrix (w->current_matrix,
15568 NILP (glyphs) ? 0 : XINT (glyphs));
15569 return Qnil;
15573 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix,
15574 Sdump_frame_glyph_matrix, 0, 0, "", doc: /* */)
15577 struct frame *f = XFRAME (selected_frame);
15578 dump_glyph_matrix (f->current_matrix, 1);
15579 return Qnil;
15583 DEFUN ("dump-glyph-row", Fdump_glyph_row, Sdump_glyph_row, 1, 2, "",
15584 doc: /* Dump glyph row ROW to stderr.
15585 GLYPH 0 means don't dump glyphs.
15586 GLYPH 1 means dump glyphs in short form.
15587 GLYPH > 1 or omitted means dump glyphs in long form. */)
15588 (row, glyphs)
15589 Lisp_Object row, glyphs;
15591 struct glyph_matrix *matrix;
15592 int vpos;
15594 CHECK_NUMBER (row);
15595 matrix = XWINDOW (selected_window)->current_matrix;
15596 vpos = XINT (row);
15597 if (vpos >= 0 && vpos < matrix->nrows)
15598 dump_glyph_row (MATRIX_ROW (matrix, vpos),
15599 vpos,
15600 INTEGERP (glyphs) ? XINT (glyphs) : 2);
15601 return Qnil;
15605 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row, Sdump_tool_bar_row, 1, 2, "",
15606 doc: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
15607 GLYPH 0 means don't dump glyphs.
15608 GLYPH 1 means dump glyphs in short form.
15609 GLYPH > 1 or omitted means dump glyphs in long form. */)
15610 (row, glyphs)
15611 Lisp_Object row, glyphs;
15613 struct frame *sf = SELECTED_FRAME ();
15614 struct glyph_matrix *m = XWINDOW (sf->tool_bar_window)->current_matrix;
15615 int vpos;
15617 CHECK_NUMBER (row);
15618 vpos = XINT (row);
15619 if (vpos >= 0 && vpos < m->nrows)
15620 dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
15621 INTEGERP (glyphs) ? XINT (glyphs) : 2);
15622 return Qnil;
15626 DEFUN ("trace-redisplay", Ftrace_redisplay, Strace_redisplay, 0, 1, "P",
15627 doc: /* Toggle tracing of redisplay.
15628 With ARG, turn tracing on if and only if ARG is positive. */)
15629 (arg)
15630 Lisp_Object arg;
15632 if (NILP (arg))
15633 trace_redisplay_p = !trace_redisplay_p;
15634 else
15636 arg = Fprefix_numeric_value (arg);
15637 trace_redisplay_p = XINT (arg) > 0;
15640 return Qnil;
15644 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
15645 doc: /* Like `format', but print result to stderr.
15646 usage: (trace-to-stderr STRING &rest OBJECTS) */)
15647 (nargs, args)
15648 int nargs;
15649 Lisp_Object *args;
15651 Lisp_Object s = Fformat (nargs, args);
15652 fprintf (stderr, "%s", SDATA (s));
15653 return Qnil;
15656 #endif /* GLYPH_DEBUG */
15660 /***********************************************************************
15661 Building Desired Matrix Rows
15662 ***********************************************************************/
15664 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
15665 Used for non-window-redisplay windows, and for windows w/o left fringe. */
15667 static struct glyph_row *
15668 get_overlay_arrow_glyph_row (w, overlay_arrow_string)
15669 struct window *w;
15670 Lisp_Object overlay_arrow_string;
15672 struct frame *f = XFRAME (WINDOW_FRAME (w));
15673 struct buffer *buffer = XBUFFER (w->buffer);
15674 struct buffer *old = current_buffer;
15675 const unsigned char *arrow_string = SDATA (overlay_arrow_string);
15676 int arrow_len = SCHARS (overlay_arrow_string);
15677 const unsigned char *arrow_end = arrow_string + arrow_len;
15678 const unsigned char *p;
15679 struct it it;
15680 int multibyte_p;
15681 int n_glyphs_before;
15683 set_buffer_temp (buffer);
15684 init_iterator (&it, w, -1, -1, &scratch_glyph_row, DEFAULT_FACE_ID);
15685 it.glyph_row->used[TEXT_AREA] = 0;
15686 SET_TEXT_POS (it.position, 0, 0);
15688 multibyte_p = !NILP (buffer->enable_multibyte_characters);
15689 p = arrow_string;
15690 while (p < arrow_end)
15692 Lisp_Object face, ilisp;
15694 /* Get the next character. */
15695 if (multibyte_p)
15696 it.c = string_char_and_length (p, arrow_len, &it.len);
15697 else
15698 it.c = *p, it.len = 1;
15699 p += it.len;
15701 /* Get its face. */
15702 ilisp = make_number (p - arrow_string);
15703 face = Fget_text_property (ilisp, Qface, overlay_arrow_string);
15704 it.face_id = compute_char_face (f, it.c, face);
15706 /* Compute its width, get its glyphs. */
15707 n_glyphs_before = it.glyph_row->used[TEXT_AREA];
15708 SET_TEXT_POS (it.position, -1, -1);
15709 PRODUCE_GLYPHS (&it);
15711 /* If this character doesn't fit any more in the line, we have
15712 to remove some glyphs. */
15713 if (it.current_x > it.last_visible_x)
15715 it.glyph_row->used[TEXT_AREA] = n_glyphs_before;
15716 break;
15720 set_buffer_temp (old);
15721 return it.glyph_row;
15725 /* Insert truncation glyphs at the start of IT->glyph_row. Truncation
15726 glyphs are only inserted for terminal frames since we can't really
15727 win with truncation glyphs when partially visible glyphs are
15728 involved. Which glyphs to insert is determined by
15729 produce_special_glyphs. */
15731 static void
15732 insert_left_trunc_glyphs (it)
15733 struct it *it;
15735 struct it truncate_it;
15736 struct glyph *from, *end, *to, *toend;
15738 xassert (!FRAME_WINDOW_P (it->f));
15740 /* Get the truncation glyphs. */
15741 truncate_it = *it;
15742 truncate_it.current_x = 0;
15743 truncate_it.face_id = DEFAULT_FACE_ID;
15744 truncate_it.glyph_row = &scratch_glyph_row;
15745 truncate_it.glyph_row->used[TEXT_AREA] = 0;
15746 CHARPOS (truncate_it.position) = BYTEPOS (truncate_it.position) = -1;
15747 truncate_it.object = make_number (0);
15748 produce_special_glyphs (&truncate_it, IT_TRUNCATION);
15750 /* Overwrite glyphs from IT with truncation glyphs. */
15751 from = truncate_it.glyph_row->glyphs[TEXT_AREA];
15752 end = from + truncate_it.glyph_row->used[TEXT_AREA];
15753 to = it->glyph_row->glyphs[TEXT_AREA];
15754 toend = to + it->glyph_row->used[TEXT_AREA];
15756 while (from < end)
15757 *to++ = *from++;
15759 /* There may be padding glyphs left over. Overwrite them too. */
15760 while (to < toend && CHAR_GLYPH_PADDING_P (*to))
15762 from = truncate_it.glyph_row->glyphs[TEXT_AREA];
15763 while (from < end)
15764 *to++ = *from++;
15767 if (to > toend)
15768 it->glyph_row->used[TEXT_AREA] = to - it->glyph_row->glyphs[TEXT_AREA];
15772 /* Compute the pixel height and width of IT->glyph_row.
15774 Most of the time, ascent and height of a display line will be equal
15775 to the max_ascent and max_height values of the display iterator
15776 structure. This is not the case if
15778 1. We hit ZV without displaying anything. In this case, max_ascent
15779 and max_height will be zero.
15781 2. We have some glyphs that don't contribute to the line height.
15782 (The glyph row flag contributes_to_line_height_p is for future
15783 pixmap extensions).
15785 The first case is easily covered by using default values because in
15786 these cases, the line height does not really matter, except that it
15787 must not be zero. */
15789 static void
15790 compute_line_metrics (it)
15791 struct it *it;
15793 struct glyph_row *row = it->glyph_row;
15794 int area, i;
15796 if (FRAME_WINDOW_P (it->f))
15798 int i, min_y, max_y;
15800 /* The line may consist of one space only, that was added to
15801 place the cursor on it. If so, the row's height hasn't been
15802 computed yet. */
15803 if (row->height == 0)
15805 if (it->max_ascent + it->max_descent == 0)
15806 it->max_descent = it->max_phys_descent = FRAME_LINE_HEIGHT (it->f);
15807 row->ascent = it->max_ascent;
15808 row->height = it->max_ascent + it->max_descent;
15809 row->phys_ascent = it->max_phys_ascent;
15810 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
15811 row->extra_line_spacing = it->max_extra_line_spacing;
15814 /* Compute the width of this line. */
15815 row->pixel_width = row->x;
15816 for (i = 0; i < row->used[TEXT_AREA]; ++i)
15817 row->pixel_width += row->glyphs[TEXT_AREA][i].pixel_width;
15819 xassert (row->pixel_width >= 0);
15820 xassert (row->ascent >= 0 && row->height > 0);
15822 row->overlapping_p = (MATRIX_ROW_OVERLAPS_SUCC_P (row)
15823 || MATRIX_ROW_OVERLAPS_PRED_P (row));
15825 /* If first line's physical ascent is larger than its logical
15826 ascent, use the physical ascent, and make the row taller.
15827 This makes accented characters fully visible. */
15828 if (row == MATRIX_FIRST_TEXT_ROW (it->w->desired_matrix)
15829 && row->phys_ascent > row->ascent)
15831 row->height += row->phys_ascent - row->ascent;
15832 row->ascent = row->phys_ascent;
15835 /* Compute how much of the line is visible. */
15836 row->visible_height = row->height;
15838 min_y = WINDOW_HEADER_LINE_HEIGHT (it->w);
15839 max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);
15841 if (row->y < min_y)
15842 row->visible_height -= min_y - row->y;
15843 if (row->y + row->height > max_y)
15844 row->visible_height -= row->y + row->height - max_y;
15846 else
15848 row->pixel_width = row->used[TEXT_AREA];
15849 if (row->continued_p)
15850 row->pixel_width -= it->continuation_pixel_width;
15851 else if (row->truncated_on_right_p)
15852 row->pixel_width -= it->truncation_pixel_width;
15853 row->ascent = row->phys_ascent = 0;
15854 row->height = row->phys_height = row->visible_height = 1;
15855 row->extra_line_spacing = 0;
15858 /* Compute a hash code for this row. */
15859 row->hash = 0;
15860 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
15861 for (i = 0; i < row->used[area]; ++i)
15862 row->hash = ((((row->hash << 4) + (row->hash >> 24)) & 0x0fffffff)
15863 + row->glyphs[area][i].u.val
15864 + row->glyphs[area][i].face_id
15865 + row->glyphs[area][i].padding_p
15866 + (row->glyphs[area][i].type << 2));
15868 it->max_ascent = it->max_descent = 0;
15869 it->max_phys_ascent = it->max_phys_descent = 0;
15873 /* Append one space to the glyph row of iterator IT if doing a
15874 window-based redisplay. The space has the same face as
15875 IT->face_id. Value is non-zero if a space was added.
15877 This function is called to make sure that there is always one glyph
15878 at the end of a glyph row that the cursor can be set on under
15879 window-systems. (If there weren't such a glyph we would not know
15880 how wide and tall a box cursor should be displayed).
15882 At the same time this space let's a nicely handle clearing to the
15883 end of the line if the row ends in italic text. */
15885 static int
15886 append_space_for_newline (it, default_face_p)
15887 struct it *it;
15888 int default_face_p;
15890 if (FRAME_WINDOW_P (it->f))
15892 int n = it->glyph_row->used[TEXT_AREA];
15894 if (it->glyph_row->glyphs[TEXT_AREA] + n
15895 < it->glyph_row->glyphs[1 + TEXT_AREA])
15897 /* Save some values that must not be changed.
15898 Must save IT->c and IT->len because otherwise
15899 ITERATOR_AT_END_P wouldn't work anymore after
15900 append_space_for_newline has been called. */
15901 enum display_element_type saved_what = it->what;
15902 int saved_c = it->c, saved_len = it->len;
15903 int saved_x = it->current_x;
15904 int saved_face_id = it->face_id;
15905 struct text_pos saved_pos;
15906 Lisp_Object saved_object;
15907 struct face *face;
15909 saved_object = it->object;
15910 saved_pos = it->position;
15912 it->what = IT_CHARACTER;
15913 bzero (&it->position, sizeof it->position);
15914 it->object = make_number (0);
15915 it->c = ' ';
15916 it->len = 1;
15918 if (default_face_p)
15919 it->face_id = DEFAULT_FACE_ID;
15920 else if (it->face_before_selective_p)
15921 it->face_id = it->saved_face_id;
15922 face = FACE_FROM_ID (it->f, it->face_id);
15923 it->face_id = FACE_FOR_CHAR (it->f, face, 0, -1, Qnil);
15925 PRODUCE_GLYPHS (it);
15927 it->override_ascent = -1;
15928 it->constrain_row_ascent_descent_p = 0;
15929 it->current_x = saved_x;
15930 it->object = saved_object;
15931 it->position = saved_pos;
15932 it->what = saved_what;
15933 it->face_id = saved_face_id;
15934 it->len = saved_len;
15935 it->c = saved_c;
15936 return 1;
15940 return 0;
15944 /* Extend the face of the last glyph in the text area of IT->glyph_row
15945 to the end of the display line. Called from display_line.
15946 If the glyph row is empty, add a space glyph to it so that we
15947 know the face to draw. Set the glyph row flag fill_line_p. */
15949 static void
15950 extend_face_to_end_of_line (it)
15951 struct it *it;
15953 struct face *face;
15954 struct frame *f = it->f;
15956 /* If line is already filled, do nothing. */
15957 if (it->current_x >= it->last_visible_x)
15958 return;
15960 /* Face extension extends the background and box of IT->face_id
15961 to the end of the line. If the background equals the background
15962 of the frame, we don't have to do anything. */
15963 if (it->face_before_selective_p)
15964 face = FACE_FROM_ID (it->f, it->saved_face_id);
15965 else
15966 face = FACE_FROM_ID (f, it->face_id);
15968 if (FRAME_WINDOW_P (f)
15969 && it->glyph_row->displays_text_p
15970 && face->box == FACE_NO_BOX
15971 && face->background == FRAME_BACKGROUND_PIXEL (f)
15972 && !face->stipple)
15973 return;
15975 /* Set the glyph row flag indicating that the face of the last glyph
15976 in the text area has to be drawn to the end of the text area. */
15977 it->glyph_row->fill_line_p = 1;
15979 /* If current character of IT is not ASCII, make sure we have the
15980 ASCII face. This will be automatically undone the next time
15981 get_next_display_element returns a multibyte character. Note
15982 that the character will always be single byte in unibyte text. */
15983 if (!ASCII_CHAR_P (it->c))
15985 it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
15988 if (FRAME_WINDOW_P (f))
15990 /* If the row is empty, add a space with the current face of IT,
15991 so that we know which face to draw. */
15992 if (it->glyph_row->used[TEXT_AREA] == 0)
15994 it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
15995 it->glyph_row->glyphs[TEXT_AREA][0].face_id = it->face_id;
15996 it->glyph_row->used[TEXT_AREA] = 1;
15999 else
16001 /* Save some values that must not be changed. */
16002 int saved_x = it->current_x;
16003 struct text_pos saved_pos;
16004 Lisp_Object saved_object;
16005 enum display_element_type saved_what = it->what;
16006 int saved_face_id = it->face_id;
16008 saved_object = it->object;
16009 saved_pos = it->position;
16011 it->what = IT_CHARACTER;
16012 bzero (&it->position, sizeof it->position);
16013 it->object = make_number (0);
16014 it->c = ' ';
16015 it->len = 1;
16016 it->face_id = face->id;
16018 PRODUCE_GLYPHS (it);
16020 while (it->current_x <= it->last_visible_x)
16021 PRODUCE_GLYPHS (it);
16023 /* Don't count these blanks really. It would let us insert a left
16024 truncation glyph below and make us set the cursor on them, maybe. */
16025 it->current_x = saved_x;
16026 it->object = saved_object;
16027 it->position = saved_pos;
16028 it->what = saved_what;
16029 it->face_id = saved_face_id;
16034 /* Value is non-zero if text starting at CHARPOS in current_buffer is
16035 trailing whitespace. */
16037 static int
16038 trailing_whitespace_p (charpos)
16039 int charpos;
16041 int bytepos = CHAR_TO_BYTE (charpos);
16042 int c = 0;
16044 while (bytepos < ZV_BYTE
16045 && (c = FETCH_CHAR (bytepos),
16046 c == ' ' || c == '\t'))
16047 ++bytepos;
16049 if (bytepos >= ZV_BYTE || c == '\n' || c == '\r')
16051 if (bytepos != PT_BYTE)
16052 return 1;
16054 return 0;
16058 /* Highlight trailing whitespace, if any, in ROW. */
16060 void
16061 highlight_trailing_whitespace (f, row)
16062 struct frame *f;
16063 struct glyph_row *row;
16065 int used = row->used[TEXT_AREA];
16067 if (used)
16069 struct glyph *start = row->glyphs[TEXT_AREA];
16070 struct glyph *glyph = start + used - 1;
16072 /* Skip over glyphs inserted to display the cursor at the
16073 end of a line, for extending the face of the last glyph
16074 to the end of the line on terminals, and for truncation
16075 and continuation glyphs. */
16076 while (glyph >= start
16077 && glyph->type == CHAR_GLYPH
16078 && INTEGERP (glyph->object))
16079 --glyph;
16081 /* If last glyph is a space or stretch, and it's trailing
16082 whitespace, set the face of all trailing whitespace glyphs in
16083 IT->glyph_row to `trailing-whitespace'. */
16084 if (glyph >= start
16085 && BUFFERP (glyph->object)
16086 && (glyph->type == STRETCH_GLYPH
16087 || (glyph->type == CHAR_GLYPH
16088 && glyph->u.ch == ' '))
16089 && trailing_whitespace_p (glyph->charpos))
16091 int face_id = lookup_named_face (f, Qtrailing_whitespace, 0);
16092 if (face_id < 0)
16093 return;
16095 while (glyph >= start
16096 && BUFFERP (glyph->object)
16097 && (glyph->type == STRETCH_GLYPH
16098 || (glyph->type == CHAR_GLYPH
16099 && glyph->u.ch == ' ')))
16100 (glyph--)->face_id = face_id;
16106 /* Value is non-zero if glyph row ROW in window W should be
16107 used to hold the cursor. */
16109 static int
16110 cursor_row_p (w, row)
16111 struct window *w;
16112 struct glyph_row *row;
16114 int cursor_row_p = 1;
16116 if (PT == MATRIX_ROW_END_CHARPOS (row))
16118 /* Suppose the row ends on a string.
16119 Unless the row is continued, that means it ends on a newline
16120 in the string. If it's anything other than a display string
16121 (e.g. a before-string from an overlay), we don't want the
16122 cursor there. (This heuristic seems to give the optimal
16123 behavior for the various types of multi-line strings.) */
16124 if (CHARPOS (row->end.string_pos) >= 0)
16126 if (row->continued_p)
16127 cursor_row_p = 1;
16128 else
16130 /* Check for `display' property. */
16131 struct glyph *beg = row->glyphs[TEXT_AREA];
16132 struct glyph *end = beg + row->used[TEXT_AREA] - 1;
16133 struct glyph *glyph;
16135 cursor_row_p = 0;
16136 for (glyph = end; glyph >= beg; --glyph)
16137 if (STRINGP (glyph->object))
16139 Lisp_Object prop
16140 = Fget_char_property (make_number (PT),
16141 Qdisplay, Qnil);
16142 cursor_row_p =
16143 (!NILP (prop)
16144 && display_prop_string_p (prop, glyph->object));
16145 break;
16149 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
16151 /* If the row ends in middle of a real character,
16152 and the line is continued, we want the cursor here.
16153 That's because MATRIX_ROW_END_CHARPOS would equal
16154 PT if PT is before the character. */
16155 if (!row->ends_in_ellipsis_p)
16156 cursor_row_p = row->continued_p;
16157 else
16158 /* If the row ends in an ellipsis, then
16159 MATRIX_ROW_END_CHARPOS will equal point after the invisible text.
16160 We want that position to be displayed after the ellipsis. */
16161 cursor_row_p = 0;
16163 /* If the row ends at ZV, display the cursor at the end of that
16164 row instead of at the start of the row below. */
16165 else if (row->ends_at_zv_p)
16166 cursor_row_p = 1;
16167 else
16168 cursor_row_p = 0;
16171 return cursor_row_p;
16175 /* Construct the glyph row IT->glyph_row in the desired matrix of
16176 IT->w from text at the current position of IT. See dispextern.h
16177 for an overview of struct it. Value is non-zero if
16178 IT->glyph_row displays text, as opposed to a line displaying ZV
16179 only. */
16181 static int
16182 display_line (it)
16183 struct it *it;
16185 struct glyph_row *row = it->glyph_row;
16186 Lisp_Object overlay_arrow_string;
16188 /* We always start displaying at hpos zero even if hscrolled. */
16189 xassert (it->hpos == 0 && it->current_x == 0);
16191 if (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
16192 >= it->w->desired_matrix->nrows)
16194 it->w->nrows_scale_factor++;
16195 fonts_changed_p = 1;
16196 return 0;
16199 /* Is IT->w showing the region? */
16200 it->w->region_showing = it->region_beg_charpos > 0 ? Qt : Qnil;
16202 /* Clear the result glyph row and enable it. */
16203 prepare_desired_row (row);
16205 row->y = it->current_y;
16206 row->start = it->start;
16207 row->continuation_lines_width = it->continuation_lines_width;
16208 row->displays_text_p = 1;
16209 row->starts_in_middle_of_char_p = it->starts_in_middle_of_char_p;
16210 it->starts_in_middle_of_char_p = 0;
16212 /* Arrange the overlays nicely for our purposes. Usually, we call
16213 display_line on only one line at a time, in which case this
16214 can't really hurt too much, or we call it on lines which appear
16215 one after another in the buffer, in which case all calls to
16216 recenter_overlay_lists but the first will be pretty cheap. */
16217 recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
16219 /* Move over display elements that are not visible because we are
16220 hscrolled. This may stop at an x-position < IT->first_visible_x
16221 if the first glyph is partially visible or if we hit a line end. */
16222 if (it->current_x < it->first_visible_x)
16224 move_it_in_display_line_to (it, ZV, it->first_visible_x,
16225 MOVE_TO_POS | MOVE_TO_X);
16228 /* Get the initial row height. This is either the height of the
16229 text hscrolled, if there is any, or zero. */
16230 row->ascent = it->max_ascent;
16231 row->height = it->max_ascent + it->max_descent;
16232 row->phys_ascent = it->max_phys_ascent;
16233 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
16234 row->extra_line_spacing = it->max_extra_line_spacing;
16236 /* Loop generating characters. The loop is left with IT on the next
16237 character to display. */
16238 while (1)
16240 int n_glyphs_before, hpos_before, x_before;
16241 int x, i, nglyphs;
16242 int ascent = 0, descent = 0, phys_ascent = 0, phys_descent = 0;
16244 /* Retrieve the next thing to display. Value is zero if end of
16245 buffer reached. */
16246 if (!get_next_display_element (it))
16248 /* Maybe add a space at the end of this line that is used to
16249 display the cursor there under X. Set the charpos of the
16250 first glyph of blank lines not corresponding to any text
16251 to -1. */
16252 #ifdef HAVE_WINDOW_SYSTEM
16253 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
16254 row->exact_window_width_line_p = 1;
16255 else
16256 #endif /* HAVE_WINDOW_SYSTEM */
16257 if ((append_space_for_newline (it, 1) && row->used[TEXT_AREA] == 1)
16258 || row->used[TEXT_AREA] == 0)
16260 row->glyphs[TEXT_AREA]->charpos = -1;
16261 row->displays_text_p = 0;
16263 if (!NILP (XBUFFER (it->w->buffer)->indicate_empty_lines)
16264 && (!MINI_WINDOW_P (it->w)
16265 || (minibuf_level && EQ (it->window, minibuf_window))))
16266 row->indicate_empty_line_p = 1;
16269 it->continuation_lines_width = 0;
16270 row->ends_at_zv_p = 1;
16271 break;
16274 /* Now, get the metrics of what we want to display. This also
16275 generates glyphs in `row' (which is IT->glyph_row). */
16276 n_glyphs_before = row->used[TEXT_AREA];
16277 x = it->current_x;
16279 /* Remember the line height so far in case the next element doesn't
16280 fit on the line. */
16281 if (!it->truncate_lines_p)
16283 ascent = it->max_ascent;
16284 descent = it->max_descent;
16285 phys_ascent = it->max_phys_ascent;
16286 phys_descent = it->max_phys_descent;
16289 PRODUCE_GLYPHS (it);
16291 /* If this display element was in marginal areas, continue with
16292 the next one. */
16293 if (it->area != TEXT_AREA)
16295 row->ascent = max (row->ascent, it->max_ascent);
16296 row->height = max (row->height, it->max_ascent + it->max_descent);
16297 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
16298 row->phys_height = max (row->phys_height,
16299 it->max_phys_ascent + it->max_phys_descent);
16300 row->extra_line_spacing = max (row->extra_line_spacing,
16301 it->max_extra_line_spacing);
16302 set_iterator_to_next (it, 1);
16303 continue;
16306 /* Does the display element fit on the line? If we truncate
16307 lines, we should draw past the right edge of the window. If
16308 we don't truncate, we want to stop so that we can display the
16309 continuation glyph before the right margin. If lines are
16310 continued, there are two possible strategies for characters
16311 resulting in more than 1 glyph (e.g. tabs): Display as many
16312 glyphs as possible in this line and leave the rest for the
16313 continuation line, or display the whole element in the next
16314 line. Original redisplay did the former, so we do it also. */
16315 nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
16316 hpos_before = it->hpos;
16317 x_before = x;
16319 if (/* Not a newline. */
16320 nglyphs > 0
16321 /* Glyphs produced fit entirely in the line. */
16322 && it->current_x < it->last_visible_x)
16324 it->hpos += nglyphs;
16325 row->ascent = max (row->ascent, it->max_ascent);
16326 row->height = max (row->height, it->max_ascent + it->max_descent);
16327 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
16328 row->phys_height = max (row->phys_height,
16329 it->max_phys_ascent + it->max_phys_descent);
16330 row->extra_line_spacing = max (row->extra_line_spacing,
16331 it->max_extra_line_spacing);
16332 if (it->current_x - it->pixel_width < it->first_visible_x)
16333 row->x = x - it->first_visible_x;
16335 else
16337 int new_x;
16338 struct glyph *glyph;
16340 for (i = 0; i < nglyphs; ++i, x = new_x)
16342 glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
16343 new_x = x + glyph->pixel_width;
16345 if (/* Lines are continued. */
16346 !it->truncate_lines_p
16347 && (/* Glyph doesn't fit on the line. */
16348 new_x > it->last_visible_x
16349 /* Or it fits exactly on a window system frame. */
16350 || (new_x == it->last_visible_x
16351 && FRAME_WINDOW_P (it->f))))
16353 /* End of a continued line. */
16355 if (it->hpos == 0
16356 || (new_x == it->last_visible_x
16357 && FRAME_WINDOW_P (it->f)))
16359 /* Current glyph is the only one on the line or
16360 fits exactly on the line. We must continue
16361 the line because we can't draw the cursor
16362 after the glyph. */
16363 row->continued_p = 1;
16364 it->current_x = new_x;
16365 it->continuation_lines_width += new_x;
16366 ++it->hpos;
16367 if (i == nglyphs - 1)
16369 set_iterator_to_next (it, 1);
16370 #ifdef HAVE_WINDOW_SYSTEM
16371 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
16373 if (!get_next_display_element (it))
16375 row->exact_window_width_line_p = 1;
16376 it->continuation_lines_width = 0;
16377 row->continued_p = 0;
16378 row->ends_at_zv_p = 1;
16380 else if (ITERATOR_AT_END_OF_LINE_P (it))
16382 row->continued_p = 0;
16383 row->exact_window_width_line_p = 1;
16386 #endif /* HAVE_WINDOW_SYSTEM */
16389 else if (CHAR_GLYPH_PADDING_P (*glyph)
16390 && !FRAME_WINDOW_P (it->f))
16392 /* A padding glyph that doesn't fit on this line.
16393 This means the whole character doesn't fit
16394 on the line. */
16395 row->used[TEXT_AREA] = n_glyphs_before;
16397 /* Fill the rest of the row with continuation
16398 glyphs like in 20.x. */
16399 while (row->glyphs[TEXT_AREA] + row->used[TEXT_AREA]
16400 < row->glyphs[1 + TEXT_AREA])
16401 produce_special_glyphs (it, IT_CONTINUATION);
16403 row->continued_p = 1;
16404 it->current_x = x_before;
16405 it->continuation_lines_width += x_before;
16407 /* Restore the height to what it was before the
16408 element not fitting on the line. */
16409 it->max_ascent = ascent;
16410 it->max_descent = descent;
16411 it->max_phys_ascent = phys_ascent;
16412 it->max_phys_descent = phys_descent;
16414 else if (it->c == '\t' && FRAME_WINDOW_P (it->f))
16416 /* A TAB that extends past the right edge of the
16417 window. This produces a single glyph on
16418 window system frames. We leave the glyph in
16419 this row and let it fill the row, but don't
16420 consume the TAB. */
16421 it->continuation_lines_width += it->last_visible_x;
16422 row->ends_in_middle_of_char_p = 1;
16423 row->continued_p = 1;
16424 glyph->pixel_width = it->last_visible_x - x;
16425 it->starts_in_middle_of_char_p = 1;
16427 else
16429 /* Something other than a TAB that draws past
16430 the right edge of the window. Restore
16431 positions to values before the element. */
16432 row->used[TEXT_AREA] = n_glyphs_before + i;
16434 /* Display continuation glyphs. */
16435 if (!FRAME_WINDOW_P (it->f))
16436 produce_special_glyphs (it, IT_CONTINUATION);
16437 row->continued_p = 1;
16439 it->current_x = x_before;
16440 it->continuation_lines_width += x;
16441 extend_face_to_end_of_line (it);
16443 if (nglyphs > 1 && i > 0)
16445 row->ends_in_middle_of_char_p = 1;
16446 it->starts_in_middle_of_char_p = 1;
16449 /* Restore the height to what it was before the
16450 element not fitting on the line. */
16451 it->max_ascent = ascent;
16452 it->max_descent = descent;
16453 it->max_phys_ascent = phys_ascent;
16454 it->max_phys_descent = phys_descent;
16457 break;
16459 else if (new_x > it->first_visible_x)
16461 /* Increment number of glyphs actually displayed. */
16462 ++it->hpos;
16464 if (x < it->first_visible_x)
16465 /* Glyph is partially visible, i.e. row starts at
16466 negative X position. */
16467 row->x = x - it->first_visible_x;
16469 else
16471 /* Glyph is completely off the left margin of the
16472 window. This should not happen because of the
16473 move_it_in_display_line at the start of this
16474 function, unless the text display area of the
16475 window is empty. */
16476 xassert (it->first_visible_x <= it->last_visible_x);
16480 row->ascent = max (row->ascent, it->max_ascent);
16481 row->height = max (row->height, it->max_ascent + it->max_descent);
16482 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
16483 row->phys_height = max (row->phys_height,
16484 it->max_phys_ascent + it->max_phys_descent);
16485 row->extra_line_spacing = max (row->extra_line_spacing,
16486 it->max_extra_line_spacing);
16488 /* End of this display line if row is continued. */
16489 if (row->continued_p || row->ends_at_zv_p)
16490 break;
16493 at_end_of_line:
16494 /* Is this a line end? If yes, we're also done, after making
16495 sure that a non-default face is extended up to the right
16496 margin of the window. */
16497 if (ITERATOR_AT_END_OF_LINE_P (it))
16499 int used_before = row->used[TEXT_AREA];
16501 row->ends_in_newline_from_string_p = STRINGP (it->object);
16503 #ifdef HAVE_WINDOW_SYSTEM
16504 /* Add a space at the end of the line that is used to
16505 display the cursor there. */
16506 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
16507 append_space_for_newline (it, 0);
16508 #endif /* HAVE_WINDOW_SYSTEM */
16510 /* Extend the face to the end of the line. */
16511 extend_face_to_end_of_line (it);
16513 /* Make sure we have the position. */
16514 if (used_before == 0)
16515 row->glyphs[TEXT_AREA]->charpos = CHARPOS (it->position);
16517 /* Consume the line end. This skips over invisible lines. */
16518 set_iterator_to_next (it, 1);
16519 it->continuation_lines_width = 0;
16520 break;
16523 /* Proceed with next display element. Note that this skips
16524 over lines invisible because of selective display. */
16525 set_iterator_to_next (it, 1);
16527 /* If we truncate lines, we are done when the last displayed
16528 glyphs reach past the right margin of the window. */
16529 if (it->truncate_lines_p
16530 && (FRAME_WINDOW_P (it->f)
16531 ? (it->current_x >= it->last_visible_x)
16532 : (it->current_x > it->last_visible_x)))
16534 /* Maybe add truncation glyphs. */
16535 if (!FRAME_WINDOW_P (it->f))
16537 int i, n;
16539 for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
16540 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
16541 break;
16543 for (n = row->used[TEXT_AREA]; i < n; ++i)
16545 row->used[TEXT_AREA] = i;
16546 produce_special_glyphs (it, IT_TRUNCATION);
16549 #ifdef HAVE_WINDOW_SYSTEM
16550 else
16552 /* Don't truncate if we can overflow newline into fringe. */
16553 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
16555 if (!get_next_display_element (it))
16557 it->continuation_lines_width = 0;
16558 row->ends_at_zv_p = 1;
16559 row->exact_window_width_line_p = 1;
16560 break;
16562 if (ITERATOR_AT_END_OF_LINE_P (it))
16564 row->exact_window_width_line_p = 1;
16565 goto at_end_of_line;
16569 #endif /* HAVE_WINDOW_SYSTEM */
16571 row->truncated_on_right_p = 1;
16572 it->continuation_lines_width = 0;
16573 reseat_at_next_visible_line_start (it, 0);
16574 row->ends_at_zv_p = FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n';
16575 it->hpos = hpos_before;
16576 it->current_x = x_before;
16577 break;
16581 /* If line is not empty and hscrolled, maybe insert truncation glyphs
16582 at the left window margin. */
16583 if (it->first_visible_x
16584 && IT_CHARPOS (*it) != MATRIX_ROW_START_CHARPOS (row))
16586 if (!FRAME_WINDOW_P (it->f))
16587 insert_left_trunc_glyphs (it);
16588 row->truncated_on_left_p = 1;
16591 /* If the start of this line is the overlay arrow-position, then
16592 mark this glyph row as the one containing the overlay arrow.
16593 This is clearly a mess with variable size fonts. It would be
16594 better to let it be displayed like cursors under X. */
16595 if ((row->displays_text_p || !overlay_arrow_seen)
16596 && (overlay_arrow_string = overlay_arrow_at_row (it, row),
16597 !NILP (overlay_arrow_string)))
16599 /* Overlay arrow in window redisplay is a fringe bitmap. */
16600 if (STRINGP (overlay_arrow_string))
16602 struct glyph_row *arrow_row
16603 = get_overlay_arrow_glyph_row (it->w, overlay_arrow_string);
16604 struct glyph *glyph = arrow_row->glyphs[TEXT_AREA];
16605 struct glyph *arrow_end = glyph + arrow_row->used[TEXT_AREA];
16606 struct glyph *p = row->glyphs[TEXT_AREA];
16607 struct glyph *p2, *end;
16609 /* Copy the arrow glyphs. */
16610 while (glyph < arrow_end)
16611 *p++ = *glyph++;
16613 /* Throw away padding glyphs. */
16614 p2 = p;
16615 end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
16616 while (p2 < end && CHAR_GLYPH_PADDING_P (*p2))
16617 ++p2;
16618 if (p2 > p)
16620 while (p2 < end)
16621 *p++ = *p2++;
16622 row->used[TEXT_AREA] = p2 - row->glyphs[TEXT_AREA];
16625 else
16627 xassert (INTEGERP (overlay_arrow_string));
16628 row->overlay_arrow_bitmap = XINT (overlay_arrow_string);
16630 overlay_arrow_seen = 1;
16633 /* Compute pixel dimensions of this line. */
16634 compute_line_metrics (it);
16636 /* Remember the position at which this line ends. */
16637 row->end = it->current;
16639 /* Record whether this row ends inside an ellipsis. */
16640 row->ends_in_ellipsis_p
16641 = (it->method == GET_FROM_DISPLAY_VECTOR
16642 && it->ellipsis_p);
16644 /* Save fringe bitmaps in this row. */
16645 row->left_user_fringe_bitmap = it->left_user_fringe_bitmap;
16646 row->left_user_fringe_face_id = it->left_user_fringe_face_id;
16647 row->right_user_fringe_bitmap = it->right_user_fringe_bitmap;
16648 row->right_user_fringe_face_id = it->right_user_fringe_face_id;
16650 it->left_user_fringe_bitmap = 0;
16651 it->left_user_fringe_face_id = 0;
16652 it->right_user_fringe_bitmap = 0;
16653 it->right_user_fringe_face_id = 0;
16655 /* Maybe set the cursor. */
16656 if (it->w->cursor.vpos < 0
16657 && PT >= MATRIX_ROW_START_CHARPOS (row)
16658 && PT <= MATRIX_ROW_END_CHARPOS (row)
16659 && cursor_row_p (it->w, row))
16660 set_cursor_from_row (it->w, row, it->w->desired_matrix, 0, 0, 0, 0);
16662 /* Highlight trailing whitespace. */
16663 if (!NILP (Vshow_trailing_whitespace))
16664 highlight_trailing_whitespace (it->f, it->glyph_row);
16666 /* Prepare for the next line. This line starts horizontally at (X
16667 HPOS) = (0 0). Vertical positions are incremented. As a
16668 convenience for the caller, IT->glyph_row is set to the next
16669 row to be used. */
16670 it->current_x = it->hpos = 0;
16671 it->current_y += row->height;
16672 ++it->vpos;
16673 ++it->glyph_row;
16674 it->start = it->current;
16675 return row->displays_text_p;
16680 /***********************************************************************
16681 Menu Bar
16682 ***********************************************************************/
16684 /* Redisplay the menu bar in the frame for window W.
16686 The menu bar of X frames that don't have X toolkit support is
16687 displayed in a special window W->frame->menu_bar_window.
16689 The menu bar of terminal frames is treated specially as far as
16690 glyph matrices are concerned. Menu bar lines are not part of
16691 windows, so the update is done directly on the frame matrix rows
16692 for the menu bar. */
16694 static void
16695 display_menu_bar (w)
16696 struct window *w;
16698 struct frame *f = XFRAME (WINDOW_FRAME (w));
16699 struct it it;
16700 Lisp_Object items;
16701 int i;
16703 /* Don't do all this for graphical frames. */
16704 #ifdef HAVE_NTGUI
16705 if (FRAME_W32_P (f))
16706 return;
16707 #endif
16708 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
16709 if (FRAME_X_P (f))
16710 return;
16711 #endif
16712 #ifdef MAC_OS
16713 if (FRAME_MAC_P (f))
16714 return;
16715 #endif
16717 #ifdef USE_X_TOOLKIT
16718 xassert (!FRAME_WINDOW_P (f));
16719 init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
16720 it.first_visible_x = 0;
16721 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
16722 #else /* not USE_X_TOOLKIT */
16723 if (FRAME_WINDOW_P (f))
16725 /* Menu bar lines are displayed in the desired matrix of the
16726 dummy window menu_bar_window. */
16727 struct window *menu_w;
16728 xassert (WINDOWP (f->menu_bar_window));
16729 menu_w = XWINDOW (f->menu_bar_window);
16730 init_iterator (&it, menu_w, -1, -1, menu_w->desired_matrix->rows,
16731 MENU_FACE_ID);
16732 it.first_visible_x = 0;
16733 it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
16735 else
16737 /* This is a TTY frame, i.e. character hpos/vpos are used as
16738 pixel x/y. */
16739 init_iterator (&it, w, -1, -1, f->desired_matrix->rows,
16740 MENU_FACE_ID);
16741 it.first_visible_x = 0;
16742 it.last_visible_x = FRAME_COLS (f);
16744 #endif /* not USE_X_TOOLKIT */
16746 if (! mode_line_inverse_video)
16747 /* Force the menu-bar to be displayed in the default face. */
16748 it.base_face_id = it.face_id = DEFAULT_FACE_ID;
16750 /* Clear all rows of the menu bar. */
16751 for (i = 0; i < FRAME_MENU_BAR_LINES (f); ++i)
16753 struct glyph_row *row = it.glyph_row + i;
16754 clear_glyph_row (row);
16755 row->enabled_p = 1;
16756 row->full_width_p = 1;
16759 /* Display all items of the menu bar. */
16760 items = FRAME_MENU_BAR_ITEMS (it.f);
16761 for (i = 0; i < XVECTOR (items)->size; i += 4)
16763 Lisp_Object string;
16765 /* Stop at nil string. */
16766 string = AREF (items, i + 1);
16767 if (NILP (string))
16768 break;
16770 /* Remember where item was displayed. */
16771 ASET (items, i + 3, make_number (it.hpos));
16773 /* Display the item, pad with one space. */
16774 if (it.current_x < it.last_visible_x)
16775 display_string (NULL, string, Qnil, 0, 0, &it,
16776 SCHARS (string) + 1, 0, 0, -1);
16779 /* Fill out the line with spaces. */
16780 if (it.current_x < it.last_visible_x)
16781 display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
16783 /* Compute the total height of the lines. */
16784 compute_line_metrics (&it);
16789 /***********************************************************************
16790 Mode Line
16791 ***********************************************************************/
16793 /* Redisplay mode lines in the window tree whose root is WINDOW. If
16794 FORCE is non-zero, redisplay mode lines unconditionally.
16795 Otherwise, redisplay only mode lines that are garbaged. Value is
16796 the number of windows whose mode lines were redisplayed. */
16798 static int
16799 redisplay_mode_lines (window, force)
16800 Lisp_Object window;
16801 int force;
16803 int nwindows = 0;
16805 while (!NILP (window))
16807 struct window *w = XWINDOW (window);
16809 if (WINDOWP (w->hchild))
16810 nwindows += redisplay_mode_lines (w->hchild, force);
16811 else if (WINDOWP (w->vchild))
16812 nwindows += redisplay_mode_lines (w->vchild, force);
16813 else if (force
16814 || FRAME_GARBAGED_P (XFRAME (w->frame))
16815 || !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
16817 struct text_pos lpoint;
16818 struct buffer *old = current_buffer;
16820 /* Set the window's buffer for the mode line display. */
16821 SET_TEXT_POS (lpoint, PT, PT_BYTE);
16822 set_buffer_internal_1 (XBUFFER (w->buffer));
16824 /* Point refers normally to the selected window. For any
16825 other window, set up appropriate value. */
16826 if (!EQ (window, selected_window))
16828 struct text_pos pt;
16830 SET_TEXT_POS_FROM_MARKER (pt, w->pointm);
16831 if (CHARPOS (pt) < BEGV)
16832 TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
16833 else if (CHARPOS (pt) > (ZV - 1))
16834 TEMP_SET_PT_BOTH (ZV, ZV_BYTE);
16835 else
16836 TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
16839 /* Display mode lines. */
16840 clear_glyph_matrix (w->desired_matrix);
16841 if (display_mode_lines (w))
16843 ++nwindows;
16844 w->must_be_updated_p = 1;
16847 /* Restore old settings. */
16848 set_buffer_internal_1 (old);
16849 TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
16852 window = w->next;
16855 return nwindows;
16859 /* Display the mode and/or top line of window W. Value is the number
16860 of mode lines displayed. */
16862 static int
16863 display_mode_lines (w)
16864 struct window *w;
16866 Lisp_Object old_selected_window, old_selected_frame;
16867 int n = 0;
16869 old_selected_frame = selected_frame;
16870 selected_frame = w->frame;
16871 old_selected_window = selected_window;
16872 XSETWINDOW (selected_window, w);
16874 /* These will be set while the mode line specs are processed. */
16875 line_number_displayed = 0;
16876 w->column_number_displayed = Qnil;
16878 if (WINDOW_WANTS_MODELINE_P (w))
16880 struct window *sel_w = XWINDOW (old_selected_window);
16882 /* Select mode line face based on the real selected window. */
16883 display_mode_line (w, CURRENT_MODE_LINE_FACE_ID_3 (sel_w, sel_w, w),
16884 current_buffer->mode_line_format);
16885 ++n;
16888 if (WINDOW_WANTS_HEADER_LINE_P (w))
16890 display_mode_line (w, HEADER_LINE_FACE_ID,
16891 current_buffer->header_line_format);
16892 ++n;
16895 selected_frame = old_selected_frame;
16896 selected_window = old_selected_window;
16897 return n;
16901 /* Display mode or top line of window W. FACE_ID specifies which line
16902 to display; it is either MODE_LINE_FACE_ID or HEADER_LINE_FACE_ID.
16903 FORMAT is the mode line format to display. Value is the pixel
16904 height of the mode line displayed. */
16906 static int
16907 display_mode_line (w, face_id, format)
16908 struct window *w;
16909 enum face_id face_id;
16910 Lisp_Object format;
16912 struct it it;
16913 struct face *face;
16914 int count = SPECPDL_INDEX ();
16916 init_iterator (&it, w, -1, -1, NULL, face_id);
16917 /* Don't extend on a previously drawn mode-line.
16918 This may happen if called from pos_visible_p. */
16919 it.glyph_row->enabled_p = 0;
16920 prepare_desired_row (it.glyph_row);
16922 it.glyph_row->mode_line_p = 1;
16924 if (! mode_line_inverse_video)
16925 /* Force the mode-line to be displayed in the default face. */
16926 it.base_face_id = it.face_id = DEFAULT_FACE_ID;
16928 record_unwind_protect (unwind_format_mode_line,
16929 format_mode_line_unwind_data (NULL, 0));
16931 mode_line_target = MODE_LINE_DISPLAY;
16933 /* Temporarily make frame's keyboard the current kboard so that
16934 kboard-local variables in the mode_line_format will get the right
16935 values. */
16936 push_kboard (FRAME_KBOARD (it.f));
16937 record_unwind_save_match_data ();
16938 display_mode_element (&it, 0, 0, 0, format, Qnil, 0);
16939 pop_kboard ();
16941 unbind_to (count, Qnil);
16943 /* Fill up with spaces. */
16944 display_string (" ", Qnil, Qnil, 0, 0, &it, 10000, -1, -1, 0);
16946 compute_line_metrics (&it);
16947 it.glyph_row->full_width_p = 1;
16948 it.glyph_row->continued_p = 0;
16949 it.glyph_row->truncated_on_left_p = 0;
16950 it.glyph_row->truncated_on_right_p = 0;
16952 /* Make a 3D mode-line have a shadow at its right end. */
16953 face = FACE_FROM_ID (it.f, face_id);
16954 extend_face_to_end_of_line (&it);
16955 if (face->box != FACE_NO_BOX)
16957 struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
16958 + it.glyph_row->used[TEXT_AREA] - 1);
16959 last->right_box_line_p = 1;
16962 return it.glyph_row->height;
16965 /* Move element ELT in LIST to the front of LIST.
16966 Return the updated list. */
16968 static Lisp_Object
16969 move_elt_to_front (elt, list)
16970 Lisp_Object elt, list;
16972 register Lisp_Object tail, prev;
16973 register Lisp_Object tem;
16975 tail = list;
16976 prev = Qnil;
16977 while (CONSP (tail))
16979 tem = XCAR (tail);
16981 if (EQ (elt, tem))
16983 /* Splice out the link TAIL. */
16984 if (NILP (prev))
16985 list = XCDR (tail);
16986 else
16987 Fsetcdr (prev, XCDR (tail));
16989 /* Now make it the first. */
16990 Fsetcdr (tail, list);
16991 return tail;
16993 else
16994 prev = tail;
16995 tail = XCDR (tail);
16996 QUIT;
16999 /* Not found--return unchanged LIST. */
17000 return list;
17003 /* Contribute ELT to the mode line for window IT->w. How it
17004 translates into text depends on its data type.
17006 IT describes the display environment in which we display, as usual.
17008 DEPTH is the depth in recursion. It is used to prevent
17009 infinite recursion here.
17011 FIELD_WIDTH is the number of characters the display of ELT should
17012 occupy in the mode line, and PRECISION is the maximum number of
17013 characters to display from ELT's representation. See
17014 display_string for details.
17016 Returns the hpos of the end of the text generated by ELT.
17018 PROPS is a property list to add to any string we encounter.
17020 If RISKY is nonzero, remove (disregard) any properties in any string
17021 we encounter, and ignore :eval and :propertize.
17023 The global variable `mode_line_target' determines whether the
17024 output is passed to `store_mode_line_noprop',
17025 `store_mode_line_string', or `display_string'. */
17027 static int
17028 display_mode_element (it, depth, field_width, precision, elt, props, risky)
17029 struct it *it;
17030 int depth;
17031 int field_width, precision;
17032 Lisp_Object elt, props;
17033 int risky;
17035 int n = 0, field, prec;
17036 int literal = 0;
17038 tail_recurse:
17039 if (depth > 100)
17040 elt = build_string ("*too-deep*");
17042 depth++;
17044 switch (SWITCH_ENUM_CAST (XTYPE (elt)))
17046 case Lisp_String:
17048 /* A string: output it and check for %-constructs within it. */
17049 unsigned char c;
17050 int offset = 0;
17052 if (SCHARS (elt) > 0
17053 && (!NILP (props) || risky))
17055 Lisp_Object oprops, aelt;
17056 oprops = Ftext_properties_at (make_number (0), elt);
17058 /* If the starting string's properties are not what
17059 we want, translate the string. Also, if the string
17060 is risky, do that anyway. */
17062 if (NILP (Fequal (props, oprops)) || risky)
17064 /* If the starting string has properties,
17065 merge the specified ones onto the existing ones. */
17066 if (! NILP (oprops) && !risky)
17068 Lisp_Object tem;
17070 oprops = Fcopy_sequence (oprops);
17071 tem = props;
17072 while (CONSP (tem))
17074 oprops = Fplist_put (oprops, XCAR (tem),
17075 XCAR (XCDR (tem)));
17076 tem = XCDR (XCDR (tem));
17078 props = oprops;
17081 aelt = Fassoc (elt, mode_line_proptrans_alist);
17082 if (! NILP (aelt) && !NILP (Fequal (props, XCDR (aelt))))
17084 /* AELT is what we want. Move it to the front
17085 without consing. */
17086 elt = XCAR (aelt);
17087 mode_line_proptrans_alist
17088 = move_elt_to_front (aelt, mode_line_proptrans_alist);
17090 else
17092 Lisp_Object tem;
17094 /* If AELT has the wrong props, it is useless.
17095 so get rid of it. */
17096 if (! NILP (aelt))
17097 mode_line_proptrans_alist
17098 = Fdelq (aelt, mode_line_proptrans_alist);
17100 elt = Fcopy_sequence (elt);
17101 Fset_text_properties (make_number (0), Flength (elt),
17102 props, elt);
17103 /* Add this item to mode_line_proptrans_alist. */
17104 mode_line_proptrans_alist
17105 = Fcons (Fcons (elt, props),
17106 mode_line_proptrans_alist);
17107 /* Truncate mode_line_proptrans_alist
17108 to at most 50 elements. */
17109 tem = Fnthcdr (make_number (50),
17110 mode_line_proptrans_alist);
17111 if (! NILP (tem))
17112 XSETCDR (tem, Qnil);
17117 offset = 0;
17119 if (literal)
17121 prec = precision - n;
17122 switch (mode_line_target)
17124 case MODE_LINE_NOPROP:
17125 case MODE_LINE_TITLE:
17126 n += store_mode_line_noprop (SDATA (elt), -1, prec);
17127 break;
17128 case MODE_LINE_STRING:
17129 n += store_mode_line_string (NULL, elt, 1, 0, prec, Qnil);
17130 break;
17131 case MODE_LINE_DISPLAY:
17132 n += display_string (NULL, elt, Qnil, 0, 0, it,
17133 0, prec, 0, STRING_MULTIBYTE (elt));
17134 break;
17137 break;
17140 /* Handle the non-literal case. */
17142 while ((precision <= 0 || n < precision)
17143 && SREF (elt, offset) != 0
17144 && (mode_line_target != MODE_LINE_DISPLAY
17145 || it->current_x < it->last_visible_x))
17147 int last_offset = offset;
17149 /* Advance to end of string or next format specifier. */
17150 while ((c = SREF (elt, offset++)) != '\0' && c != '%')
17153 if (offset - 1 != last_offset)
17155 int nchars, nbytes;
17157 /* Output to end of string or up to '%'. Field width
17158 is length of string. Don't output more than
17159 PRECISION allows us. */
17160 offset--;
17162 prec = c_string_width (SDATA (elt) + last_offset,
17163 offset - last_offset, precision - n,
17164 &nchars, &nbytes);
17166 switch (mode_line_target)
17168 case MODE_LINE_NOPROP:
17169 case MODE_LINE_TITLE:
17170 n += store_mode_line_noprop (SDATA (elt) + last_offset, 0, prec);
17171 break;
17172 case MODE_LINE_STRING:
17174 int bytepos = last_offset;
17175 int charpos = string_byte_to_char (elt, bytepos);
17176 int endpos = (precision <= 0
17177 ? string_byte_to_char (elt, offset)
17178 : charpos + nchars);
17180 n += store_mode_line_string (NULL,
17181 Fsubstring (elt, make_number (charpos),
17182 make_number (endpos)),
17183 0, 0, 0, Qnil);
17185 break;
17186 case MODE_LINE_DISPLAY:
17188 int bytepos = last_offset;
17189 int charpos = string_byte_to_char (elt, bytepos);
17191 if (precision <= 0)
17192 nchars = string_byte_to_char (elt, offset) - charpos;
17193 n += display_string (NULL, elt, Qnil, 0, charpos,
17194 it, 0, nchars, 0,
17195 STRING_MULTIBYTE (elt));
17197 break;
17200 else /* c == '%' */
17202 int percent_position = offset;
17204 /* Get the specified minimum width. Zero means
17205 don't pad. */
17206 field = 0;
17207 while ((c = SREF (elt, offset++)) >= '0' && c <= '9')
17208 field = field * 10 + c - '0';
17210 /* Don't pad beyond the total padding allowed. */
17211 if (field_width - n > 0 && field > field_width - n)
17212 field = field_width - n;
17214 /* Note that either PRECISION <= 0 or N < PRECISION. */
17215 prec = precision - n;
17217 if (c == 'M')
17218 n += display_mode_element (it, depth, field, prec,
17219 Vglobal_mode_string, props,
17220 risky);
17221 else if (c != 0)
17223 int multibyte;
17224 int bytepos, charpos;
17225 unsigned char *spec;
17227 bytepos = percent_position;
17228 charpos = (STRING_MULTIBYTE (elt)
17229 ? string_byte_to_char (elt, bytepos)
17230 : bytepos);
17231 spec
17232 = decode_mode_spec (it->w, c, field, prec, &multibyte);
17234 switch (mode_line_target)
17236 case MODE_LINE_NOPROP:
17237 case MODE_LINE_TITLE:
17238 n += store_mode_line_noprop (spec, field, prec);
17239 break;
17240 case MODE_LINE_STRING:
17242 int len = strlen (spec);
17243 Lisp_Object tem = make_string (spec, len);
17244 props = Ftext_properties_at (make_number (charpos), elt);
17245 /* Should only keep face property in props */
17246 n += store_mode_line_string (NULL, tem, 0, field, prec, props);
17248 break;
17249 case MODE_LINE_DISPLAY:
17251 int nglyphs_before, nwritten;
17253 nglyphs_before = it->glyph_row->used[TEXT_AREA];
17254 nwritten = display_string (spec, Qnil, elt,
17255 charpos, 0, it,
17256 field, prec, 0,
17257 multibyte);
17259 /* Assign to the glyphs written above the
17260 string where the `%x' came from, position
17261 of the `%'. */
17262 if (nwritten > 0)
17264 struct glyph *glyph
17265 = (it->glyph_row->glyphs[TEXT_AREA]
17266 + nglyphs_before);
17267 int i;
17269 for (i = 0; i < nwritten; ++i)
17271 glyph[i].object = elt;
17272 glyph[i].charpos = charpos;
17275 n += nwritten;
17278 break;
17281 else /* c == 0 */
17282 break;
17286 break;
17288 case Lisp_Symbol:
17289 /* A symbol: process the value of the symbol recursively
17290 as if it appeared here directly. Avoid error if symbol void.
17291 Special case: if value of symbol is a string, output the string
17292 literally. */
17294 register Lisp_Object tem;
17296 /* If the variable is not marked as risky to set
17297 then its contents are risky to use. */
17298 if (NILP (Fget (elt, Qrisky_local_variable)))
17299 risky = 1;
17301 tem = Fboundp (elt);
17302 if (!NILP (tem))
17304 tem = Fsymbol_value (elt);
17305 /* If value is a string, output that string literally:
17306 don't check for % within it. */
17307 if (STRINGP (tem))
17308 literal = 1;
17310 if (!EQ (tem, elt))
17312 /* Give up right away for nil or t. */
17313 elt = tem;
17314 goto tail_recurse;
17318 break;
17320 case Lisp_Cons:
17322 register Lisp_Object car, tem;
17324 /* A cons cell: five distinct cases.
17325 If first element is :eval or :propertize, do something special.
17326 If first element is a string or a cons, process all the elements
17327 and effectively concatenate them.
17328 If first element is a negative number, truncate displaying cdr to
17329 at most that many characters. If positive, pad (with spaces)
17330 to at least that many characters.
17331 If first element is a symbol, process the cadr or caddr recursively
17332 according to whether the symbol's value is non-nil or nil. */
17333 car = XCAR (elt);
17334 if (EQ (car, QCeval))
17336 /* An element of the form (:eval FORM) means evaluate FORM
17337 and use the result as mode line elements. */
17339 if (risky)
17340 break;
17342 if (CONSP (XCDR (elt)))
17344 Lisp_Object spec;
17345 spec = safe_eval (XCAR (XCDR (elt)));
17346 n += display_mode_element (it, depth, field_width - n,
17347 precision - n, spec, props,
17348 risky);
17351 else if (EQ (car, QCpropertize))
17353 /* An element of the form (:propertize ELT PROPS...)
17354 means display ELT but applying properties PROPS. */
17356 if (risky)
17357 break;
17359 if (CONSP (XCDR (elt)))
17360 n += display_mode_element (it, depth, field_width - n,
17361 precision - n, XCAR (XCDR (elt)),
17362 XCDR (XCDR (elt)), risky);
17364 else if (SYMBOLP (car))
17366 tem = Fboundp (car);
17367 elt = XCDR (elt);
17368 if (!CONSP (elt))
17369 goto invalid;
17370 /* elt is now the cdr, and we know it is a cons cell.
17371 Use its car if CAR has a non-nil value. */
17372 if (!NILP (tem))
17374 tem = Fsymbol_value (car);
17375 if (!NILP (tem))
17377 elt = XCAR (elt);
17378 goto tail_recurse;
17381 /* Symbol's value is nil (or symbol is unbound)
17382 Get the cddr of the original list
17383 and if possible find the caddr and use that. */
17384 elt = XCDR (elt);
17385 if (NILP (elt))
17386 break;
17387 else if (!CONSP (elt))
17388 goto invalid;
17389 elt = XCAR (elt);
17390 goto tail_recurse;
17392 else if (INTEGERP (car))
17394 register int lim = XINT (car);
17395 elt = XCDR (elt);
17396 if (lim < 0)
17398 /* Negative int means reduce maximum width. */
17399 if (precision <= 0)
17400 precision = -lim;
17401 else
17402 precision = min (precision, -lim);
17404 else if (lim > 0)
17406 /* Padding specified. Don't let it be more than
17407 current maximum. */
17408 if (precision > 0)
17409 lim = min (precision, lim);
17411 /* If that's more padding than already wanted, queue it.
17412 But don't reduce padding already specified even if
17413 that is beyond the current truncation point. */
17414 field_width = max (lim, field_width);
17416 goto tail_recurse;
17418 else if (STRINGP (car) || CONSP (car))
17420 register int limit = 50;
17421 /* Limit is to protect against circular lists. */
17422 while (CONSP (elt)
17423 && --limit > 0
17424 && (precision <= 0 || n < precision))
17426 n += display_mode_element (it, depth,
17427 /* Do padding only after the last
17428 element in the list. */
17429 (! CONSP (XCDR (elt))
17430 ? field_width - n
17431 : 0),
17432 precision - n, XCAR (elt),
17433 props, risky);
17434 elt = XCDR (elt);
17438 break;
17440 default:
17441 invalid:
17442 elt = build_string ("*invalid*");
17443 goto tail_recurse;
17446 /* Pad to FIELD_WIDTH. */
17447 if (field_width > 0 && n < field_width)
17449 switch (mode_line_target)
17451 case MODE_LINE_NOPROP:
17452 case MODE_LINE_TITLE:
17453 n += store_mode_line_noprop ("", field_width - n, 0);
17454 break;
17455 case MODE_LINE_STRING:
17456 n += store_mode_line_string ("", Qnil, 0, field_width - n, 0, Qnil);
17457 break;
17458 case MODE_LINE_DISPLAY:
17459 n += display_string ("", Qnil, Qnil, 0, 0, it, field_width - n,
17460 0, 0, 0);
17461 break;
17465 return n;
17468 /* Store a mode-line string element in mode_line_string_list.
17470 If STRING is non-null, display that C string. Otherwise, the Lisp
17471 string LISP_STRING is displayed.
17473 FIELD_WIDTH is the minimum number of output glyphs to produce.
17474 If STRING has fewer characters than FIELD_WIDTH, pad to the right
17475 with spaces. FIELD_WIDTH <= 0 means don't pad.
17477 PRECISION is the maximum number of characters to output from
17478 STRING. PRECISION <= 0 means don't truncate the string.
17480 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
17481 properties to the string.
17483 PROPS are the properties to add to the string.
17484 The mode_line_string_face face property is always added to the string.
17487 static int
17488 store_mode_line_string (string, lisp_string, copy_string, field_width, precision, props)
17489 char *string;
17490 Lisp_Object lisp_string;
17491 int copy_string;
17492 int field_width;
17493 int precision;
17494 Lisp_Object props;
17496 int len;
17497 int n = 0;
17499 if (string != NULL)
17501 len = strlen (string);
17502 if (precision > 0 && len > precision)
17503 len = precision;
17504 lisp_string = make_string (string, len);
17505 if (NILP (props))
17506 props = mode_line_string_face_prop;
17507 else if (!NILP (mode_line_string_face))
17509 Lisp_Object face = Fplist_get (props, Qface);
17510 props = Fcopy_sequence (props);
17511 if (NILP (face))
17512 face = mode_line_string_face;
17513 else
17514 face = Fcons (face, Fcons (mode_line_string_face, Qnil));
17515 props = Fplist_put (props, Qface, face);
17517 Fadd_text_properties (make_number (0), make_number (len),
17518 props, lisp_string);
17520 else
17522 len = XFASTINT (Flength (lisp_string));
17523 if (precision > 0 && len > precision)
17525 len = precision;
17526 lisp_string = Fsubstring (lisp_string, make_number (0), make_number (len));
17527 precision = -1;
17529 if (!NILP (mode_line_string_face))
17531 Lisp_Object face;
17532 if (NILP (props))
17533 props = Ftext_properties_at (make_number (0), lisp_string);
17534 face = Fplist_get (props, Qface);
17535 if (NILP (face))
17536 face = mode_line_string_face;
17537 else
17538 face = Fcons (face, Fcons (mode_line_string_face, Qnil));
17539 props = Fcons (Qface, Fcons (face, Qnil));
17540 if (copy_string)
17541 lisp_string = Fcopy_sequence (lisp_string);
17543 if (!NILP (props))
17544 Fadd_text_properties (make_number (0), make_number (len),
17545 props, lisp_string);
17548 if (len > 0)
17550 mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
17551 n += len;
17554 if (field_width > len)
17556 field_width -= len;
17557 lisp_string = Fmake_string (make_number (field_width), make_number (' '));
17558 if (!NILP (props))
17559 Fadd_text_properties (make_number (0), make_number (field_width),
17560 props, lisp_string);
17561 mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
17562 n += field_width;
17565 return n;
17569 DEFUN ("format-mode-line", Fformat_mode_line, Sformat_mode_line,
17570 1, 4, 0,
17571 doc: /* Format a string out of a mode line format specification.
17572 First arg FORMAT specifies the mode line format (see `mode-line-format'
17573 for details) to use.
17575 Optional second arg FACE specifies the face property to put
17576 on all characters for which no face is specified.
17577 The value t means whatever face the window's mode line currently uses
17578 \(either `mode-line' or `mode-line-inactive', depending).
17579 A value of nil means the default is no face property.
17580 If FACE is an integer, the value string has no text properties.
17582 Optional third and fourth args WINDOW and BUFFER specify the window
17583 and buffer to use as the context for the formatting (defaults
17584 are the selected window and the window's buffer). */)
17585 (format, face, window, buffer)
17586 Lisp_Object format, face, window, buffer;
17588 struct it it;
17589 int len;
17590 struct window *w;
17591 struct buffer *old_buffer = NULL;
17592 int face_id = -1;
17593 int no_props = INTEGERP (face);
17594 int count = SPECPDL_INDEX ();
17595 Lisp_Object str;
17596 int string_start = 0;
17598 if (NILP (window))
17599 window = selected_window;
17600 CHECK_WINDOW (window);
17601 w = XWINDOW (window);
17603 if (NILP (buffer))
17604 buffer = w->buffer;
17605 CHECK_BUFFER (buffer);
17607 /* Make formatting the modeline a non-op when noninteractive, otherwise
17608 there will be problems later caused by a partially initialized frame. */
17609 if (NILP (format) || noninteractive)
17610 return empty_unibyte_string;
17612 if (no_props)
17613 face = Qnil;
17615 if (!NILP (face))
17617 if (EQ (face, Qt))
17618 face = (EQ (window, selected_window) ? Qmode_line : Qmode_line_inactive);
17619 face_id = lookup_named_face (XFRAME (WINDOW_FRAME (w)), face, 0);
17622 if (face_id < 0)
17623 face_id = DEFAULT_FACE_ID;
17625 if (XBUFFER (buffer) != current_buffer)
17626 old_buffer = current_buffer;
17628 /* Save things including mode_line_proptrans_alist,
17629 and set that to nil so that we don't alter the outer value. */
17630 record_unwind_protect (unwind_format_mode_line,
17631 format_mode_line_unwind_data (old_buffer, 1));
17632 mode_line_proptrans_alist = Qnil;
17634 if (old_buffer)
17635 set_buffer_internal_1 (XBUFFER (buffer));
17637 init_iterator (&it, w, -1, -1, NULL, face_id);
17639 if (no_props)
17641 mode_line_target = MODE_LINE_NOPROP;
17642 mode_line_string_face_prop = Qnil;
17643 mode_line_string_list = Qnil;
17644 string_start = MODE_LINE_NOPROP_LEN (0);
17646 else
17648 mode_line_target = MODE_LINE_STRING;
17649 mode_line_string_list = Qnil;
17650 mode_line_string_face = face;
17651 mode_line_string_face_prop
17652 = (NILP (face) ? Qnil : Fcons (Qface, Fcons (face, Qnil)));
17655 push_kboard (FRAME_KBOARD (it.f));
17656 display_mode_element (&it, 0, 0, 0, format, Qnil, 0);
17657 pop_kboard ();
17659 if (no_props)
17661 len = MODE_LINE_NOPROP_LEN (string_start);
17662 str = make_string (mode_line_noprop_buf + string_start, len);
17664 else
17666 mode_line_string_list = Fnreverse (mode_line_string_list);
17667 str = Fmapconcat (intern ("identity"), mode_line_string_list,
17668 empty_unibyte_string);
17671 unbind_to (count, Qnil);
17672 return str;
17675 /* Write a null-terminated, right justified decimal representation of
17676 the positive integer D to BUF using a minimal field width WIDTH. */
17678 static void
17679 pint2str (buf, width, d)
17680 register char *buf;
17681 register int width;
17682 register int d;
17684 register char *p = buf;
17686 if (d <= 0)
17687 *p++ = '0';
17688 else
17690 while (d > 0)
17692 *p++ = d % 10 + '0';
17693 d /= 10;
17697 for (width -= (int) (p - buf); width > 0; --width)
17698 *p++ = ' ';
17699 *p-- = '\0';
17700 while (p > buf)
17702 d = *buf;
17703 *buf++ = *p;
17704 *p-- = d;
17708 /* Write a null-terminated, right justified decimal and "human
17709 readable" representation of the nonnegative integer D to BUF using
17710 a minimal field width WIDTH. D should be smaller than 999.5e24. */
17712 static const char power_letter[] =
17714 0, /* not used */
17715 'k', /* kilo */
17716 'M', /* mega */
17717 'G', /* giga */
17718 'T', /* tera */
17719 'P', /* peta */
17720 'E', /* exa */
17721 'Z', /* zetta */
17722 'Y' /* yotta */
17725 static void
17726 pint2hrstr (buf, width, d)
17727 char *buf;
17728 int width;
17729 int d;
17731 /* We aim to represent the nonnegative integer D as
17732 QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
17733 int quotient = d;
17734 int remainder = 0;
17735 /* -1 means: do not use TENTHS. */
17736 int tenths = -1;
17737 int exponent = 0;
17739 /* Length of QUOTIENT.TENTHS as a string. */
17740 int length;
17742 char * psuffix;
17743 char * p;
17745 if (1000 <= quotient)
17747 /* Scale to the appropriate EXPONENT. */
17750 remainder = quotient % 1000;
17751 quotient /= 1000;
17752 exponent++;
17754 while (1000 <= quotient);
17756 /* Round to nearest and decide whether to use TENTHS or not. */
17757 if (quotient <= 9)
17759 tenths = remainder / 100;
17760 if (50 <= remainder % 100)
17762 if (tenths < 9)
17763 tenths++;
17764 else
17766 quotient++;
17767 if (quotient == 10)
17768 tenths = -1;
17769 else
17770 tenths = 0;
17774 else
17775 if (500 <= remainder)
17777 if (quotient < 999)
17778 quotient++;
17779 else
17781 quotient = 1;
17782 exponent++;
17783 tenths = 0;
17788 /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
17789 if (tenths == -1 && quotient <= 99)
17790 if (quotient <= 9)
17791 length = 1;
17792 else
17793 length = 2;
17794 else
17795 length = 3;
17796 p = psuffix = buf + max (width, length);
17798 /* Print EXPONENT. */
17799 if (exponent)
17800 *psuffix++ = power_letter[exponent];
17801 *psuffix = '\0';
17803 /* Print TENTHS. */
17804 if (tenths >= 0)
17806 *--p = '0' + tenths;
17807 *--p = '.';
17810 /* Print QUOTIENT. */
17813 int digit = quotient % 10;
17814 *--p = '0' + digit;
17816 while ((quotient /= 10) != 0);
17818 /* Print leading spaces. */
17819 while (buf < p)
17820 *--p = ' ';
17823 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
17824 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
17825 type of CODING_SYSTEM. Return updated pointer into BUF. */
17827 static unsigned char invalid_eol_type[] = "(*invalid*)";
17829 static char *
17830 decode_mode_spec_coding (coding_system, buf, eol_flag)
17831 Lisp_Object coding_system;
17832 register char *buf;
17833 int eol_flag;
17835 Lisp_Object val;
17836 int multibyte = !NILP (current_buffer->enable_multibyte_characters);
17837 const unsigned char *eol_str;
17838 int eol_str_len;
17839 /* The EOL conversion we are using. */
17840 Lisp_Object eoltype;
17842 val = CODING_SYSTEM_SPEC (coding_system);
17843 eoltype = Qnil;
17845 if (!VECTORP (val)) /* Not yet decided. */
17847 if (multibyte)
17848 *buf++ = '-';
17849 if (eol_flag)
17850 eoltype = eol_mnemonic_undecided;
17851 /* Don't mention EOL conversion if it isn't decided. */
17853 else
17855 Lisp_Object attrs;
17856 Lisp_Object eolvalue;
17858 attrs = AREF (val, 0);
17859 eolvalue = AREF (val, 2);
17861 if (multibyte)
17862 *buf++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs));
17864 if (eol_flag)
17866 /* The EOL conversion that is normal on this system. */
17868 if (NILP (eolvalue)) /* Not yet decided. */
17869 eoltype = eol_mnemonic_undecided;
17870 else if (VECTORP (eolvalue)) /* Not yet decided. */
17871 eoltype = eol_mnemonic_undecided;
17872 else /* eolvalue is Qunix, Qdos, or Qmac. */
17873 eoltype = (EQ (eolvalue, Qunix)
17874 ? eol_mnemonic_unix
17875 : (EQ (eolvalue, Qdos) == 1
17876 ? eol_mnemonic_dos : eol_mnemonic_mac));
17880 if (eol_flag)
17882 /* Mention the EOL conversion if it is not the usual one. */
17883 if (STRINGP (eoltype))
17885 eol_str = SDATA (eoltype);
17886 eol_str_len = SBYTES (eoltype);
17888 else if (CHARACTERP (eoltype))
17890 unsigned char *tmp = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH);
17891 eol_str_len = CHAR_STRING (XINT (eoltype), tmp);
17892 eol_str = tmp;
17894 else
17896 eol_str = invalid_eol_type;
17897 eol_str_len = sizeof (invalid_eol_type) - 1;
17899 bcopy (eol_str, buf, eol_str_len);
17900 buf += eol_str_len;
17903 return buf;
17906 /* Return a string for the output of a mode line %-spec for window W,
17907 generated by character C. PRECISION >= 0 means don't return a
17908 string longer than that value. FIELD_WIDTH > 0 means pad the
17909 string returned with spaces to that value. Return 1 in *MULTIBYTE
17910 if the result is multibyte text.
17912 Note we operate on the current buffer for most purposes,
17913 the exception being w->base_line_pos. */
17915 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
17917 static char *
17918 decode_mode_spec (w, c, field_width, precision, multibyte)
17919 struct window *w;
17920 register int c;
17921 int field_width, precision;
17922 int *multibyte;
17924 Lisp_Object obj;
17925 struct frame *f = XFRAME (WINDOW_FRAME (w));
17926 char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
17927 struct buffer *b = current_buffer;
17929 obj = Qnil;
17930 *multibyte = 0;
17932 switch (c)
17934 case '*':
17935 if (!NILP (b->read_only))
17936 return "%";
17937 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
17938 return "*";
17939 return "-";
17941 case '+':
17942 /* This differs from %* only for a modified read-only buffer. */
17943 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
17944 return "*";
17945 if (!NILP (b->read_only))
17946 return "%";
17947 return "-";
17949 case '&':
17950 /* This differs from %* in ignoring read-only-ness. */
17951 if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
17952 return "*";
17953 return "-";
17955 case '%':
17956 return "%";
17958 case '[':
17960 int i;
17961 char *p;
17963 if (command_loop_level > 5)
17964 return "[[[... ";
17965 p = decode_mode_spec_buf;
17966 for (i = 0; i < command_loop_level; i++)
17967 *p++ = '[';
17968 *p = 0;
17969 return decode_mode_spec_buf;
17972 case ']':
17974 int i;
17975 char *p;
17977 if (command_loop_level > 5)
17978 return " ...]]]";
17979 p = decode_mode_spec_buf;
17980 for (i = 0; i < command_loop_level; i++)
17981 *p++ = ']';
17982 *p = 0;
17983 return decode_mode_spec_buf;
17986 case '-':
17988 register int i;
17990 /* Let lots_of_dashes be a string of infinite length. */
17991 if (mode_line_target == MODE_LINE_NOPROP ||
17992 mode_line_target == MODE_LINE_STRING)
17993 return "--";
17994 if (field_width <= 0
17995 || field_width > sizeof (lots_of_dashes))
17997 for (i = 0; i < FRAME_MESSAGE_BUF_SIZE (f) - 1; ++i)
17998 decode_mode_spec_buf[i] = '-';
17999 decode_mode_spec_buf[i] = '\0';
18000 return decode_mode_spec_buf;
18002 else
18003 return lots_of_dashes;
18006 case 'b':
18007 obj = b->name;
18008 break;
18010 case 'c':
18011 /* %c and %l are ignored in `frame-title-format'.
18012 (In redisplay_internal, the frame title is drawn _before_ the
18013 windows are updated, so the stuff which depends on actual
18014 window contents (such as %l) may fail to render properly, or
18015 even crash emacs.) */
18016 if (mode_line_target == MODE_LINE_TITLE)
18017 return "";
18018 else
18020 int col = (int) current_column (); /* iftc */
18021 w->column_number_displayed = make_number (col);
18022 pint2str (decode_mode_spec_buf, field_width, col);
18023 return decode_mode_spec_buf;
18026 case 'e':
18027 #ifndef SYSTEM_MALLOC
18029 if (NILP (Vmemory_full))
18030 return "";
18031 else
18032 return "!MEM FULL! ";
18034 #else
18035 return "";
18036 #endif
18038 case 'F':
18039 /* %F displays the frame name. */
18040 if (!NILP (f->title))
18041 return (char *) SDATA (f->title);
18042 if (f->explicit_name || ! FRAME_WINDOW_P (f))
18043 return (char *) SDATA (f->name);
18044 return "Emacs";
18046 case 'f':
18047 obj = b->filename;
18048 break;
18050 case 'i':
18052 int size = ZV - BEGV;
18053 pint2str (decode_mode_spec_buf, field_width, size);
18054 return decode_mode_spec_buf;
18057 case 'I':
18059 int size = ZV - BEGV;
18060 pint2hrstr (decode_mode_spec_buf, field_width, size);
18061 return decode_mode_spec_buf;
18064 case 'l':
18066 int startpos, startpos_byte, line, linepos, linepos_byte;
18067 int topline, nlines, junk, height;
18069 /* %c and %l are ignored in `frame-title-format'. */
18070 if (mode_line_target == MODE_LINE_TITLE)
18071 return "";
18073 startpos = XMARKER (w->start)->charpos;
18074 startpos_byte = marker_byte_position (w->start);
18075 height = WINDOW_TOTAL_LINES (w);
18077 /* If we decided that this buffer isn't suitable for line numbers,
18078 don't forget that too fast. */
18079 if (EQ (w->base_line_pos, w->buffer))
18080 goto no_value;
18081 /* But do forget it, if the window shows a different buffer now. */
18082 else if (BUFFERP (w->base_line_pos))
18083 w->base_line_pos = Qnil;
18085 /* If the buffer is very big, don't waste time. */
18086 if (INTEGERP (Vline_number_display_limit)
18087 && BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
18089 w->base_line_pos = Qnil;
18090 w->base_line_number = Qnil;
18091 goto no_value;
18094 if (INTEGERP (w->base_line_number)
18095 && INTEGERP (w->base_line_pos)
18096 && XFASTINT (w->base_line_pos) <= startpos)
18098 line = XFASTINT (w->base_line_number);
18099 linepos = XFASTINT (w->base_line_pos);
18100 linepos_byte = buf_charpos_to_bytepos (b, linepos);
18102 else
18104 line = 1;
18105 linepos = BUF_BEGV (b);
18106 linepos_byte = BUF_BEGV_BYTE (b);
18109 /* Count lines from base line to window start position. */
18110 nlines = display_count_lines (linepos, linepos_byte,
18111 startpos_byte,
18112 startpos, &junk);
18114 topline = nlines + line;
18116 /* Determine a new base line, if the old one is too close
18117 or too far away, or if we did not have one.
18118 "Too close" means it's plausible a scroll-down would
18119 go back past it. */
18120 if (startpos == BUF_BEGV (b))
18122 w->base_line_number = make_number (topline);
18123 w->base_line_pos = make_number (BUF_BEGV (b));
18125 else if (nlines < height + 25 || nlines > height * 3 + 50
18126 || linepos == BUF_BEGV (b))
18128 int limit = BUF_BEGV (b);
18129 int limit_byte = BUF_BEGV_BYTE (b);
18130 int position;
18131 int distance = (height * 2 + 30) * line_number_display_limit_width;
18133 if (startpos - distance > limit)
18135 limit = startpos - distance;
18136 limit_byte = CHAR_TO_BYTE (limit);
18139 nlines = display_count_lines (startpos, startpos_byte,
18140 limit_byte,
18141 - (height * 2 + 30),
18142 &position);
18143 /* If we couldn't find the lines we wanted within
18144 line_number_display_limit_width chars per line,
18145 give up on line numbers for this window. */
18146 if (position == limit_byte && limit == startpos - distance)
18148 w->base_line_pos = w->buffer;
18149 w->base_line_number = Qnil;
18150 goto no_value;
18153 w->base_line_number = make_number (topline - nlines);
18154 w->base_line_pos = make_number (BYTE_TO_CHAR (position));
18157 /* Now count lines from the start pos to point. */
18158 nlines = display_count_lines (startpos, startpos_byte,
18159 PT_BYTE, PT, &junk);
18161 /* Record that we did display the line number. */
18162 line_number_displayed = 1;
18164 /* Make the string to show. */
18165 pint2str (decode_mode_spec_buf, field_width, topline + nlines);
18166 return decode_mode_spec_buf;
18167 no_value:
18169 char* p = decode_mode_spec_buf;
18170 int pad = field_width - 2;
18171 while (pad-- > 0)
18172 *p++ = ' ';
18173 *p++ = '?';
18174 *p++ = '?';
18175 *p = '\0';
18176 return decode_mode_spec_buf;
18179 break;
18181 case 'm':
18182 obj = b->mode_name;
18183 break;
18185 case 'n':
18186 if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b))
18187 return " Narrow";
18188 break;
18190 case 'p':
18192 int pos = marker_position (w->start);
18193 int total = BUF_ZV (b) - BUF_BEGV (b);
18195 if (XFASTINT (w->window_end_pos) <= BUF_Z (b) - BUF_ZV (b))
18197 if (pos <= BUF_BEGV (b))
18198 return "All";
18199 else
18200 return "Bottom";
18202 else if (pos <= BUF_BEGV (b))
18203 return "Top";
18204 else
18206 if (total > 1000000)
18207 /* Do it differently for a large value, to avoid overflow. */
18208 total = ((pos - BUF_BEGV (b)) + (total / 100) - 1) / (total / 100);
18209 else
18210 total = ((pos - BUF_BEGV (b)) * 100 + total - 1) / total;
18211 /* We can't normally display a 3-digit number,
18212 so get us a 2-digit number that is close. */
18213 if (total == 100)
18214 total = 99;
18215 sprintf (decode_mode_spec_buf, "%2d%%", total);
18216 return decode_mode_spec_buf;
18220 /* Display percentage of size above the bottom of the screen. */
18221 case 'P':
18223 int toppos = marker_position (w->start);
18224 int botpos = BUF_Z (b) - XFASTINT (w->window_end_pos);
18225 int total = BUF_ZV (b) - BUF_BEGV (b);
18227 if (botpos >= BUF_ZV (b))
18229 if (toppos <= BUF_BEGV (b))
18230 return "All";
18231 else
18232 return "Bottom";
18234 else
18236 if (total > 1000000)
18237 /* Do it differently for a large value, to avoid overflow. */
18238 total = ((botpos - BUF_BEGV (b)) + (total / 100) - 1) / (total / 100);
18239 else
18240 total = ((botpos - BUF_BEGV (b)) * 100 + total - 1) / total;
18241 /* We can't normally display a 3-digit number,
18242 so get us a 2-digit number that is close. */
18243 if (total == 100)
18244 total = 99;
18245 if (toppos <= BUF_BEGV (b))
18246 sprintf (decode_mode_spec_buf, "Top%2d%%", total);
18247 else
18248 sprintf (decode_mode_spec_buf, "%2d%%", total);
18249 return decode_mode_spec_buf;
18253 case 's':
18254 /* status of process */
18255 obj = Fget_buffer_process (Fcurrent_buffer ());
18256 if (NILP (obj))
18257 return "no process";
18258 #ifdef subprocesses
18259 obj = Fsymbol_name (Fprocess_status (obj));
18260 #endif
18261 break;
18263 case '@':
18265 Lisp_Object val;
18266 val = call1 (intern ("file-remote-p"), current_buffer->directory);
18267 if (NILP (val))
18268 return "-";
18269 else
18270 return "@";
18273 case 't': /* indicate TEXT or BINARY */
18274 #ifdef MODE_LINE_BINARY_TEXT
18275 return MODE_LINE_BINARY_TEXT (b);
18276 #else
18277 return "T";
18278 #endif
18280 case 'z':
18281 /* coding-system (not including end-of-line format) */
18282 case 'Z':
18283 /* coding-system (including end-of-line type) */
18285 int eol_flag = (c == 'Z');
18286 char *p = decode_mode_spec_buf;
18288 if (! FRAME_WINDOW_P (f))
18290 /* No need to mention EOL here--the terminal never needs
18291 to do EOL conversion. */
18292 p = decode_mode_spec_coding (CODING_ID_NAME
18293 (FRAME_KEYBOARD_CODING (f)->id),
18294 p, 0);
18295 p = decode_mode_spec_coding (CODING_ID_NAME
18296 (FRAME_TERMINAL_CODING (f)->id),
18297 p, 0);
18299 p = decode_mode_spec_coding (b->buffer_file_coding_system,
18300 p, eol_flag);
18302 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
18303 #ifdef subprocesses
18304 obj = Fget_buffer_process (Fcurrent_buffer ());
18305 if (PROCESSP (obj))
18307 p = decode_mode_spec_coding (XPROCESS (obj)->decode_coding_system,
18308 p, eol_flag);
18309 p = decode_mode_spec_coding (XPROCESS (obj)->encode_coding_system,
18310 p, eol_flag);
18312 #endif /* subprocesses */
18313 #endif /* 0 */
18314 *p = 0;
18315 return decode_mode_spec_buf;
18319 if (STRINGP (obj))
18321 *multibyte = STRING_MULTIBYTE (obj);
18322 return (char *) SDATA (obj);
18324 else
18325 return "";
18329 /* Count up to COUNT lines starting from START / START_BYTE.
18330 But don't go beyond LIMIT_BYTE.
18331 Return the number of lines thus found (always nonnegative).
18333 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
18335 static int
18336 display_count_lines (start, start_byte, limit_byte, count, byte_pos_ptr)
18337 int start, start_byte, limit_byte, count;
18338 int *byte_pos_ptr;
18340 register unsigned char *cursor;
18341 unsigned char *base;
18343 register int ceiling;
18344 register unsigned char *ceiling_addr;
18345 int orig_count = count;
18347 /* If we are not in selective display mode,
18348 check only for newlines. */
18349 int selective_display = (!NILP (current_buffer->selective_display)
18350 && !INTEGERP (current_buffer->selective_display));
18352 if (count > 0)
18354 while (start_byte < limit_byte)
18356 ceiling = BUFFER_CEILING_OF (start_byte);
18357 ceiling = min (limit_byte - 1, ceiling);
18358 ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
18359 base = (cursor = BYTE_POS_ADDR (start_byte));
18360 while (1)
18362 if (selective_display)
18363 while (*cursor != '\n' && *cursor != 015 && ++cursor != ceiling_addr)
18365 else
18366 while (*cursor != '\n' && ++cursor != ceiling_addr)
18369 if (cursor != ceiling_addr)
18371 if (--count == 0)
18373 start_byte += cursor - base + 1;
18374 *byte_pos_ptr = start_byte;
18375 return orig_count;
18377 else
18378 if (++cursor == ceiling_addr)
18379 break;
18381 else
18382 break;
18384 start_byte += cursor - base;
18387 else
18389 while (start_byte > limit_byte)
18391 ceiling = BUFFER_FLOOR_OF (start_byte - 1);
18392 ceiling = max (limit_byte, ceiling);
18393 ceiling_addr = BYTE_POS_ADDR (ceiling) - 1;
18394 base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
18395 while (1)
18397 if (selective_display)
18398 while (--cursor != ceiling_addr
18399 && *cursor != '\n' && *cursor != 015)
18401 else
18402 while (--cursor != ceiling_addr && *cursor != '\n')
18405 if (cursor != ceiling_addr)
18407 if (++count == 0)
18409 start_byte += cursor - base + 1;
18410 *byte_pos_ptr = start_byte;
18411 /* When scanning backwards, we should
18412 not count the newline posterior to which we stop. */
18413 return - orig_count - 1;
18416 else
18417 break;
18419 /* Here we add 1 to compensate for the last decrement
18420 of CURSOR, which took it past the valid range. */
18421 start_byte += cursor - base + 1;
18425 *byte_pos_ptr = limit_byte;
18427 if (count < 0)
18428 return - orig_count + count;
18429 return orig_count - count;
18435 /***********************************************************************
18436 Displaying strings
18437 ***********************************************************************/
18439 /* Display a NUL-terminated string, starting with index START.
18441 If STRING is non-null, display that C string. Otherwise, the Lisp
18442 string LISP_STRING is displayed.
18444 If FACE_STRING is not nil, FACE_STRING_POS is a position in
18445 FACE_STRING. Display STRING or LISP_STRING with the face at
18446 FACE_STRING_POS in FACE_STRING:
18448 Display the string in the environment given by IT, but use the
18449 standard display table, temporarily.
18451 FIELD_WIDTH is the minimum number of output glyphs to produce.
18452 If STRING has fewer characters than FIELD_WIDTH, pad to the right
18453 with spaces. If STRING has more characters, more than FIELD_WIDTH
18454 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
18456 PRECISION is the maximum number of characters to output from
18457 STRING. PRECISION < 0 means don't truncate the string.
18459 This is roughly equivalent to printf format specifiers:
18461 FIELD_WIDTH PRECISION PRINTF
18462 ----------------------------------------
18463 -1 -1 %s
18464 -1 10 %.10s
18465 10 -1 %10s
18466 20 10 %20.10s
18468 MULTIBYTE zero means do not display multibyte chars, > 0 means do
18469 display them, and < 0 means obey the current buffer's value of
18470 enable_multibyte_characters.
18472 Value is the number of columns displayed. */
18474 static int
18475 display_string (string, lisp_string, face_string, face_string_pos,
18476 start, it, field_width, precision, max_x, multibyte)
18477 unsigned char *string;
18478 Lisp_Object lisp_string;
18479 Lisp_Object face_string;
18480 EMACS_INT face_string_pos;
18481 EMACS_INT start;
18482 struct it *it;
18483 int field_width, precision, max_x;
18484 int multibyte;
18486 int hpos_at_start = it->hpos;
18487 int saved_face_id = it->face_id;
18488 struct glyph_row *row = it->glyph_row;
18490 /* Initialize the iterator IT for iteration over STRING beginning
18491 with index START. */
18492 reseat_to_string (it, string, lisp_string, start,
18493 precision, field_width, multibyte);
18495 /* If displaying STRING, set up the face of the iterator
18496 from LISP_STRING, if that's given. */
18497 if (STRINGP (face_string))
18499 EMACS_INT endptr;
18500 struct face *face;
18502 it->face_id
18503 = face_at_string_position (it->w, face_string, face_string_pos,
18504 0, it->region_beg_charpos,
18505 it->region_end_charpos,
18506 &endptr, it->base_face_id, 0);
18507 face = FACE_FROM_ID (it->f, it->face_id);
18508 it->face_box_p = face->box != FACE_NO_BOX;
18511 /* Set max_x to the maximum allowed X position. Don't let it go
18512 beyond the right edge of the window. */
18513 if (max_x <= 0)
18514 max_x = it->last_visible_x;
18515 else
18516 max_x = min (max_x, it->last_visible_x);
18518 /* Skip over display elements that are not visible. because IT->w is
18519 hscrolled. */
18520 if (it->current_x < it->first_visible_x)
18521 move_it_in_display_line_to (it, 100000, it->first_visible_x,
18522 MOVE_TO_POS | MOVE_TO_X);
18524 row->ascent = it->max_ascent;
18525 row->height = it->max_ascent + it->max_descent;
18526 row->phys_ascent = it->max_phys_ascent;
18527 row->phys_height = it->max_phys_ascent + it->max_phys_descent;
18528 row->extra_line_spacing = it->max_extra_line_spacing;
18530 /* This condition is for the case that we are called with current_x
18531 past last_visible_x. */
18532 while (it->current_x < max_x)
18534 int x_before, x, n_glyphs_before, i, nglyphs;
18536 /* Get the next display element. */
18537 if (!get_next_display_element (it))
18538 break;
18540 /* Produce glyphs. */
18541 x_before = it->current_x;
18542 n_glyphs_before = it->glyph_row->used[TEXT_AREA];
18543 PRODUCE_GLYPHS (it);
18545 nglyphs = it->glyph_row->used[TEXT_AREA] - n_glyphs_before;
18546 i = 0;
18547 x = x_before;
18548 while (i < nglyphs)
18550 struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
18552 if (!it->truncate_lines_p
18553 && x + glyph->pixel_width > max_x)
18555 /* End of continued line or max_x reached. */
18556 if (CHAR_GLYPH_PADDING_P (*glyph))
18558 /* A wide character is unbreakable. */
18559 it->glyph_row->used[TEXT_AREA] = n_glyphs_before;
18560 it->current_x = x_before;
18562 else
18564 it->glyph_row->used[TEXT_AREA] = n_glyphs_before + i;
18565 it->current_x = x;
18567 break;
18569 else if (x + glyph->pixel_width >= it->first_visible_x)
18571 /* Glyph is at least partially visible. */
18572 ++it->hpos;
18573 if (x < it->first_visible_x)
18574 it->glyph_row->x = x - it->first_visible_x;
18576 else
18578 /* Glyph is off the left margin of the display area.
18579 Should not happen. */
18580 abort ();
18583 row->ascent = max (row->ascent, it->max_ascent);
18584 row->height = max (row->height, it->max_ascent + it->max_descent);
18585 row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
18586 row->phys_height = max (row->phys_height,
18587 it->max_phys_ascent + it->max_phys_descent);
18588 row->extra_line_spacing = max (row->extra_line_spacing,
18589 it->max_extra_line_spacing);
18590 x += glyph->pixel_width;
18591 ++i;
18594 /* Stop if max_x reached. */
18595 if (i < nglyphs)
18596 break;
18598 /* Stop at line ends. */
18599 if (ITERATOR_AT_END_OF_LINE_P (it))
18601 it->continuation_lines_width = 0;
18602 break;
18605 set_iterator_to_next (it, 1);
18607 /* Stop if truncating at the right edge. */
18608 if (it->truncate_lines_p
18609 && it->current_x >= it->last_visible_x)
18611 /* Add truncation mark, but don't do it if the line is
18612 truncated at a padding space. */
18613 if (IT_CHARPOS (*it) < it->string_nchars)
18615 if (!FRAME_WINDOW_P (it->f))
18617 int i, n;
18619 if (it->current_x > it->last_visible_x)
18621 for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
18622 if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
18623 break;
18624 for (n = row->used[TEXT_AREA]; i < n; ++i)
18626 row->used[TEXT_AREA] = i;
18627 produce_special_glyphs (it, IT_TRUNCATION);
18630 produce_special_glyphs (it, IT_TRUNCATION);
18632 it->glyph_row->truncated_on_right_p = 1;
18634 break;
18638 /* Maybe insert a truncation at the left. */
18639 if (it->first_visible_x
18640 && IT_CHARPOS (*it) > 0)
18642 if (!FRAME_WINDOW_P (it->f))
18643 insert_left_trunc_glyphs (it);
18644 it->glyph_row->truncated_on_left_p = 1;
18647 it->face_id = saved_face_id;
18649 /* Value is number of columns displayed. */
18650 return it->hpos - hpos_at_start;
18655 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
18656 appears as an element of LIST or as the car of an element of LIST.
18657 If PROPVAL is a list, compare each element against LIST in that
18658 way, and return 1/2 if any element of PROPVAL is found in LIST.
18659 Otherwise return 0. This function cannot quit.
18660 The return value is 2 if the text is invisible but with an ellipsis
18661 and 1 if it's invisible and without an ellipsis. */
18664 invisible_p (propval, list)
18665 register Lisp_Object propval;
18666 Lisp_Object list;
18668 register Lisp_Object tail, proptail;
18670 for (tail = list; CONSP (tail); tail = XCDR (tail))
18672 register Lisp_Object tem;
18673 tem = XCAR (tail);
18674 if (EQ (propval, tem))
18675 return 1;
18676 if (CONSP (tem) && EQ (propval, XCAR (tem)))
18677 return NILP (XCDR (tem)) ? 1 : 2;
18680 if (CONSP (propval))
18682 for (proptail = propval; CONSP (proptail); proptail = XCDR (proptail))
18684 Lisp_Object propelt;
18685 propelt = XCAR (proptail);
18686 for (tail = list; CONSP (tail); tail = XCDR (tail))
18688 register Lisp_Object tem;
18689 tem = XCAR (tail);
18690 if (EQ (propelt, tem))
18691 return 1;
18692 if (CONSP (tem) && EQ (propelt, XCAR (tem)))
18693 return NILP (XCDR (tem)) ? 1 : 2;
18698 return 0;
18701 DEFUN ("invisible-p", Finvisible_p, Sinvisible_p, 1, 1, 0,
18702 doc: /* Non-nil if the property makes the text invisible.
18703 POS-OR-PROP can be a marker or number, in which case it is taken to be
18704 a position in the current buffer and the value of the `invisible' property
18705 is checked; or it can be some other value, which is then presumed to be the
18706 value of the `invisible' property of the text of interest.
18707 The non-nil value returned can be t for truly invisible text or something
18708 else if the text is replaced by an ellipsis. */)
18709 (pos_or_prop)
18710 Lisp_Object pos_or_prop;
18712 Lisp_Object prop
18713 = (NATNUMP (pos_or_prop) || MARKERP (pos_or_prop)
18714 ? Fget_char_property (pos_or_prop, Qinvisible, Qnil)
18715 : pos_or_prop);
18716 int invis = TEXT_PROP_MEANS_INVISIBLE (prop);
18717 return (invis == 0 ? Qnil
18718 : invis == 1 ? Qt
18719 : make_number (invis));
18722 /* Calculate a width or height in pixels from a specification using
18723 the following elements:
18725 SPEC ::=
18726 NUM - a (fractional) multiple of the default font width/height
18727 (NUM) - specifies exactly NUM pixels
18728 UNIT - a fixed number of pixels, see below.
18729 ELEMENT - size of a display element in pixels, see below.
18730 (NUM . SPEC) - equals NUM * SPEC
18731 (+ SPEC SPEC ...) - add pixel values
18732 (- SPEC SPEC ...) - subtract pixel values
18733 (- SPEC) - negate pixel value
18735 NUM ::=
18736 INT or FLOAT - a number constant
18737 SYMBOL - use symbol's (buffer local) variable binding.
18739 UNIT ::=
18740 in - pixels per inch *)
18741 mm - pixels per 1/1000 meter *)
18742 cm - pixels per 1/100 meter *)
18743 width - width of current font in pixels.
18744 height - height of current font in pixels.
18746 *) using the ratio(s) defined in display-pixels-per-inch.
18748 ELEMENT ::=
18750 left-fringe - left fringe width in pixels
18751 right-fringe - right fringe width in pixels
18753 left-margin - left margin width in pixels
18754 right-margin - right margin width in pixels
18756 scroll-bar - scroll-bar area width in pixels
18758 Examples:
18760 Pixels corresponding to 5 inches:
18761 (5 . in)
18763 Total width of non-text areas on left side of window (if scroll-bar is on left):
18764 '(space :width (+ left-fringe left-margin scroll-bar))
18766 Align to first text column (in header line):
18767 '(space :align-to 0)
18769 Align to middle of text area minus half the width of variable `my-image'
18770 containing a loaded image:
18771 '(space :align-to (0.5 . (- text my-image)))
18773 Width of left margin minus width of 1 character in the default font:
18774 '(space :width (- left-margin 1))
18776 Width of left margin minus width of 2 characters in the current font:
18777 '(space :width (- left-margin (2 . width)))
18779 Center 1 character over left-margin (in header line):
18780 '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
18782 Different ways to express width of left fringe plus left margin minus one pixel:
18783 '(space :width (- (+ left-fringe left-margin) (1)))
18784 '(space :width (+ left-fringe left-margin (- (1))))
18785 '(space :width (+ left-fringe left-margin (-1)))
18789 #define NUMVAL(X) \
18790 ((INTEGERP (X) || FLOATP (X)) \
18791 ? XFLOATINT (X) \
18792 : - 1)
18795 calc_pixel_width_or_height (res, it, prop, font, width_p, align_to)
18796 double *res;
18797 struct it *it;
18798 Lisp_Object prop;
18799 void *font;
18800 int width_p, *align_to;
18802 double pixels;
18804 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
18805 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
18807 if (NILP (prop))
18808 return OK_PIXELS (0);
18810 xassert (FRAME_LIVE_P (it->f));
18812 if (SYMBOLP (prop))
18814 if (SCHARS (SYMBOL_NAME (prop)) == 2)
18816 char *unit = SDATA (SYMBOL_NAME (prop));
18818 if (unit[0] == 'i' && unit[1] == 'n')
18819 pixels = 1.0;
18820 else if (unit[0] == 'm' && unit[1] == 'm')
18821 pixels = 25.4;
18822 else if (unit[0] == 'c' && unit[1] == 'm')
18823 pixels = 2.54;
18824 else
18825 pixels = 0;
18826 if (pixels > 0)
18828 double ppi;
18829 #ifdef HAVE_WINDOW_SYSTEM
18830 if (FRAME_WINDOW_P (it->f)
18831 && (ppi = (width_p
18832 ? FRAME_X_DISPLAY_INFO (it->f)->resx
18833 : FRAME_X_DISPLAY_INFO (it->f)->resy),
18834 ppi > 0))
18835 return OK_PIXELS (ppi / pixels);
18836 #endif
18838 if ((ppi = NUMVAL (Vdisplay_pixels_per_inch), ppi > 0)
18839 || (CONSP (Vdisplay_pixels_per_inch)
18840 && (ppi = (width_p
18841 ? NUMVAL (XCAR (Vdisplay_pixels_per_inch))
18842 : NUMVAL (XCDR (Vdisplay_pixels_per_inch))),
18843 ppi > 0)))
18844 return OK_PIXELS (ppi / pixels);
18846 return 0;
18850 #ifdef HAVE_WINDOW_SYSTEM
18851 if (EQ (prop, Qheight))
18852 return OK_PIXELS (font ? FONT_HEIGHT ((XFontStruct *)font) : FRAME_LINE_HEIGHT (it->f));
18853 if (EQ (prop, Qwidth))
18854 return OK_PIXELS (font ? FONT_WIDTH ((XFontStruct *)font) : FRAME_COLUMN_WIDTH (it->f));
18855 #else
18856 if (EQ (prop, Qheight) || EQ (prop, Qwidth))
18857 return OK_PIXELS (1);
18858 #endif
18860 if (EQ (prop, Qtext))
18861 return OK_PIXELS (width_p
18862 ? window_box_width (it->w, TEXT_AREA)
18863 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w));
18865 if (align_to && *align_to < 0)
18867 *res = 0;
18868 if (EQ (prop, Qleft))
18869 return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA));
18870 if (EQ (prop, Qright))
18871 return OK_ALIGN_TO (window_box_right_offset (it->w, TEXT_AREA));
18872 if (EQ (prop, Qcenter))
18873 return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
18874 + window_box_width (it->w, TEXT_AREA) / 2);
18875 if (EQ (prop, Qleft_fringe))
18876 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
18877 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it->w)
18878 : window_box_right_offset (it->w, LEFT_MARGIN_AREA));
18879 if (EQ (prop, Qright_fringe))
18880 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
18881 ? window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
18882 : window_box_right_offset (it->w, TEXT_AREA));
18883 if (EQ (prop, Qleft_margin))
18884 return OK_ALIGN_TO (window_box_left_offset (it->w, LEFT_MARGIN_AREA));
18885 if (EQ (prop, Qright_margin))
18886 return OK_ALIGN_TO (window_box_left_offset (it->w, RIGHT_MARGIN_AREA));
18887 if (EQ (prop, Qscroll_bar))
18888 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it->w)
18890 : (window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
18891 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
18892 ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
18893 : 0)));
18895 else
18897 if (EQ (prop, Qleft_fringe))
18898 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it->w));
18899 if (EQ (prop, Qright_fringe))
18900 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it->w));
18901 if (EQ (prop, Qleft_margin))
18902 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it->w));
18903 if (EQ (prop, Qright_margin))
18904 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it->w));
18905 if (EQ (prop, Qscroll_bar))
18906 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
18909 prop = Fbuffer_local_value (prop, it->w->buffer);
18912 if (INTEGERP (prop) || FLOATP (prop))
18914 int base_unit = (width_p
18915 ? FRAME_COLUMN_WIDTH (it->f)
18916 : FRAME_LINE_HEIGHT (it->f));
18917 return OK_PIXELS (XFLOATINT (prop) * base_unit);
18920 if (CONSP (prop))
18922 Lisp_Object car = XCAR (prop);
18923 Lisp_Object cdr = XCDR (prop);
18925 if (SYMBOLP (car))
18927 #ifdef HAVE_WINDOW_SYSTEM
18928 if (FRAME_WINDOW_P (it->f)
18929 && valid_image_p (prop))
18931 int id = lookup_image (it->f, prop);
18932 struct image *img = IMAGE_FROM_ID (it->f, id);
18934 return OK_PIXELS (width_p ? img->width : img->height);
18936 #endif
18937 if (EQ (car, Qplus) || EQ (car, Qminus))
18939 int first = 1;
18940 double px;
18942 pixels = 0;
18943 while (CONSP (cdr))
18945 if (!calc_pixel_width_or_height (&px, it, XCAR (cdr),
18946 font, width_p, align_to))
18947 return 0;
18948 if (first)
18949 pixels = (EQ (car, Qplus) ? px : -px), first = 0;
18950 else
18951 pixels += px;
18952 cdr = XCDR (cdr);
18954 if (EQ (car, Qminus))
18955 pixels = -pixels;
18956 return OK_PIXELS (pixels);
18959 car = Fbuffer_local_value (car, it->w->buffer);
18962 if (INTEGERP (car) || FLOATP (car))
18964 double fact;
18965 pixels = XFLOATINT (car);
18966 if (NILP (cdr))
18967 return OK_PIXELS (pixels);
18968 if (calc_pixel_width_or_height (&fact, it, cdr,
18969 font, width_p, align_to))
18970 return OK_PIXELS (pixels * fact);
18971 return 0;
18974 return 0;
18977 return 0;
18981 /***********************************************************************
18982 Glyph Display
18983 ***********************************************************************/
18985 #ifdef HAVE_WINDOW_SYSTEM
18987 #if GLYPH_DEBUG
18989 void
18990 dump_glyph_string (s)
18991 struct glyph_string *s;
18993 fprintf (stderr, "glyph string\n");
18994 fprintf (stderr, " x, y, w, h = %d, %d, %d, %d\n",
18995 s->x, s->y, s->width, s->height);
18996 fprintf (stderr, " ybase = %d\n", s->ybase);
18997 fprintf (stderr, " hl = %d\n", s->hl);
18998 fprintf (stderr, " left overhang = %d, right = %d\n",
18999 s->left_overhang, s->right_overhang);
19000 fprintf (stderr, " nchars = %d\n", s->nchars);
19001 fprintf (stderr, " extends to end of line = %d\n",
19002 s->extends_to_end_of_line_p);
19003 fprintf (stderr, " font height = %d\n", FONT_HEIGHT (s->font));
19004 fprintf (stderr, " bg width = %d\n", s->background_width);
19007 #endif /* GLYPH_DEBUG */
19009 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
19010 of XChar2b structures for S; it can't be allocated in
19011 init_glyph_string because it must be allocated via `alloca'. W
19012 is the window on which S is drawn. ROW and AREA are the glyph row
19013 and area within the row from which S is constructed. START is the
19014 index of the first glyph structure covered by S. HL is a
19015 face-override for drawing S. */
19017 #ifdef HAVE_NTGUI
19018 #define OPTIONAL_HDC(hdc) hdc,
19019 #define DECLARE_HDC(hdc) HDC hdc;
19020 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
19021 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
19022 #endif
19024 #ifndef OPTIONAL_HDC
19025 #define OPTIONAL_HDC(hdc)
19026 #define DECLARE_HDC(hdc)
19027 #define ALLOCATE_HDC(hdc, f)
19028 #define RELEASE_HDC(hdc, f)
19029 #endif
19031 static void
19032 init_glyph_string (s, OPTIONAL_HDC (hdc) char2b, w, row, area, start, hl)
19033 struct glyph_string *s;
19034 DECLARE_HDC (hdc)
19035 XChar2b *char2b;
19036 struct window *w;
19037 struct glyph_row *row;
19038 enum glyph_row_area area;
19039 int start;
19040 enum draw_glyphs_face hl;
19042 bzero (s, sizeof *s);
19043 s->w = w;
19044 s->f = XFRAME (w->frame);
19045 #ifdef HAVE_NTGUI
19046 s->hdc = hdc;
19047 #endif
19048 s->display = FRAME_X_DISPLAY (s->f);
19049 s->window = FRAME_X_WINDOW (s->f);
19050 s->char2b = char2b;
19051 s->hl = hl;
19052 s->row = row;
19053 s->area = area;
19054 s->first_glyph = row->glyphs[area] + start;
19055 s->height = row->height;
19056 s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
19058 /* Display the internal border below the tool-bar window. */
19059 if (WINDOWP (s->f->tool_bar_window)
19060 && s->w == XWINDOW (s->f->tool_bar_window))
19061 s->y -= FRAME_INTERNAL_BORDER_WIDTH (s->f);
19063 s->ybase = s->y + row->ascent;
19067 /* Append the list of glyph strings with head H and tail T to the list
19068 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
19070 static INLINE void
19071 append_glyph_string_lists (head, tail, h, t)
19072 struct glyph_string **head, **tail;
19073 struct glyph_string *h, *t;
19075 if (h)
19077 if (*head)
19078 (*tail)->next = h;
19079 else
19080 *head = h;
19081 h->prev = *tail;
19082 *tail = t;
19087 /* Prepend the list of glyph strings with head H and tail T to the
19088 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
19089 result. */
19091 static INLINE void
19092 prepend_glyph_string_lists (head, tail, h, t)
19093 struct glyph_string **head, **tail;
19094 struct glyph_string *h, *t;
19096 if (h)
19098 if (*head)
19099 (*head)->prev = t;
19100 else
19101 *tail = t;
19102 t->next = *head;
19103 *head = h;
19108 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
19109 Set *HEAD and *TAIL to the resulting list. */
19111 static INLINE void
19112 append_glyph_string (head, tail, s)
19113 struct glyph_string **head, **tail;
19114 struct glyph_string *s;
19116 s->next = s->prev = NULL;
19117 append_glyph_string_lists (head, tail, s, s);
19121 /* Get face and two-byte form of character C in face FACE_ID on frame
19122 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
19123 means we want to display multibyte text. DISPLAY_P non-zero means
19124 make sure that X resources for the face returned are allocated.
19125 Value is a pointer to a realized face that is ready for display if
19126 DISPLAY_P is non-zero. */
19128 static INLINE struct face *
19129 get_char_face_and_encoding (f, c, face_id, char2b, multibyte_p, display_p)
19130 struct frame *f;
19131 int c, face_id;
19132 XChar2b *char2b;
19133 int multibyte_p, display_p;
19135 struct face *face = FACE_FROM_ID (f, face_id);
19137 #ifdef USE_FONT_BACKEND
19138 if (enable_font_backend)
19140 struct font *font = (struct font *) face->font_info;
19142 if (font)
19144 unsigned code = font->driver->encode_char (font, c);
19146 if (code != FONT_INVALID_CODE)
19147 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
19148 else
19149 STORE_XCHAR2B (char2b, 0, 0);
19152 else
19153 #endif /* USE_FONT_BACKEND */
19154 if (!multibyte_p)
19156 /* Unibyte case. We don't have to encode, but we have to make
19157 sure to use a face suitable for unibyte. */
19158 STORE_XCHAR2B (char2b, 0, c);
19159 face_id = FACE_FOR_CHAR (f, face, c, -1, Qnil);
19160 face = FACE_FROM_ID (f, face_id);
19162 else if (c < 128)
19164 /* Case of ASCII in a face known to fit ASCII. */
19165 STORE_XCHAR2B (char2b, 0, c);
19167 else if (face->font != NULL)
19169 struct font_info *font_info
19170 = FONT_INFO_FROM_ID (f, face->font_info_id);
19171 struct charset *charset = CHARSET_FROM_ID (font_info->charset);
19172 unsigned code = ENCODE_CHAR (charset, c);
19174 if (CHARSET_DIMENSION (charset) == 1)
19175 STORE_XCHAR2B (char2b, 0, code);
19176 else
19177 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
19178 /* Maybe encode the character in *CHAR2B. */
19179 FRAME_RIF (f)->encode_char (c, char2b, font_info, charset, NULL);
19182 /* Make sure X resources of the face are allocated. */
19183 #ifdef HAVE_X_WINDOWS
19184 if (display_p)
19185 #endif
19187 xassert (face != NULL);
19188 PREPARE_FACE_FOR_DISPLAY (f, face);
19191 return face;
19195 /* Get face and two-byte form of character glyph GLYPH on frame F.
19196 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
19197 a pointer to a realized face that is ready for display. */
19199 static INLINE struct face *
19200 get_glyph_face_and_encoding (f, glyph, char2b, two_byte_p)
19201 struct frame *f;
19202 struct glyph *glyph;
19203 XChar2b *char2b;
19204 int *two_byte_p;
19206 struct face *face;
19208 xassert (glyph->type == CHAR_GLYPH);
19209 face = FACE_FROM_ID (f, glyph->face_id);
19211 if (two_byte_p)
19212 *two_byte_p = 0;
19214 #ifdef USE_FONT_BACKEND
19215 if (enable_font_backend)
19217 struct font *font = (struct font *) face->font_info;
19219 if (font)
19221 unsigned code = font->driver->encode_char (font, glyph->u.ch);
19223 if (code != FONT_INVALID_CODE)
19224 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
19225 else
19226 STORE_XCHAR2B (char2b, 0, code);
19229 else
19230 #endif /* USE_FONT_BACKEND */
19231 if (!glyph->multibyte_p)
19233 /* Unibyte case. We don't have to encode, but we have to make
19234 sure to use a face suitable for unibyte. */
19235 STORE_XCHAR2B (char2b, 0, glyph->u.ch);
19237 else if (glyph->u.ch < 128)
19239 /* Case of ASCII in a face known to fit ASCII. */
19240 STORE_XCHAR2B (char2b, 0, glyph->u.ch);
19242 else
19244 struct font_info *font_info
19245 = FONT_INFO_FROM_ID (f, face->font_info_id);
19246 if (font_info)
19248 struct charset *charset = CHARSET_FROM_ID (font_info->charset);
19249 unsigned code = ENCODE_CHAR (charset, glyph->u.ch);
19251 if (CHARSET_DIMENSION (charset) == 1)
19252 STORE_XCHAR2B (char2b, 0, code);
19253 else
19254 STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
19256 /* Maybe encode the character in *CHAR2B. */
19257 if (CHARSET_ID (charset) != charset_ascii)
19259 glyph->font_type
19260 = FRAME_RIF (f)->encode_char (glyph->u.ch, char2b, font_info,
19261 charset, two_byte_p);
19266 /* Make sure X resources of the face are allocated. */
19267 xassert (face != NULL);
19268 PREPARE_FACE_FOR_DISPLAY (f, face);
19269 return face;
19273 /* Fill glyph string S with composition components specified by S->cmp.
19275 BASE_FACE is the base face of the composition.
19276 S->gidx is the index of the first component for S.
19278 OVERLAPS non-zero means S should draw the foreground only, and use
19279 its physical height for clipping. See also draw_glyphs.
19281 Value is the index of a component not in S. */
19283 static int
19284 fill_composite_glyph_string (s, base_face, overlaps)
19285 struct glyph_string *s;
19286 struct face *base_face;
19287 int overlaps;
19289 int i;
19291 xassert (s);
19293 s->for_overlaps = overlaps;
19295 #ifdef USE_FONT_BACKEND
19296 if (enable_font_backend && s->cmp->method == COMPOSITION_WITH_GLYPH_STRING)
19298 Lisp_Object gstring
19299 = AREF (XHASH_TABLE (composition_hash_table)->key_and_value,
19300 s->cmp->hash_index * 2);
19302 s->face = base_face;
19303 s->font_info = base_face->font_info;
19304 s->font = s->font_info->font;
19305 for (i = 0, s->nchars = 0; i < s->cmp->glyph_len; i++, s->nchars++)
19307 Lisp_Object g = LGSTRING_GLYPH (gstring, i);
19308 unsigned code;
19309 XChar2b * store_pos;
19310 if (NILP (g))
19311 break;
19312 code = LGLYPH_CODE (g);
19313 store_pos = s->char2b + i;
19314 STORE_XCHAR2B (store_pos, code >> 8, code & 0xFF);
19316 s->width = s->cmp->pixel_width;
19318 else
19319 #endif /* USE_FONT_BACKEND */
19321 /* For all glyphs of this composition, starting at the offset
19322 S->gidx, until we reach the end of the definition or encounter a
19323 glyph that requires the different face, add it to S. */
19324 struct face *face;
19326 s->face = NULL;
19327 s->font = NULL;
19328 s->font_info = NULL;
19329 for (i = s->gidx; i < s->cmp->glyph_len; i++)
19331 int c = COMPOSITION_GLYPH (s->cmp, i);
19333 if (c != '\t')
19335 int face_id = FACE_FOR_CHAR (s->f, base_face->ascii_face, c,
19336 -1, Qnil);
19338 face = get_char_face_and_encoding (s->f, c, face_id,
19339 s->char2b + i, 1, 1);
19340 if (face)
19342 if (! s->face)
19344 s->face = face;
19345 s->font = s->face->font;
19346 s->font_info = FONT_INFO_FROM_FACE (s->f, s->face);
19348 else if (s->face != face)
19349 break;
19352 ++s->nchars;
19355 /* All glyph strings for the same composition has the same width,
19356 i.e. the width set for the first component of the composition. */
19357 s->width = s->first_glyph->pixel_width;
19360 /* If the specified font could not be loaded, use the frame's
19361 default font, but record the fact that we couldn't load it in
19362 the glyph string so that we can draw rectangles for the
19363 characters of the glyph string. */
19364 if (s->font == NULL)
19366 s->font_not_found_p = 1;
19367 s->font = FRAME_FONT (s->f);
19370 /* Adjust base line for subscript/superscript text. */
19371 s->ybase += s->first_glyph->voffset;
19373 /* This glyph string must always be drawn with 16-bit functions. */
19374 s->two_byte_p = 1;
19376 return s->gidx + s->nchars;
19380 /* Fill glyph string S from a sequence of character glyphs.
19382 FACE_ID is the face id of the string. START is the index of the
19383 first glyph to consider, END is the index of the last + 1.
19384 OVERLAPS non-zero means S should draw the foreground only, and use
19385 its physical height for clipping. See also draw_glyphs.
19387 Value is the index of the first glyph not in S. */
19389 static int
19390 fill_glyph_string (s, face_id, start, end, overlaps)
19391 struct glyph_string *s;
19392 int face_id;
19393 int start, end, overlaps;
19395 struct glyph *glyph, *last;
19396 int voffset;
19397 int glyph_not_available_p;
19399 xassert (s->f == XFRAME (s->w->frame));
19400 xassert (s->nchars == 0);
19401 xassert (start >= 0 && end > start);
19403 s->for_overlaps = overlaps,
19404 glyph = s->row->glyphs[s->area] + start;
19405 last = s->row->glyphs[s->area] + end;
19406 voffset = glyph->voffset;
19407 s->padding_p = glyph->padding_p;
19408 glyph_not_available_p = glyph->glyph_not_available_p;
19410 while (glyph < last
19411 && glyph->type == CHAR_GLYPH
19412 && glyph->voffset == voffset
19413 /* Same face id implies same font, nowadays. */
19414 && glyph->face_id == face_id
19415 && glyph->glyph_not_available_p == glyph_not_available_p)
19417 int two_byte_p;
19419 s->face = get_glyph_face_and_encoding (s->f, glyph,
19420 s->char2b + s->nchars,
19421 &two_byte_p);
19422 s->two_byte_p = two_byte_p;
19423 ++s->nchars;
19424 xassert (s->nchars <= end - start);
19425 s->width += glyph->pixel_width;
19426 if (glyph++->padding_p != s->padding_p)
19427 break;
19430 s->font = s->face->font;
19431 s->font_info = FONT_INFO_FROM_FACE (s->f, s->face);
19433 /* If the specified font could not be loaded, use the frame's font,
19434 but record the fact that we couldn't load it in
19435 S->font_not_found_p so that we can draw rectangles for the
19436 characters of the glyph string. */
19437 if (s->font == NULL || glyph_not_available_p)
19439 s->font_not_found_p = 1;
19440 s->font = FRAME_FONT (s->f);
19443 /* Adjust base line for subscript/superscript text. */
19444 s->ybase += voffset;
19446 xassert (s->face && s->face->gc);
19447 return glyph - s->row->glyphs[s->area];
19451 /* Fill glyph string S from image glyph S->first_glyph. */
19453 static void
19454 fill_image_glyph_string (s)
19455 struct glyph_string *s;
19457 xassert (s->first_glyph->type == IMAGE_GLYPH);
19458 s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
19459 xassert (s->img);
19460 s->slice = s->first_glyph->slice;
19461 s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
19462 s->font = s->face->font;
19463 s->width = s->first_glyph->pixel_width;
19465 /* Adjust base line for subscript/superscript text. */
19466 s->ybase += s->first_glyph->voffset;
19470 /* Fill glyph string S from a sequence of stretch glyphs.
19472 ROW is the glyph row in which the glyphs are found, AREA is the
19473 area within the row. START is the index of the first glyph to
19474 consider, END is the index of the last + 1.
19476 Value is the index of the first glyph not in S. */
19478 static int
19479 fill_stretch_glyph_string (s, row, area, start, end)
19480 struct glyph_string *s;
19481 struct glyph_row *row;
19482 enum glyph_row_area area;
19483 int start, end;
19485 struct glyph *glyph, *last;
19486 int voffset, face_id;
19488 xassert (s->first_glyph->type == STRETCH_GLYPH);
19490 glyph = s->row->glyphs[s->area] + start;
19491 last = s->row->glyphs[s->area] + end;
19492 face_id = glyph->face_id;
19493 s->face = FACE_FROM_ID (s->f, face_id);
19494 s->font = s->face->font;
19495 s->font_info = FONT_INFO_FROM_FACE (s->f, s->face);
19496 s->width = glyph->pixel_width;
19497 s->nchars = 1;
19498 voffset = glyph->voffset;
19500 for (++glyph;
19501 (glyph < last
19502 && glyph->type == STRETCH_GLYPH
19503 && glyph->voffset == voffset
19504 && glyph->face_id == face_id);
19505 ++glyph)
19506 s->width += glyph->pixel_width;
19508 /* Adjust base line for subscript/superscript text. */
19509 s->ybase += voffset;
19511 /* The case that face->gc == 0 is handled when drawing the glyph
19512 string by calling PREPARE_FACE_FOR_DISPLAY. */
19513 xassert (s->face);
19514 return glyph - s->row->glyphs[s->area];
19517 static XCharStruct *
19518 get_per_char_metric (f, font, font_info, char2b, font_type)
19519 struct frame *f;
19520 XFontStruct *font;
19521 struct font_info *font_info;
19522 XChar2b *char2b;
19523 int font_type;
19525 #ifdef USE_FONT_BACKEND
19526 if (enable_font_backend)
19528 static XCharStruct pcm_value;
19529 unsigned code = (XCHAR2B_BYTE1 (char2b) << 8) | XCHAR2B_BYTE2 (char2b);
19530 struct font *fontp;
19531 struct font_metrics metrics;
19533 if (! font_info || code == FONT_INVALID_CODE)
19534 return NULL;
19535 fontp = (struct font *) font_info;
19536 fontp->driver->text_extents (fontp, &code, 1, &metrics);
19537 pcm_value.lbearing = metrics.lbearing;
19538 pcm_value.rbearing = metrics.rbearing;
19539 pcm_value.ascent = metrics.ascent;
19540 pcm_value.descent = metrics.descent;
19541 pcm_value.width = metrics.width;
19542 return &pcm_value;
19544 #endif /* USE_FONT_BACKEND */
19545 return FRAME_RIF (f)->per_char_metric (font, char2b, font_type);
19548 /* EXPORT for RIF:
19549 Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
19550 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
19551 assumed to be zero. */
19553 void
19554 x_get_glyph_overhangs (glyph, f, left, right)
19555 struct glyph *glyph;
19556 struct frame *f;
19557 int *left, *right;
19559 *left = *right = 0;
19561 if (glyph->type == CHAR_GLYPH)
19563 XFontStruct *font;
19564 struct face *face;
19565 struct font_info *font_info;
19566 XChar2b char2b;
19567 XCharStruct *pcm;
19569 face = get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
19570 font = face->font;
19571 font_info = FONT_INFO_FROM_FACE (f, face);
19572 if (font /* ++KFS: Should this be font_info ? */
19573 && (pcm = get_per_char_metric (f, font, font_info, &char2b, glyph->font_type)))
19575 if (pcm->rbearing > pcm->width)
19576 *right = pcm->rbearing - pcm->width;
19577 if (pcm->lbearing < 0)
19578 *left = -pcm->lbearing;
19581 else if (glyph->type == COMPOSITE_GLYPH)
19583 struct composition *cmp = composition_table[glyph->u.cmp_id];
19585 *right = cmp->rbearing - cmp->pixel_width;
19586 *left = - cmp->lbearing;
19591 /* Return the index of the first glyph preceding glyph string S that
19592 is overwritten by S because of S's left overhang. Value is -1
19593 if no glyphs are overwritten. */
19595 static int
19596 left_overwritten (s)
19597 struct glyph_string *s;
19599 int k;
19601 if (s->left_overhang)
19603 int x = 0, i;
19604 struct glyph *glyphs = s->row->glyphs[s->area];
19605 int first = s->first_glyph - glyphs;
19607 for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
19608 x -= glyphs[i].pixel_width;
19610 k = i + 1;
19612 else
19613 k = -1;
19615 return k;
19619 /* Return the index of the first glyph preceding glyph string S that
19620 is overwriting S because of its right overhang. Value is -1 if no
19621 glyph in front of S overwrites S. */
19623 static int
19624 left_overwriting (s)
19625 struct glyph_string *s;
19627 int i, k, x;
19628 struct glyph *glyphs = s->row->glyphs[s->area];
19629 int first = s->first_glyph - glyphs;
19631 k = -1;
19632 x = 0;
19633 for (i = first - 1; i >= 0; --i)
19635 int left, right;
19636 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
19637 if (x + right > 0)
19638 k = i;
19639 x -= glyphs[i].pixel_width;
19642 return k;
19646 /* Return the index of the last glyph following glyph string S that is
19647 not overwritten by S because of S's right overhang. Value is -1 if
19648 no such glyph is found. */
19650 static int
19651 right_overwritten (s)
19652 struct glyph_string *s;
19654 int k = -1;
19656 if (s->right_overhang)
19658 int x = 0, i;
19659 struct glyph *glyphs = s->row->glyphs[s->area];
19660 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
19661 int end = s->row->used[s->area];
19663 for (i = first; i < end && s->right_overhang > x; ++i)
19664 x += glyphs[i].pixel_width;
19666 k = i;
19669 return k;
19673 /* Return the index of the last glyph following glyph string S that
19674 overwrites S because of its left overhang. Value is negative
19675 if no such glyph is found. */
19677 static int
19678 right_overwriting (s)
19679 struct glyph_string *s;
19681 int i, k, x;
19682 int end = s->row->used[s->area];
19683 struct glyph *glyphs = s->row->glyphs[s->area];
19684 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
19686 k = -1;
19687 x = 0;
19688 for (i = first; i < end; ++i)
19690 int left, right;
19691 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
19692 if (x - left < 0)
19693 k = i;
19694 x += glyphs[i].pixel_width;
19697 return k;
19701 /* Set background width of glyph string S. START is the index of the
19702 first glyph following S. LAST_X is the right-most x-position + 1
19703 in the drawing area. */
19705 static INLINE void
19706 set_glyph_string_background_width (s, start, last_x)
19707 struct glyph_string *s;
19708 int start;
19709 int last_x;
19711 /* If the face of this glyph string has to be drawn to the end of
19712 the drawing area, set S->extends_to_end_of_line_p. */
19714 if (start == s->row->used[s->area]
19715 && s->area == TEXT_AREA
19716 && ((s->row->fill_line_p
19717 && (s->hl == DRAW_NORMAL_TEXT
19718 || s->hl == DRAW_IMAGE_RAISED
19719 || s->hl == DRAW_IMAGE_SUNKEN))
19720 || s->hl == DRAW_MOUSE_FACE))
19721 s->extends_to_end_of_line_p = 1;
19723 /* If S extends its face to the end of the line, set its
19724 background_width to the distance to the right edge of the drawing
19725 area. */
19726 if (s->extends_to_end_of_line_p)
19727 s->background_width = last_x - s->x + 1;
19728 else
19729 s->background_width = s->width;
19733 /* Compute overhangs and x-positions for glyph string S and its
19734 predecessors, or successors. X is the starting x-position for S.
19735 BACKWARD_P non-zero means process predecessors. */
19737 static void
19738 compute_overhangs_and_x (s, x, backward_p)
19739 struct glyph_string *s;
19740 int x;
19741 int backward_p;
19743 if (backward_p)
19745 while (s)
19747 if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
19748 FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
19749 x -= s->width;
19750 s->x = x;
19751 s = s->prev;
19754 else
19756 while (s)
19758 if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
19759 FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
19760 s->x = x;
19761 x += s->width;
19762 s = s->next;
19769 /* The following macros are only called from draw_glyphs below.
19770 They reference the following parameters of that function directly:
19771 `w', `row', `area', and `overlap_p'
19772 as well as the following local variables:
19773 `s', `f', and `hdc' (in W32) */
19775 #ifdef HAVE_NTGUI
19776 /* On W32, silently add local `hdc' variable to argument list of
19777 init_glyph_string. */
19778 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
19779 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
19780 #else
19781 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
19782 init_glyph_string (s, char2b, w, row, area, start, hl)
19783 #endif
19785 /* Add a glyph string for a stretch glyph to the list of strings
19786 between HEAD and TAIL. START is the index of the stretch glyph in
19787 row area AREA of glyph row ROW. END is the index of the last glyph
19788 in that glyph row area. X is the current output position assigned
19789 to the new glyph string constructed. HL overrides that face of the
19790 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
19791 is the right-most x-position of the drawing area. */
19793 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
19794 and below -- keep them on one line. */
19795 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
19796 do \
19798 s = (struct glyph_string *) alloca (sizeof *s); \
19799 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
19800 START = fill_stretch_glyph_string (s, row, area, START, END); \
19801 append_glyph_string (&HEAD, &TAIL, s); \
19802 s->x = (X); \
19804 while (0)
19807 /* Add a glyph string for an image glyph to the list of strings
19808 between HEAD and TAIL. START is the index of the image glyph in
19809 row area AREA of glyph row ROW. END is the index of the last glyph
19810 in that glyph row area. X is the current output position assigned
19811 to the new glyph string constructed. HL overrides that face of the
19812 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
19813 is the right-most x-position of the drawing area. */
19815 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
19816 do \
19818 s = (struct glyph_string *) alloca (sizeof *s); \
19819 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
19820 fill_image_glyph_string (s); \
19821 append_glyph_string (&HEAD, &TAIL, s); \
19822 ++START; \
19823 s->x = (X); \
19825 while (0)
19828 /* Add a glyph string for a sequence of character glyphs to the list
19829 of strings between HEAD and TAIL. START is the index of the first
19830 glyph in row area AREA of glyph row ROW that is part of the new
19831 glyph string. END is the index of the last glyph in that glyph row
19832 area. X is the current output position assigned to the new glyph
19833 string constructed. HL overrides that face of the glyph; e.g. it
19834 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
19835 right-most x-position of the drawing area. */
19837 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
19838 do \
19840 int face_id; \
19841 XChar2b *char2b; \
19843 face_id = (row)->glyphs[area][START].face_id; \
19845 s = (struct glyph_string *) alloca (sizeof *s); \
19846 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
19847 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
19848 append_glyph_string (&HEAD, &TAIL, s); \
19849 s->x = (X); \
19850 START = fill_glyph_string (s, face_id, START, END, overlaps); \
19852 while (0)
19855 /* Add a glyph string for a composite sequence to the list of strings
19856 between HEAD and TAIL. START is the index of the first glyph in
19857 row area AREA of glyph row ROW that is part of the new glyph
19858 string. END is the index of the last glyph in that glyph row area.
19859 X is the current output position assigned to the new glyph string
19860 constructed. HL overrides that face of the glyph; e.g. it is
19861 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
19862 x-position of the drawing area. */
19864 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
19865 do { \
19866 int face_id = (row)->glyphs[area][START].face_id; \
19867 struct face *base_face = FACE_FROM_ID (f, face_id); \
19868 int cmp_id = (row)->glyphs[area][START].u.cmp_id; \
19869 struct composition *cmp = composition_table[cmp_id]; \
19870 XChar2b *char2b; \
19871 struct glyph_string *first_s; \
19872 int n; \
19874 char2b = (XChar2b *) alloca ((sizeof *char2b) * cmp->glyph_len); \
19876 /* Make glyph_strings for each glyph sequence that is drawable by \
19877 the same face, and append them to HEAD/TAIL. */ \
19878 for (n = 0; n < cmp->glyph_len;) \
19880 s = (struct glyph_string *) alloca (sizeof *s); \
19881 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
19882 append_glyph_string (&(HEAD), &(TAIL), s); \
19883 s->cmp = cmp; \
19884 s->gidx = n; \
19885 s->x = (X); \
19886 if (n == 0) \
19887 first_s = s; \
19888 n = fill_composite_glyph_string (s, base_face, overlaps); \
19891 ++START; \
19892 s = first_s; \
19893 } while (0)
19896 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
19897 of AREA of glyph row ROW on window W between indices START and END.
19898 HL overrides the face for drawing glyph strings, e.g. it is
19899 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
19900 x-positions of the drawing area.
19902 This is an ugly monster macro construct because we must use alloca
19903 to allocate glyph strings (because draw_glyphs can be called
19904 asynchronously). */
19906 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
19907 do \
19909 HEAD = TAIL = NULL; \
19910 while (START < END) \
19912 struct glyph *first_glyph = (row)->glyphs[area] + START; \
19913 switch (first_glyph->type) \
19915 case CHAR_GLYPH: \
19916 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
19917 HL, X, LAST_X); \
19918 break; \
19920 case COMPOSITE_GLYPH: \
19921 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
19922 HL, X, LAST_X); \
19923 break; \
19925 case STRETCH_GLYPH: \
19926 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
19927 HL, X, LAST_X); \
19928 break; \
19930 case IMAGE_GLYPH: \
19931 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
19932 HL, X, LAST_X); \
19933 break; \
19935 default: \
19936 abort (); \
19939 if (s) \
19941 set_glyph_string_background_width (s, START, LAST_X); \
19942 (X) += s->width; \
19946 while (0)
19949 /* Draw glyphs between START and END in AREA of ROW on window W,
19950 starting at x-position X. X is relative to AREA in W. HL is a
19951 face-override with the following meaning:
19953 DRAW_NORMAL_TEXT draw normally
19954 DRAW_CURSOR draw in cursor face
19955 DRAW_MOUSE_FACE draw in mouse face.
19956 DRAW_INVERSE_VIDEO draw in mode line face
19957 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
19958 DRAW_IMAGE_RAISED draw an image with a raised relief around it
19960 If OVERLAPS is non-zero, draw only the foreground of characters and
19961 clip to the physical height of ROW. Non-zero value also defines
19962 the overlapping part to be drawn:
19964 OVERLAPS_PRED overlap with preceding rows
19965 OVERLAPS_SUCC overlap with succeeding rows
19966 OVERLAPS_BOTH overlap with both preceding/succeeding rows
19967 OVERLAPS_ERASED_CURSOR overlap with erased cursor area
19969 Value is the x-position reached, relative to AREA of W. */
19971 static int
19972 draw_glyphs (w, x, row, area, start, end, hl, overlaps)
19973 struct window *w;
19974 int x;
19975 struct glyph_row *row;
19976 enum glyph_row_area area;
19977 EMACS_INT start, end;
19978 enum draw_glyphs_face hl;
19979 int overlaps;
19981 struct glyph_string *head, *tail;
19982 struct glyph_string *s;
19983 struct glyph_string *clip_head = NULL, *clip_tail = NULL;
19984 int last_x, area_width;
19985 int x_reached;
19986 int i, j;
19987 struct frame *f = XFRAME (WINDOW_FRAME (w));
19988 DECLARE_HDC (hdc);
19990 ALLOCATE_HDC (hdc, f);
19992 /* Let's rather be paranoid than getting a SEGV. */
19993 end = min (end, row->used[area]);
19994 start = max (0, start);
19995 start = min (end, start);
19997 /* Translate X to frame coordinates. Set last_x to the right
19998 end of the drawing area. */
19999 if (row->full_width_p)
20001 /* X is relative to the left edge of W, without scroll bars
20002 or fringes. */
20003 x += WINDOW_LEFT_EDGE_X (w);
20004 last_x = WINDOW_LEFT_EDGE_X (w) + WINDOW_TOTAL_WIDTH (w);
20006 else
20008 int area_left = window_box_left (w, area);
20009 x += area_left;
20010 area_width = window_box_width (w, area);
20011 last_x = area_left + area_width;
20014 /* Build a doubly-linked list of glyph_string structures between
20015 head and tail from what we have to draw. Note that the macro
20016 BUILD_GLYPH_STRINGS will modify its start parameter. That's
20017 the reason we use a separate variable `i'. */
20018 i = start;
20019 BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
20020 if (tail)
20021 x_reached = tail->x + tail->background_width;
20022 else
20023 x_reached = x;
20025 /* If there are any glyphs with lbearing < 0 or rbearing > width in
20026 the row, redraw some glyphs in front or following the glyph
20027 strings built above. */
20028 if (head && !overlaps && row->contains_overlapping_glyphs_p)
20030 int dummy_x = 0;
20031 struct glyph_string *h, *t;
20033 /* Compute overhangs for all glyph strings. */
20034 if (FRAME_RIF (f)->compute_glyph_string_overhangs)
20035 for (s = head; s; s = s->next)
20036 FRAME_RIF (f)->compute_glyph_string_overhangs (s);
20038 /* Prepend glyph strings for glyphs in front of the first glyph
20039 string that are overwritten because of the first glyph
20040 string's left overhang. The background of all strings
20041 prepended must be drawn because the first glyph string
20042 draws over it. */
20043 i = left_overwritten (head);
20044 if (i >= 0)
20046 j = i;
20047 BUILD_GLYPH_STRINGS (j, start, h, t,
20048 DRAW_NORMAL_TEXT, dummy_x, last_x);
20049 start = i;
20050 compute_overhangs_and_x (t, head->x, 1);
20051 prepend_glyph_string_lists (&head, &tail, h, t);
20052 clip_head = head;
20055 /* Prepend glyph strings for glyphs in front of the first glyph
20056 string that overwrite that glyph string because of their
20057 right overhang. For these strings, only the foreground must
20058 be drawn, because it draws over the glyph string at `head'.
20059 The background must not be drawn because this would overwrite
20060 right overhangs of preceding glyphs for which no glyph
20061 strings exist. */
20062 i = left_overwriting (head);
20063 if (i >= 0)
20065 clip_head = head;
20066 BUILD_GLYPH_STRINGS (i, start, h, t,
20067 DRAW_NORMAL_TEXT, dummy_x, last_x);
20068 for (s = h; s; s = s->next)
20069 s->background_filled_p = 1;
20070 compute_overhangs_and_x (t, head->x, 1);
20071 prepend_glyph_string_lists (&head, &tail, h, t);
20074 /* Append glyphs strings for glyphs following the last glyph
20075 string tail that are overwritten by tail. The background of
20076 these strings has to be drawn because tail's foreground draws
20077 over it. */
20078 i = right_overwritten (tail);
20079 if (i >= 0)
20081 BUILD_GLYPH_STRINGS (end, i, h, t,
20082 DRAW_NORMAL_TEXT, x, last_x);
20083 compute_overhangs_and_x (h, tail->x + tail->width, 0);
20084 append_glyph_string_lists (&head, &tail, h, t);
20085 clip_tail = tail;
20088 /* Append glyph strings for glyphs following the last glyph
20089 string tail that overwrite tail. The foreground of such
20090 glyphs has to be drawn because it writes into the background
20091 of tail. The background must not be drawn because it could
20092 paint over the foreground of following glyphs. */
20093 i = right_overwriting (tail);
20094 if (i >= 0)
20096 clip_tail = tail;
20097 i++; /* We must include the Ith glyph. */
20098 BUILD_GLYPH_STRINGS (end, i, h, t,
20099 DRAW_NORMAL_TEXT, x, last_x);
20100 for (s = h; s; s = s->next)
20101 s->background_filled_p = 1;
20102 compute_overhangs_and_x (h, tail->x + tail->width, 0);
20103 append_glyph_string_lists (&head, &tail, h, t);
20105 if (clip_head || clip_tail)
20106 for (s = head; s; s = s->next)
20108 s->clip_head = clip_head;
20109 s->clip_tail = clip_tail;
20113 /* Draw all strings. */
20114 for (s = head; s; s = s->next)
20115 FRAME_RIF (f)->draw_glyph_string (s);
20117 if (area == TEXT_AREA
20118 && !row->full_width_p
20119 /* When drawing overlapping rows, only the glyph strings'
20120 foreground is drawn, which doesn't erase a cursor
20121 completely. */
20122 && !overlaps)
20124 int x0 = clip_head ? clip_head->x : (head ? head->x : x);
20125 int x1 = (clip_tail ? clip_tail->x + clip_tail->background_width
20126 : (tail ? tail->x + tail->background_width : x));
20128 int text_left = window_box_left (w, TEXT_AREA);
20129 x0 -= text_left;
20130 x1 -= text_left;
20132 notice_overwritten_cursor (w, TEXT_AREA, x0, x1,
20133 row->y, MATRIX_ROW_BOTTOM_Y (row));
20136 /* Value is the x-position up to which drawn, relative to AREA of W.
20137 This doesn't include parts drawn because of overhangs. */
20138 if (row->full_width_p)
20139 x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
20140 else
20141 x_reached -= window_box_left (w, area);
20143 RELEASE_HDC (hdc, f);
20145 return x_reached;
20148 /* Expand row matrix if too narrow. Don't expand if area
20149 is not present. */
20151 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
20153 if (!fonts_changed_p \
20154 && (it->glyph_row->glyphs[area] \
20155 < it->glyph_row->glyphs[area + 1])) \
20157 it->w->ncols_scale_factor++; \
20158 fonts_changed_p = 1; \
20162 /* Store one glyph for IT->char_to_display in IT->glyph_row.
20163 Called from x_produce_glyphs when IT->glyph_row is non-null. */
20165 static INLINE void
20166 append_glyph (it)
20167 struct it *it;
20169 struct glyph *glyph;
20170 enum glyph_row_area area = it->area;
20172 xassert (it->glyph_row);
20173 xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
20175 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
20176 if (glyph < it->glyph_row->glyphs[area + 1])
20178 glyph->charpos = CHARPOS (it->position);
20179 glyph->object = it->object;
20180 if (it->pixel_width > 0)
20182 glyph->pixel_width = it->pixel_width;
20183 glyph->padding_p = 0;
20185 else
20187 /* Assure at least 1-pixel width. Otherwise, cursor can't
20188 be displayed correctly. */
20189 glyph->pixel_width = 1;
20190 glyph->padding_p = 1;
20192 glyph->ascent = it->ascent;
20193 glyph->descent = it->descent;
20194 glyph->voffset = it->voffset;
20195 glyph->type = CHAR_GLYPH;
20196 glyph->multibyte_p = it->multibyte_p;
20197 glyph->left_box_line_p = it->start_of_box_run_p;
20198 glyph->right_box_line_p = it->end_of_box_run_p;
20199 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
20200 || it->phys_descent > it->descent);
20201 glyph->glyph_not_available_p = it->glyph_not_available_p;
20202 glyph->face_id = it->face_id;
20203 glyph->u.ch = it->char_to_display;
20204 glyph->slice = null_glyph_slice;
20205 glyph->font_type = FONT_TYPE_UNKNOWN;
20206 ++it->glyph_row->used[area];
20208 else
20209 IT_EXPAND_MATRIX_WIDTH (it, area);
20212 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
20213 Called from x_produce_glyphs when IT->glyph_row is non-null. */
20215 static INLINE void
20216 append_composite_glyph (it)
20217 struct it *it;
20219 struct glyph *glyph;
20220 enum glyph_row_area area = it->area;
20222 xassert (it->glyph_row);
20224 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
20225 if (glyph < it->glyph_row->glyphs[area + 1])
20227 glyph->charpos = CHARPOS (it->position);
20228 glyph->object = it->object;
20229 glyph->pixel_width = it->pixel_width;
20230 glyph->ascent = it->ascent;
20231 glyph->descent = it->descent;
20232 glyph->voffset = it->voffset;
20233 glyph->type = COMPOSITE_GLYPH;
20234 glyph->multibyte_p = it->multibyte_p;
20235 glyph->left_box_line_p = it->start_of_box_run_p;
20236 glyph->right_box_line_p = it->end_of_box_run_p;
20237 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
20238 || it->phys_descent > it->descent);
20239 glyph->padding_p = 0;
20240 glyph->glyph_not_available_p = 0;
20241 glyph->face_id = it->face_id;
20242 glyph->u.cmp_id = it->cmp_id;
20243 glyph->slice = null_glyph_slice;
20244 glyph->font_type = FONT_TYPE_UNKNOWN;
20245 ++it->glyph_row->used[area];
20247 else
20248 IT_EXPAND_MATRIX_WIDTH (it, area);
20252 /* Change IT->ascent and IT->height according to the setting of
20253 IT->voffset. */
20255 static INLINE void
20256 take_vertical_position_into_account (it)
20257 struct it *it;
20259 if (it->voffset)
20261 if (it->voffset < 0)
20262 /* Increase the ascent so that we can display the text higher
20263 in the line. */
20264 it->ascent -= it->voffset;
20265 else
20266 /* Increase the descent so that we can display the text lower
20267 in the line. */
20268 it->descent += it->voffset;
20273 /* Produce glyphs/get display metrics for the image IT is loaded with.
20274 See the description of struct display_iterator in dispextern.h for
20275 an overview of struct display_iterator. */
20277 static void
20278 produce_image_glyph (it)
20279 struct it *it;
20281 struct image *img;
20282 struct face *face;
20283 int glyph_ascent, crop;
20284 struct glyph_slice slice;
20286 xassert (it->what == IT_IMAGE);
20288 face = FACE_FROM_ID (it->f, it->face_id);
20289 xassert (face);
20290 /* Make sure X resources of the face is loaded. */
20291 PREPARE_FACE_FOR_DISPLAY (it->f, face);
20293 if (it->image_id < 0)
20295 /* Fringe bitmap. */
20296 it->ascent = it->phys_ascent = 0;
20297 it->descent = it->phys_descent = 0;
20298 it->pixel_width = 0;
20299 it->nglyphs = 0;
20300 return;
20303 img = IMAGE_FROM_ID (it->f, it->image_id);
20304 xassert (img);
20305 /* Make sure X resources of the image is loaded. */
20306 prepare_image_for_display (it->f, img);
20308 slice.x = slice.y = 0;
20309 slice.width = img->width;
20310 slice.height = img->height;
20312 if (INTEGERP (it->slice.x))
20313 slice.x = XINT (it->slice.x);
20314 else if (FLOATP (it->slice.x))
20315 slice.x = XFLOAT_DATA (it->slice.x) * img->width;
20317 if (INTEGERP (it->slice.y))
20318 slice.y = XINT (it->slice.y);
20319 else if (FLOATP (it->slice.y))
20320 slice.y = XFLOAT_DATA (it->slice.y) * img->height;
20322 if (INTEGERP (it->slice.width))
20323 slice.width = XINT (it->slice.width);
20324 else if (FLOATP (it->slice.width))
20325 slice.width = XFLOAT_DATA (it->slice.width) * img->width;
20327 if (INTEGERP (it->slice.height))
20328 slice.height = XINT (it->slice.height);
20329 else if (FLOATP (it->slice.height))
20330 slice.height = XFLOAT_DATA (it->slice.height) * img->height;
20332 if (slice.x >= img->width)
20333 slice.x = img->width;
20334 if (slice.y >= img->height)
20335 slice.y = img->height;
20336 if (slice.x + slice.width >= img->width)
20337 slice.width = img->width - slice.x;
20338 if (slice.y + slice.height > img->height)
20339 slice.height = img->height - slice.y;
20341 if (slice.width == 0 || slice.height == 0)
20342 return;
20344 it->ascent = it->phys_ascent = glyph_ascent = image_ascent (img, face, &slice);
20346 it->descent = slice.height - glyph_ascent;
20347 if (slice.y == 0)
20348 it->descent += img->vmargin;
20349 if (slice.y + slice.height == img->height)
20350 it->descent += img->vmargin;
20351 it->phys_descent = it->descent;
20353 it->pixel_width = slice.width;
20354 if (slice.x == 0)
20355 it->pixel_width += img->hmargin;
20356 if (slice.x + slice.width == img->width)
20357 it->pixel_width += img->hmargin;
20359 /* It's quite possible for images to have an ascent greater than
20360 their height, so don't get confused in that case. */
20361 if (it->descent < 0)
20362 it->descent = 0;
20364 #if 0 /* this breaks image tiling */
20365 /* If this glyph is alone on the last line, adjust it.ascent to minimum row ascent. */
20366 int face_ascent = face->font ? FONT_BASE (face->font) : FRAME_BASELINE_OFFSET (it->f);
20367 if (face_ascent > it->ascent)
20368 it->ascent = it->phys_ascent = face_ascent;
20369 #endif
20371 it->nglyphs = 1;
20373 if (face->box != FACE_NO_BOX)
20375 if (face->box_line_width > 0)
20377 if (slice.y == 0)
20378 it->ascent += face->box_line_width;
20379 if (slice.y + slice.height == img->height)
20380 it->descent += face->box_line_width;
20383 if (it->start_of_box_run_p && slice.x == 0)
20384 it->pixel_width += eabs (face->box_line_width);
20385 if (it->end_of_box_run_p && slice.x + slice.width == img->width)
20386 it->pixel_width += eabs (face->box_line_width);
20389 take_vertical_position_into_account (it);
20391 /* Automatically crop wide image glyphs at right edge so we can
20392 draw the cursor on same display row. */
20393 if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0)
20394 && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
20396 it->pixel_width -= crop;
20397 slice.width -= crop;
20400 if (it->glyph_row)
20402 struct glyph *glyph;
20403 enum glyph_row_area area = it->area;
20405 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
20406 if (glyph < it->glyph_row->glyphs[area + 1])
20408 glyph->charpos = CHARPOS (it->position);
20409 glyph->object = it->object;
20410 glyph->pixel_width = it->pixel_width;
20411 glyph->ascent = glyph_ascent;
20412 glyph->descent = it->descent;
20413 glyph->voffset = it->voffset;
20414 glyph->type = IMAGE_GLYPH;
20415 glyph->multibyte_p = it->multibyte_p;
20416 glyph->left_box_line_p = it->start_of_box_run_p;
20417 glyph->right_box_line_p = it->end_of_box_run_p;
20418 glyph->overlaps_vertically_p = 0;
20419 glyph->padding_p = 0;
20420 glyph->glyph_not_available_p = 0;
20421 glyph->face_id = it->face_id;
20422 glyph->u.img_id = img->id;
20423 glyph->slice = slice;
20424 glyph->font_type = FONT_TYPE_UNKNOWN;
20425 ++it->glyph_row->used[area];
20427 else
20428 IT_EXPAND_MATRIX_WIDTH (it, area);
20433 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
20434 of the glyph, WIDTH and HEIGHT are the width and height of the
20435 stretch. ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT). */
20437 static void
20438 append_stretch_glyph (it, object, width, height, ascent)
20439 struct it *it;
20440 Lisp_Object object;
20441 int width, height;
20442 int ascent;
20444 struct glyph *glyph;
20445 enum glyph_row_area area = it->area;
20447 xassert (ascent >= 0 && ascent <= height);
20449 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
20450 if (glyph < it->glyph_row->glyphs[area + 1])
20452 glyph->charpos = CHARPOS (it->position);
20453 glyph->object = object;
20454 glyph->pixel_width = width;
20455 glyph->ascent = ascent;
20456 glyph->descent = height - ascent;
20457 glyph->voffset = it->voffset;
20458 glyph->type = STRETCH_GLYPH;
20459 glyph->multibyte_p = it->multibyte_p;
20460 glyph->left_box_line_p = it->start_of_box_run_p;
20461 glyph->right_box_line_p = it->end_of_box_run_p;
20462 glyph->overlaps_vertically_p = 0;
20463 glyph->padding_p = 0;
20464 glyph->glyph_not_available_p = 0;
20465 glyph->face_id = it->face_id;
20466 glyph->u.stretch.ascent = ascent;
20467 glyph->u.stretch.height = height;
20468 glyph->slice = null_glyph_slice;
20469 glyph->font_type = FONT_TYPE_UNKNOWN;
20470 ++it->glyph_row->used[area];
20472 else
20473 IT_EXPAND_MATRIX_WIDTH (it, area);
20477 /* Produce a stretch glyph for iterator IT. IT->object is the value
20478 of the glyph property displayed. The value must be a list
20479 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
20480 being recognized:
20482 1. `:width WIDTH' specifies that the space should be WIDTH *
20483 canonical char width wide. WIDTH may be an integer or floating
20484 point number.
20486 2. `:relative-width FACTOR' specifies that the width of the stretch
20487 should be computed from the width of the first character having the
20488 `glyph' property, and should be FACTOR times that width.
20490 3. `:align-to HPOS' specifies that the space should be wide enough
20491 to reach HPOS, a value in canonical character units.
20493 Exactly one of the above pairs must be present.
20495 4. `:height HEIGHT' specifies that the height of the stretch produced
20496 should be HEIGHT, measured in canonical character units.
20498 5. `:relative-height FACTOR' specifies that the height of the
20499 stretch should be FACTOR times the height of the characters having
20500 the glyph property.
20502 Either none or exactly one of 4 or 5 must be present.
20504 6. `:ascent ASCENT' specifies that ASCENT percent of the height
20505 of the stretch should be used for the ascent of the stretch.
20506 ASCENT must be in the range 0 <= ASCENT <= 100. */
20508 static void
20509 produce_stretch_glyph (it)
20510 struct it *it;
20512 /* (space :width WIDTH :height HEIGHT ...) */
20513 Lisp_Object prop, plist;
20514 int width = 0, height = 0, align_to = -1;
20515 int zero_width_ok_p = 0, zero_height_ok_p = 0;
20516 int ascent = 0;
20517 double tem;
20518 struct face *face = FACE_FROM_ID (it->f, it->face_id);
20519 XFontStruct *font = face->font ? face->font : FRAME_FONT (it->f);
20521 PREPARE_FACE_FOR_DISPLAY (it->f, face);
20523 /* List should start with `space'. */
20524 xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
20525 plist = XCDR (it->object);
20527 /* Compute the width of the stretch. */
20528 if ((prop = Fplist_get (plist, QCwidth), !NILP (prop))
20529 && calc_pixel_width_or_height (&tem, it, prop, font, 1, 0))
20531 /* Absolute width `:width WIDTH' specified and valid. */
20532 zero_width_ok_p = 1;
20533 width = (int)tem;
20535 else if (prop = Fplist_get (plist, QCrelative_width),
20536 NUMVAL (prop) > 0)
20538 /* Relative width `:relative-width FACTOR' specified and valid.
20539 Compute the width of the characters having the `glyph'
20540 property. */
20541 struct it it2;
20542 unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
20544 it2 = *it;
20545 if (it->multibyte_p)
20547 int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
20548 - IT_BYTEPOS (*it));
20549 it2.c = STRING_CHAR_AND_LENGTH (p, maxlen, it2.len);
20551 else
20552 it2.c = *p, it2.len = 1;
20554 it2.glyph_row = NULL;
20555 it2.what = IT_CHARACTER;
20556 x_produce_glyphs (&it2);
20557 width = NUMVAL (prop) * it2.pixel_width;
20559 else if ((prop = Fplist_get (plist, QCalign_to), !NILP (prop))
20560 && calc_pixel_width_or_height (&tem, it, prop, font, 1, &align_to))
20562 if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
20563 align_to = (align_to < 0
20565 : align_to - window_box_left_offset (it->w, TEXT_AREA));
20566 else if (align_to < 0)
20567 align_to = window_box_left_offset (it->w, TEXT_AREA);
20568 width = max (0, (int)tem + align_to - it->current_x);
20569 zero_width_ok_p = 1;
20571 else
20572 /* Nothing specified -> width defaults to canonical char width. */
20573 width = FRAME_COLUMN_WIDTH (it->f);
20575 if (width <= 0 && (width < 0 || !zero_width_ok_p))
20576 width = 1;
20578 /* Compute height. */
20579 if ((prop = Fplist_get (plist, QCheight), !NILP (prop))
20580 && calc_pixel_width_or_height (&tem, it, prop, font, 0, 0))
20582 height = (int)tem;
20583 zero_height_ok_p = 1;
20585 else if (prop = Fplist_get (plist, QCrelative_height),
20586 NUMVAL (prop) > 0)
20587 height = FONT_HEIGHT (font) * NUMVAL (prop);
20588 else
20589 height = FONT_HEIGHT (font);
20591 if (height <= 0 && (height < 0 || !zero_height_ok_p))
20592 height = 1;
20594 /* Compute percentage of height used for ascent. If
20595 `:ascent ASCENT' is present and valid, use that. Otherwise,
20596 derive the ascent from the font in use. */
20597 if (prop = Fplist_get (plist, QCascent),
20598 NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
20599 ascent = height * NUMVAL (prop) / 100.0;
20600 else if (!NILP (prop)
20601 && calc_pixel_width_or_height (&tem, it, prop, font, 0, 0))
20602 ascent = min (max (0, (int)tem), height);
20603 else
20604 ascent = (height * FONT_BASE (font)) / FONT_HEIGHT (font);
20606 if (width > 0 && !it->truncate_lines_p
20607 && it->current_x + width > it->last_visible_x)
20608 width = it->last_visible_x - it->current_x - 1;
20610 if (width > 0 && height > 0 && it->glyph_row)
20612 Lisp_Object object = it->stack[it->sp - 1].string;
20613 if (!STRINGP (object))
20614 object = it->w->buffer;
20615 append_stretch_glyph (it, object, width, height, ascent);
20618 it->pixel_width = width;
20619 it->ascent = it->phys_ascent = ascent;
20620 it->descent = it->phys_descent = height - it->ascent;
20621 it->nglyphs = width > 0 && height > 0 ? 1 : 0;
20623 take_vertical_position_into_account (it);
20626 /* Get line-height and line-spacing property at point.
20627 If line-height has format (HEIGHT TOTAL), return TOTAL
20628 in TOTAL_HEIGHT. */
20630 static Lisp_Object
20631 get_line_height_property (it, prop)
20632 struct it *it;
20633 Lisp_Object prop;
20635 Lisp_Object position;
20637 if (STRINGP (it->object))
20638 position = make_number (IT_STRING_CHARPOS (*it));
20639 else if (BUFFERP (it->object))
20640 position = make_number (IT_CHARPOS (*it));
20641 else
20642 return Qnil;
20644 return Fget_char_property (position, prop, it->object);
20647 /* Calculate line-height and line-spacing properties.
20648 An integer value specifies explicit pixel value.
20649 A float value specifies relative value to current face height.
20650 A cons (float . face-name) specifies relative value to
20651 height of specified face font.
20653 Returns height in pixels, or nil. */
20656 static Lisp_Object
20657 calc_line_height_property (it, val, font, boff, override)
20658 struct it *it;
20659 Lisp_Object val;
20660 XFontStruct *font;
20661 int boff, override;
20663 Lisp_Object face_name = Qnil;
20664 int ascent, descent, height;
20666 if (NILP (val) || INTEGERP (val) || (override && EQ (val, Qt)))
20667 return val;
20669 if (CONSP (val))
20671 face_name = XCAR (val);
20672 val = XCDR (val);
20673 if (!NUMBERP (val))
20674 val = make_number (1);
20675 if (NILP (face_name))
20677 height = it->ascent + it->descent;
20678 goto scale;
20682 if (NILP (face_name))
20684 font = FRAME_FONT (it->f);
20685 boff = FRAME_BASELINE_OFFSET (it->f);
20687 else if (EQ (face_name, Qt))
20689 override = 0;
20691 else
20693 int face_id;
20694 struct face *face;
20695 struct font_info *font_info;
20697 face_id = lookup_named_face (it->f, face_name, 0);
20698 if (face_id < 0)
20699 return make_number (-1);
20701 face = FACE_FROM_ID (it->f, face_id);
20702 font = face->font;
20703 if (font == NULL)
20704 return make_number (-1);
20706 font_info = FONT_INFO_FROM_FACE (it->f, face);
20707 boff = font_info->baseline_offset;
20708 if (font_info->vertical_centering)
20709 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
20712 ascent = FONT_BASE (font) + boff;
20713 descent = FONT_DESCENT (font) - boff;
20715 if (override)
20717 it->override_ascent = ascent;
20718 it->override_descent = descent;
20719 it->override_boff = boff;
20722 height = ascent + descent;
20724 scale:
20725 if (FLOATP (val))
20726 height = (int)(XFLOAT_DATA (val) * height);
20727 else if (INTEGERP (val))
20728 height *= XINT (val);
20730 return make_number (height);
20734 /* RIF:
20735 Produce glyphs/get display metrics for the display element IT is
20736 loaded with. See the description of struct it in dispextern.h
20737 for an overview of struct it. */
20739 void
20740 x_produce_glyphs (it)
20741 struct it *it;
20743 int extra_line_spacing = it->extra_line_spacing;
20745 it->glyph_not_available_p = 0;
20747 if (it->what == IT_CHARACTER)
20749 XChar2b char2b;
20750 XFontStruct *font;
20751 struct face *face = FACE_FROM_ID (it->f, it->face_id);
20752 XCharStruct *pcm;
20753 int font_not_found_p;
20754 struct font_info *font_info;
20755 int boff; /* baseline offset */
20756 /* We may change it->multibyte_p upon unibyte<->multibyte
20757 conversion. So, save the current value now and restore it
20758 later.
20760 Note: It seems that we don't have to record multibyte_p in
20761 struct glyph because the character code itself tells if or
20762 not the character is multibyte. Thus, in the future, we must
20763 consider eliminating the field `multibyte_p' in the struct
20764 glyph. */
20765 int saved_multibyte_p = it->multibyte_p;
20767 /* Maybe translate single-byte characters to multibyte, or the
20768 other way. */
20769 it->char_to_display = it->c;
20770 if (!ASCII_BYTE_P (it->c)
20771 && ! it->multibyte_p)
20773 if (SINGLE_BYTE_CHAR_P (it->c)
20774 && unibyte_display_via_language_environment)
20775 it->char_to_display = unibyte_char_to_multibyte (it->c);
20776 if (! SINGLE_BYTE_CHAR_P (it->char_to_display))
20778 it->multibyte_p = 1;
20779 it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display,
20780 -1, Qnil);
20781 face = FACE_FROM_ID (it->f, it->face_id);
20785 /* Get font to use. Encode IT->char_to_display. */
20786 get_char_face_and_encoding (it->f, it->char_to_display, it->face_id,
20787 &char2b, it->multibyte_p, 0);
20788 font = face->font;
20790 /* When no suitable font found, use the default font. */
20791 font_not_found_p = font == NULL;
20792 if (font_not_found_p)
20794 font = FRAME_FONT (it->f);
20795 boff = FRAME_BASELINE_OFFSET (it->f);
20796 font_info = NULL;
20798 else
20800 font_info = FONT_INFO_FROM_FACE (it->f, face);
20801 boff = font_info->baseline_offset;
20802 if (font_info->vertical_centering)
20803 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
20806 if (it->char_to_display >= ' '
20807 && (!it->multibyte_p || it->char_to_display < 128))
20809 /* Either unibyte or ASCII. */
20810 int stretched_p;
20812 it->nglyphs = 1;
20814 pcm = get_per_char_metric (it->f, font, font_info, &char2b,
20815 FONT_TYPE_FOR_UNIBYTE (font, it->char_to_display));
20817 if (it->override_ascent >= 0)
20819 it->ascent = it->override_ascent;
20820 it->descent = it->override_descent;
20821 boff = it->override_boff;
20823 else
20825 it->ascent = FONT_BASE (font) + boff;
20826 it->descent = FONT_DESCENT (font) - boff;
20829 if (pcm)
20831 it->phys_ascent = pcm->ascent + boff;
20832 it->phys_descent = pcm->descent - boff;
20833 it->pixel_width = pcm->width;
20835 else
20837 it->glyph_not_available_p = 1;
20838 it->phys_ascent = it->ascent;
20839 it->phys_descent = it->descent;
20840 it->pixel_width = FONT_WIDTH (font);
20843 if (it->constrain_row_ascent_descent_p)
20845 if (it->descent > it->max_descent)
20847 it->ascent += it->descent - it->max_descent;
20848 it->descent = it->max_descent;
20850 if (it->ascent > it->max_ascent)
20852 it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
20853 it->ascent = it->max_ascent;
20855 it->phys_ascent = min (it->phys_ascent, it->ascent);
20856 it->phys_descent = min (it->phys_descent, it->descent);
20857 extra_line_spacing = 0;
20860 /* If this is a space inside a region of text with
20861 `space-width' property, change its width. */
20862 stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
20863 if (stretched_p)
20864 it->pixel_width *= XFLOATINT (it->space_width);
20866 /* If face has a box, add the box thickness to the character
20867 height. If character has a box line to the left and/or
20868 right, add the box line width to the character's width. */
20869 if (face->box != FACE_NO_BOX)
20871 int thick = face->box_line_width;
20873 if (thick > 0)
20875 it->ascent += thick;
20876 it->descent += thick;
20878 else
20879 thick = -thick;
20881 if (it->start_of_box_run_p)
20882 it->pixel_width += thick;
20883 if (it->end_of_box_run_p)
20884 it->pixel_width += thick;
20887 /* If face has an overline, add the height of the overline
20888 (1 pixel) and a 1 pixel margin to the character height. */
20889 if (face->overline_p)
20890 it->ascent += overline_margin;
20892 if (it->constrain_row_ascent_descent_p)
20894 if (it->ascent > it->max_ascent)
20895 it->ascent = it->max_ascent;
20896 if (it->descent > it->max_descent)
20897 it->descent = it->max_descent;
20900 take_vertical_position_into_account (it);
20902 /* If we have to actually produce glyphs, do it. */
20903 if (it->glyph_row)
20905 if (stretched_p)
20907 /* Translate a space with a `space-width' property
20908 into a stretch glyph. */
20909 int ascent = (((it->ascent + it->descent) * FONT_BASE (font))
20910 / FONT_HEIGHT (font));
20911 append_stretch_glyph (it, it->object, it->pixel_width,
20912 it->ascent + it->descent, ascent);
20914 else
20915 append_glyph (it);
20917 /* If characters with lbearing or rbearing are displayed
20918 in this line, record that fact in a flag of the
20919 glyph row. This is used to optimize X output code. */
20920 if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
20921 it->glyph_row->contains_overlapping_glyphs_p = 1;
20923 if (! stretched_p && it->pixel_width == 0)
20924 /* We assure that all visible glyphs have at least 1-pixel
20925 width. */
20926 it->pixel_width = 1;
20928 else if (it->char_to_display == '\n')
20930 /* A newline has no width but we need the height of the line.
20931 But if previous part of the line set a height, don't
20932 increase that height */
20934 Lisp_Object height;
20935 Lisp_Object total_height = Qnil;
20937 it->override_ascent = -1;
20938 it->pixel_width = 0;
20939 it->nglyphs = 0;
20941 height = get_line_height_property(it, Qline_height);
20942 /* Split (line-height total-height) list */
20943 if (CONSP (height)
20944 && CONSP (XCDR (height))
20945 && NILP (XCDR (XCDR (height))))
20947 total_height = XCAR (XCDR (height));
20948 height = XCAR (height);
20950 height = calc_line_height_property(it, height, font, boff, 1);
20952 if (it->override_ascent >= 0)
20954 it->ascent = it->override_ascent;
20955 it->descent = it->override_descent;
20956 boff = it->override_boff;
20958 else
20960 it->ascent = FONT_BASE (font) + boff;
20961 it->descent = FONT_DESCENT (font) - boff;
20964 if (EQ (height, Qt))
20966 if (it->descent > it->max_descent)
20968 it->ascent += it->descent - it->max_descent;
20969 it->descent = it->max_descent;
20971 if (it->ascent > it->max_ascent)
20973 it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
20974 it->ascent = it->max_ascent;
20976 it->phys_ascent = min (it->phys_ascent, it->ascent);
20977 it->phys_descent = min (it->phys_descent, it->descent);
20978 it->constrain_row_ascent_descent_p = 1;
20979 extra_line_spacing = 0;
20981 else
20983 Lisp_Object spacing;
20985 it->phys_ascent = it->ascent;
20986 it->phys_descent = it->descent;
20988 if ((it->max_ascent > 0 || it->max_descent > 0)
20989 && face->box != FACE_NO_BOX
20990 && face->box_line_width > 0)
20992 it->ascent += face->box_line_width;
20993 it->descent += face->box_line_width;
20995 if (!NILP (height)
20996 && XINT (height) > it->ascent + it->descent)
20997 it->ascent = XINT (height) - it->descent;
20999 if (!NILP (total_height))
21000 spacing = calc_line_height_property(it, total_height, font, boff, 0);
21001 else
21003 spacing = get_line_height_property(it, Qline_spacing);
21004 spacing = calc_line_height_property(it, spacing, font, boff, 0);
21006 if (INTEGERP (spacing))
21008 extra_line_spacing = XINT (spacing);
21009 if (!NILP (total_height))
21010 extra_line_spacing -= (it->phys_ascent + it->phys_descent);
21014 else if (it->char_to_display == '\t')
21016 int tab_width = it->tab_width * FRAME_SPACE_WIDTH (it->f);
21017 int x = it->current_x + it->continuation_lines_width;
21018 int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
21020 /* If the distance from the current position to the next tab
21021 stop is less than a space character width, use the
21022 tab stop after that. */
21023 if (next_tab_x - x < FRAME_SPACE_WIDTH (it->f))
21024 next_tab_x += tab_width;
21026 it->pixel_width = next_tab_x - x;
21027 it->nglyphs = 1;
21028 it->ascent = it->phys_ascent = FONT_BASE (font) + boff;
21029 it->descent = it->phys_descent = FONT_DESCENT (font) - boff;
21031 if (it->glyph_row)
21033 append_stretch_glyph (it, it->object, it->pixel_width,
21034 it->ascent + it->descent, it->ascent);
21037 else
21039 /* A multi-byte character. Assume that the display width of the
21040 character is the width of the character multiplied by the
21041 width of the font. */
21043 /* If we found a font, this font should give us the right
21044 metrics. If we didn't find a font, use the frame's
21045 default font and calculate the width of the character by
21046 multiplying the width of font by the width of the
21047 character. */
21049 pcm = get_per_char_metric (it->f, font, font_info, &char2b,
21050 FONT_TYPE_FOR_MULTIBYTE (font, it->c));
21052 if (font_not_found_p || !pcm)
21054 int char_width = CHAR_WIDTH (it->char_to_display);
21056 if (char_width == 0)
21057 /* This is a non spacing character. But, as we are
21058 going to display an empty box, the box must occupy
21059 at least one column. */
21060 char_width = 1;
21061 it->glyph_not_available_p = 1;
21062 it->pixel_width = FRAME_COLUMN_WIDTH (it->f) * char_width;
21063 it->phys_ascent = FONT_BASE (font) + boff;
21064 it->phys_descent = FONT_DESCENT (font) - boff;
21066 else
21068 it->pixel_width = pcm->width;
21069 it->phys_ascent = pcm->ascent + boff;
21070 it->phys_descent = pcm->descent - boff;
21071 if (it->glyph_row
21072 && (pcm->lbearing < 0
21073 || pcm->rbearing > pcm->width))
21074 it->glyph_row->contains_overlapping_glyphs_p = 1;
21076 it->nglyphs = 1;
21077 it->ascent = FONT_BASE (font) + boff;
21078 it->descent = FONT_DESCENT (font) - boff;
21079 if (face->box != FACE_NO_BOX)
21081 int thick = face->box_line_width;
21083 if (thick > 0)
21085 it->ascent += thick;
21086 it->descent += thick;
21088 else
21089 thick = - thick;
21091 if (it->start_of_box_run_p)
21092 it->pixel_width += thick;
21093 if (it->end_of_box_run_p)
21094 it->pixel_width += thick;
21097 /* If face has an overline, add the height of the overline
21098 (1 pixel) and a 1 pixel margin to the character height. */
21099 if (face->overline_p)
21100 it->ascent += overline_margin;
21102 take_vertical_position_into_account (it);
21104 if (it->ascent < 0)
21105 it->ascent = 0;
21106 if (it->descent < 0)
21107 it->descent = 0;
21109 if (it->glyph_row)
21110 append_glyph (it);
21111 if (it->pixel_width == 0)
21112 /* We assure that all visible glyphs have at least 1-pixel
21113 width. */
21114 it->pixel_width = 1;
21116 it->multibyte_p = saved_multibyte_p;
21118 else if (it->what == IT_COMPOSITION)
21120 /* Note: A composition is represented as one glyph in the
21121 glyph matrix. There are no padding glyphs.
21123 Important is that pixel_width, ascent, and descent are the
21124 values of what is drawn by draw_glyphs (i.e. the values of
21125 the overall glyphs composed). */
21126 struct face *face = FACE_FROM_ID (it->f, it->face_id);
21127 int boff; /* baseline offset */
21128 struct composition *cmp = composition_table[it->cmp_id];
21129 int glyph_len = cmp->glyph_len;
21130 XFontStruct *font = face->font;
21132 it->nglyphs = 1;
21134 #ifdef USE_FONT_BACKEND
21135 if (cmp->method == COMPOSITION_WITH_GLYPH_STRING)
21137 PREPARE_FACE_FOR_DISPLAY (it->f, face);
21138 font_prepare_composition (cmp, it->f);
21140 else
21141 #endif /* USE_FONT_BACKEND */
21142 /* If we have not yet calculated pixel size data of glyphs of
21143 the composition for the current face font, calculate them
21144 now. Theoretically, we have to check all fonts for the
21145 glyphs, but that requires much time and memory space. So,
21146 here we check only the font of the first glyph. This leads
21147 to incorrect display, but it's very rare, and C-l (recenter)
21148 can correct the display anyway. */
21149 if (! cmp->font || cmp->font != font)
21151 /* Ascent and descent of the font of the first character
21152 of this composition (adjusted by baseline offset).
21153 Ascent and descent of overall glyphs should not be less
21154 than them respectively. */
21155 int font_ascent, font_descent, font_height;
21156 /* Bounding box of the overall glyphs. */
21157 int leftmost, rightmost, lowest, highest;
21158 int lbearing, rbearing;
21159 int i, width, ascent, descent;
21160 int left_padded = 0, right_padded = 0;
21161 int face_id;
21162 int c;
21163 XChar2b char2b;
21164 XCharStruct *pcm;
21165 int font_not_found_p;
21166 struct font_info *font_info;
21167 int pos;
21169 for (glyph_len = cmp->glyph_len; glyph_len > 0; glyph_len--)
21170 if ((c = COMPOSITION_GLYPH (cmp, glyph_len - 1)) != '\t')
21171 break;
21172 if (glyph_len < cmp->glyph_len)
21173 right_padded = 1;
21174 for (i = 0; i < glyph_len; i++)
21176 if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
21177 break;
21178 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
21180 if (i > 0)
21181 left_padded = 1;
21183 pos = (STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
21184 : IT_CHARPOS (*it));
21185 /* When no suitable font found, use the default font. */
21186 font_not_found_p = font == NULL;
21187 if (font_not_found_p)
21189 face = face->ascii_face;
21190 font = face->font;
21192 font_info = FONT_INFO_FROM_FACE (it->f, face);
21193 boff = font_info->baseline_offset;
21194 if (font_info->vertical_centering)
21195 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
21196 font_ascent = FONT_BASE (font) + boff;
21197 font_descent = FONT_DESCENT (font) - boff;
21198 font_height = FONT_HEIGHT (font);
21200 cmp->font = (void *) font;
21202 pcm = NULL;
21203 if (! font_not_found_p)
21205 get_char_face_and_encoding (it->f, c, it->face_id,
21206 &char2b, it->multibyte_p, 0);
21207 pcm = get_per_char_metric (it->f, font, font_info, &char2b,
21208 FONT_TYPE_FOR_MULTIBYTE (font, c));
21211 /* Initialize the bounding box. */
21212 if (pcm)
21214 width = pcm->width;
21215 ascent = pcm->ascent;
21216 descent = pcm->descent;
21217 lbearing = pcm->lbearing;
21218 rbearing = pcm->rbearing;
21220 else
21222 width = FONT_WIDTH (font);
21223 ascent = FONT_BASE (font);
21224 descent = FONT_DESCENT (font);
21225 lbearing = 0;
21226 rbearing = width;
21229 rightmost = width;
21230 leftmost = 0;
21231 lowest = - descent + boff;
21232 highest = ascent + boff;
21234 if (! font_not_found_p
21235 && font_info->default_ascent
21236 && CHAR_TABLE_P (Vuse_default_ascent)
21237 && !NILP (Faref (Vuse_default_ascent,
21238 make_number (it->char_to_display))))
21239 highest = font_info->default_ascent + boff;
21241 /* Draw the first glyph at the normal position. It may be
21242 shifted to right later if some other glyphs are drawn
21243 at the left. */
21244 cmp->offsets[i * 2] = 0;
21245 cmp->offsets[i * 2 + 1] = boff;
21246 cmp->lbearing = lbearing;
21247 cmp->rbearing = rbearing;
21249 /* Set cmp->offsets for the remaining glyphs. */
21250 for (i++; i < glyph_len; i++)
21252 int left, right, btm, top;
21253 int ch = COMPOSITION_GLYPH (cmp, i);
21254 int face_id;
21255 struct face *this_face;
21256 int this_boff;
21258 if (ch == '\t')
21259 ch = ' ';
21260 face_id = FACE_FOR_CHAR (it->f, face, ch, pos, it->string);
21261 this_face = FACE_FROM_ID (it->f, face_id);
21262 font = this_face->font;
21264 if (font == NULL)
21265 pcm = NULL;
21266 else
21268 font_info = FONT_INFO_FROM_FACE (it->f, this_face);
21269 this_boff = font_info->baseline_offset;
21270 if (font_info->vertical_centering)
21271 this_boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
21272 get_char_face_and_encoding (it->f, ch, face_id,
21273 &char2b, it->multibyte_p, 0);
21274 pcm = get_per_char_metric (it->f, font, font_info, &char2b,
21275 FONT_TYPE_FOR_MULTIBYTE (font,
21276 ch));
21278 if (! pcm)
21279 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
21280 else
21282 width = pcm->width;
21283 ascent = pcm->ascent;
21284 descent = pcm->descent;
21285 lbearing = pcm->lbearing;
21286 rbearing = pcm->rbearing;
21287 if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
21289 /* Relative composition with or without
21290 alternate chars. */
21291 left = (leftmost + rightmost - width) / 2;
21292 btm = - descent + boff;
21293 if (font_info->relative_compose
21294 && (! CHAR_TABLE_P (Vignore_relative_composition)
21295 || NILP (Faref (Vignore_relative_composition,
21296 make_number (ch)))))
21299 if (- descent >= font_info->relative_compose)
21300 /* One extra pixel between two glyphs. */
21301 btm = highest + 1;
21302 else if (ascent <= 0)
21303 /* One extra pixel between two glyphs. */
21304 btm = lowest - 1 - ascent - descent;
21307 else
21309 /* A composition rule is specified by an integer
21310 value that encodes global and new reference
21311 points (GREF and NREF). GREF and NREF are
21312 specified by numbers as below:
21314 0---1---2 -- ascent
21318 9--10--11 -- center
21320 ---3---4---5--- baseline
21322 6---7---8 -- descent
21324 int rule = COMPOSITION_RULE (cmp, i);
21325 int gref, nref, grefx, grefy, nrefx, nrefy, xoff, yoff;
21327 COMPOSITION_DECODE_RULE (rule, gref, nref, xoff, yoff);
21328 grefx = gref % 3, nrefx = nref % 3;
21329 grefy = gref / 3, nrefy = nref / 3;
21330 if (xoff)
21331 xoff = font_height * (xoff - 128) / 256;
21332 if (yoff)
21333 yoff = font_height * (yoff - 128) / 256;
21335 left = (leftmost
21336 + grefx * (rightmost - leftmost) / 2
21337 - nrefx * width / 2
21338 + xoff);
21340 btm = ((grefy == 0 ? highest
21341 : grefy == 1 ? 0
21342 : grefy == 2 ? lowest
21343 : (highest + lowest) / 2)
21344 - (nrefy == 0 ? ascent + descent
21345 : nrefy == 1 ? descent - boff
21346 : nrefy == 2 ? 0
21347 : (ascent + descent) / 2)
21348 + yoff);
21351 cmp->offsets[i * 2] = left;
21352 cmp->offsets[i * 2 + 1] = btm + descent;
21354 /* Update the bounding box of the overall glyphs. */
21355 if (width > 0)
21357 right = left + width;
21358 if (left < leftmost)
21359 leftmost = left;
21360 if (right > rightmost)
21361 rightmost = right;
21363 top = btm + descent + ascent;
21364 if (top > highest)
21365 highest = top;
21366 if (btm < lowest)
21367 lowest = btm;
21369 if (cmp->lbearing > left + lbearing)
21370 cmp->lbearing = left + lbearing;
21371 if (cmp->rbearing < left + rbearing)
21372 cmp->rbearing = left + rbearing;
21376 /* If there are glyphs whose x-offsets are negative,
21377 shift all glyphs to the right and make all x-offsets
21378 non-negative. */
21379 if (leftmost < 0)
21381 for (i = 0; i < cmp->glyph_len; i++)
21382 cmp->offsets[i * 2] -= leftmost;
21383 rightmost -= leftmost;
21384 cmp->lbearing -= leftmost;
21385 cmp->rbearing -= leftmost;
21388 if (left_padded && cmp->lbearing < 0)
21390 for (i = 0; i < cmp->glyph_len; i++)
21391 cmp->offsets[i * 2] -= cmp->lbearing;
21392 rightmost -= cmp->lbearing;
21393 cmp->rbearing -= cmp->lbearing;
21394 cmp->lbearing = 0;
21396 if (right_padded && rightmost < cmp->rbearing)
21398 rightmost = cmp->rbearing;
21401 cmp->pixel_width = rightmost;
21402 cmp->ascent = highest;
21403 cmp->descent = - lowest;
21404 if (cmp->ascent < font_ascent)
21405 cmp->ascent = font_ascent;
21406 if (cmp->descent < font_descent)
21407 cmp->descent = font_descent;
21410 if (it->glyph_row
21411 && (cmp->lbearing < 0
21412 || cmp->rbearing > cmp->pixel_width))
21413 it->glyph_row->contains_overlapping_glyphs_p = 1;
21415 it->pixel_width = cmp->pixel_width;
21416 it->ascent = it->phys_ascent = cmp->ascent;
21417 it->descent = it->phys_descent = cmp->descent;
21418 if (face->box != FACE_NO_BOX)
21420 int thick = face->box_line_width;
21422 if (thick > 0)
21424 it->ascent += thick;
21425 it->descent += thick;
21427 else
21428 thick = - thick;
21430 if (it->start_of_box_run_p)
21431 it->pixel_width += thick;
21432 if (it->end_of_box_run_p)
21433 it->pixel_width += thick;
21436 /* If face has an overline, add the height of the overline
21437 (1 pixel) and a 1 pixel margin to the character height. */
21438 if (face->overline_p)
21439 it->ascent += overline_margin;
21441 take_vertical_position_into_account (it);
21442 if (it->ascent < 0)
21443 it->ascent = 0;
21444 if (it->descent < 0)
21445 it->descent = 0;
21447 if (it->glyph_row)
21448 append_composite_glyph (it);
21450 else if (it->what == IT_IMAGE)
21451 produce_image_glyph (it);
21452 else if (it->what == IT_STRETCH)
21453 produce_stretch_glyph (it);
21455 /* Accumulate dimensions. Note: can't assume that it->descent > 0
21456 because this isn't true for images with `:ascent 100'. */
21457 xassert (it->ascent >= 0 && it->descent >= 0);
21458 if (it->area == TEXT_AREA)
21459 it->current_x += it->pixel_width;
21461 if (extra_line_spacing > 0)
21463 it->descent += extra_line_spacing;
21464 if (extra_line_spacing > it->max_extra_line_spacing)
21465 it->max_extra_line_spacing = extra_line_spacing;
21468 it->max_ascent = max (it->max_ascent, it->ascent);
21469 it->max_descent = max (it->max_descent, it->descent);
21470 it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
21471 it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
21474 /* EXPORT for RIF:
21475 Output LEN glyphs starting at START at the nominal cursor position.
21476 Advance the nominal cursor over the text. The global variable
21477 updated_window contains the window being updated, updated_row is
21478 the glyph row being updated, and updated_area is the area of that
21479 row being updated. */
21481 void
21482 x_write_glyphs (start, len)
21483 struct glyph *start;
21484 int len;
21486 int x, hpos;
21488 xassert (updated_window && updated_row);
21489 BLOCK_INPUT;
21491 /* Write glyphs. */
21493 hpos = start - updated_row->glyphs[updated_area];
21494 x = draw_glyphs (updated_window, output_cursor.x,
21495 updated_row, updated_area,
21496 hpos, hpos + len,
21497 DRAW_NORMAL_TEXT, 0);
21499 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
21500 if (updated_area == TEXT_AREA
21501 && updated_window->phys_cursor_on_p
21502 && updated_window->phys_cursor.vpos == output_cursor.vpos
21503 && updated_window->phys_cursor.hpos >= hpos
21504 && updated_window->phys_cursor.hpos < hpos + len)
21505 updated_window->phys_cursor_on_p = 0;
21507 UNBLOCK_INPUT;
21509 /* Advance the output cursor. */
21510 output_cursor.hpos += len;
21511 output_cursor.x = x;
21515 /* EXPORT for RIF:
21516 Insert LEN glyphs from START at the nominal cursor position. */
21518 void
21519 x_insert_glyphs (start, len)
21520 struct glyph *start;
21521 int len;
21523 struct frame *f;
21524 struct window *w;
21525 int line_height, shift_by_width, shifted_region_width;
21526 struct glyph_row *row;
21527 struct glyph *glyph;
21528 int frame_x, frame_y;
21529 EMACS_INT hpos;
21531 xassert (updated_window && updated_row);
21532 BLOCK_INPUT;
21533 w = updated_window;
21534 f = XFRAME (WINDOW_FRAME (w));
21536 /* Get the height of the line we are in. */
21537 row = updated_row;
21538 line_height = row->height;
21540 /* Get the width of the glyphs to insert. */
21541 shift_by_width = 0;
21542 for (glyph = start; glyph < start + len; ++glyph)
21543 shift_by_width += glyph->pixel_width;
21545 /* Get the width of the region to shift right. */
21546 shifted_region_width = (window_box_width (w, updated_area)
21547 - output_cursor.x
21548 - shift_by_width);
21550 /* Shift right. */
21551 frame_x = window_box_left (w, updated_area) + output_cursor.x;
21552 frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
21554 FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
21555 line_height, shift_by_width);
21557 /* Write the glyphs. */
21558 hpos = start - row->glyphs[updated_area];
21559 draw_glyphs (w, output_cursor.x, row, updated_area,
21560 hpos, hpos + len,
21561 DRAW_NORMAL_TEXT, 0);
21563 /* Advance the output cursor. */
21564 output_cursor.hpos += len;
21565 output_cursor.x += shift_by_width;
21566 UNBLOCK_INPUT;
21570 /* EXPORT for RIF:
21571 Erase the current text line from the nominal cursor position
21572 (inclusive) to pixel column TO_X (exclusive). The idea is that
21573 everything from TO_X onward is already erased.
21575 TO_X is a pixel position relative to updated_area of
21576 updated_window. TO_X == -1 means clear to the end of this area. */
21578 void
21579 x_clear_end_of_line (to_x)
21580 int to_x;
21582 struct frame *f;
21583 struct window *w = updated_window;
21584 int max_x, min_y, max_y;
21585 int from_x, from_y, to_y;
21587 xassert (updated_window && updated_row);
21588 f = XFRAME (w->frame);
21590 if (updated_row->full_width_p)
21591 max_x = WINDOW_TOTAL_WIDTH (w);
21592 else
21593 max_x = window_box_width (w, updated_area);
21594 max_y = window_text_bottom_y (w);
21596 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
21597 of window. For TO_X > 0, truncate to end of drawing area. */
21598 if (to_x == 0)
21599 return;
21600 else if (to_x < 0)
21601 to_x = max_x;
21602 else
21603 to_x = min (to_x, max_x);
21605 to_y = min (max_y, output_cursor.y + updated_row->height);
21607 /* Notice if the cursor will be cleared by this operation. */
21608 if (!updated_row->full_width_p)
21609 notice_overwritten_cursor (w, updated_area,
21610 output_cursor.x, -1,
21611 updated_row->y,
21612 MATRIX_ROW_BOTTOM_Y (updated_row));
21614 from_x = output_cursor.x;
21616 /* Translate to frame coordinates. */
21617 if (updated_row->full_width_p)
21619 from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
21620 to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
21622 else
21624 int area_left = window_box_left (w, updated_area);
21625 from_x += area_left;
21626 to_x += area_left;
21629 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
21630 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
21631 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
21633 /* Prevent inadvertently clearing to end of the X window. */
21634 if (to_x > from_x && to_y > from_y)
21636 BLOCK_INPUT;
21637 FRAME_RIF (f)->clear_frame_area (f, from_x, from_y,
21638 to_x - from_x, to_y - from_y);
21639 UNBLOCK_INPUT;
21643 #endif /* HAVE_WINDOW_SYSTEM */
21647 /***********************************************************************
21648 Cursor types
21649 ***********************************************************************/
21651 /* Value is the internal representation of the specified cursor type
21652 ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
21653 of the bar cursor. */
21655 static enum text_cursor_kinds
21656 get_specified_cursor_type (arg, width)
21657 Lisp_Object arg;
21658 int *width;
21660 enum text_cursor_kinds type;
21662 if (NILP (arg))
21663 return NO_CURSOR;
21665 if (EQ (arg, Qbox))
21666 return FILLED_BOX_CURSOR;
21668 if (EQ (arg, Qhollow))
21669 return HOLLOW_BOX_CURSOR;
21671 if (EQ (arg, Qbar))
21673 *width = 2;
21674 return BAR_CURSOR;
21677 if (CONSP (arg)
21678 && EQ (XCAR (arg), Qbar)
21679 && INTEGERP (XCDR (arg))
21680 && XINT (XCDR (arg)) >= 0)
21682 *width = XINT (XCDR (arg));
21683 return BAR_CURSOR;
21686 if (EQ (arg, Qhbar))
21688 *width = 2;
21689 return HBAR_CURSOR;
21692 if (CONSP (arg)
21693 && EQ (XCAR (arg), Qhbar)
21694 && INTEGERP (XCDR (arg))
21695 && XINT (XCDR (arg)) >= 0)
21697 *width = XINT (XCDR (arg));
21698 return HBAR_CURSOR;
21701 /* Treat anything unknown as "hollow box cursor".
21702 It was bad to signal an error; people have trouble fixing
21703 .Xdefaults with Emacs, when it has something bad in it. */
21704 type = HOLLOW_BOX_CURSOR;
21706 return type;
21709 /* Set the default cursor types for specified frame. */
21710 void
21711 set_frame_cursor_types (f, arg)
21712 struct frame *f;
21713 Lisp_Object arg;
21715 int width;
21716 Lisp_Object tem;
21718 FRAME_DESIRED_CURSOR (f) = get_specified_cursor_type (arg, &width);
21719 FRAME_CURSOR_WIDTH (f) = width;
21721 /* By default, set up the blink-off state depending on the on-state. */
21723 tem = Fassoc (arg, Vblink_cursor_alist);
21724 if (!NILP (tem))
21726 FRAME_BLINK_OFF_CURSOR (f)
21727 = get_specified_cursor_type (XCDR (tem), &width);
21728 FRAME_BLINK_OFF_CURSOR_WIDTH (f) = width;
21730 else
21731 FRAME_BLINK_OFF_CURSOR (f) = DEFAULT_CURSOR;
21735 /* Return the cursor we want to be displayed in window W. Return
21736 width of bar/hbar cursor through WIDTH arg. Return with
21737 ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
21738 (i.e. if the `system caret' should track this cursor).
21740 In a mini-buffer window, we want the cursor only to appear if we
21741 are reading input from this window. For the selected window, we
21742 want the cursor type given by the frame parameter or buffer local
21743 setting of cursor-type. If explicitly marked off, draw no cursor.
21744 In all other cases, we want a hollow box cursor. */
21746 static enum text_cursor_kinds
21747 get_window_cursor_type (w, glyph, width, active_cursor)
21748 struct window *w;
21749 struct glyph *glyph;
21750 int *width;
21751 int *active_cursor;
21753 struct frame *f = XFRAME (w->frame);
21754 struct buffer *b = XBUFFER (w->buffer);
21755 int cursor_type = DEFAULT_CURSOR;
21756 Lisp_Object alt_cursor;
21757 int non_selected = 0;
21759 *active_cursor = 1;
21761 /* Echo area */
21762 if (cursor_in_echo_area
21763 && FRAME_HAS_MINIBUF_P (f)
21764 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
21766 if (w == XWINDOW (echo_area_window))
21768 if (EQ (b->cursor_type, Qt) || NILP (b->cursor_type))
21770 *width = FRAME_CURSOR_WIDTH (f);
21771 return FRAME_DESIRED_CURSOR (f);
21773 else
21774 return get_specified_cursor_type (b->cursor_type, width);
21777 *active_cursor = 0;
21778 non_selected = 1;
21781 /* Detect a nonselected window or nonselected frame. */
21782 else if (w != XWINDOW (f->selected_window)
21783 #ifdef HAVE_WINDOW_SYSTEM
21784 || f != FRAME_X_DISPLAY_INFO (f)->x_highlight_frame
21785 #endif
21788 *active_cursor = 0;
21790 if (MINI_WINDOW_P (w) && minibuf_level == 0)
21791 return NO_CURSOR;
21793 non_selected = 1;
21796 /* Never display a cursor in a window in which cursor-type is nil. */
21797 if (NILP (b->cursor_type))
21798 return NO_CURSOR;
21800 /* Get the normal cursor type for this window. */
21801 if (EQ (b->cursor_type, Qt))
21803 cursor_type = FRAME_DESIRED_CURSOR (f);
21804 *width = FRAME_CURSOR_WIDTH (f);
21806 else
21807 cursor_type = get_specified_cursor_type (b->cursor_type, width);
21809 /* Use cursor-in-non-selected-windows instead
21810 for non-selected window or frame. */
21811 if (non_selected)
21813 alt_cursor = b->cursor_in_non_selected_windows;
21814 if (!EQ (Qt, alt_cursor))
21815 return get_specified_cursor_type (alt_cursor, width);
21816 /* t means modify the normal cursor type. */
21817 if (cursor_type == FILLED_BOX_CURSOR)
21818 cursor_type = HOLLOW_BOX_CURSOR;
21819 else if (cursor_type == BAR_CURSOR && *width > 1)
21820 --*width;
21821 return cursor_type;
21824 /* Use normal cursor if not blinked off. */
21825 if (!w->cursor_off_p)
21827 #ifdef HAVE_WINDOW_SYSTEM
21828 if (glyph != NULL && glyph->type == IMAGE_GLYPH)
21830 if (cursor_type == FILLED_BOX_CURSOR)
21832 /* Using a block cursor on large images can be very annoying.
21833 So use a hollow cursor for "large" images.
21834 If image is not transparent (no mask), also use hollow cursor. */
21835 struct image *img = IMAGE_FROM_ID (f, glyph->u.img_id);
21836 if (img != NULL && IMAGEP (img->spec))
21838 /* Arbitrarily, interpret "Large" as >32x32 and >NxN
21839 where N = size of default frame font size.
21840 This should cover most of the "tiny" icons people may use. */
21841 if (!img->mask
21842 || img->width > max (32, WINDOW_FRAME_COLUMN_WIDTH (w))
21843 || img->height > max (32, WINDOW_FRAME_LINE_HEIGHT (w)))
21844 cursor_type = HOLLOW_BOX_CURSOR;
21847 else if (cursor_type != NO_CURSOR)
21849 /* Display current only supports BOX and HOLLOW cursors for images.
21850 So for now, unconditionally use a HOLLOW cursor when cursor is
21851 not a solid box cursor. */
21852 cursor_type = HOLLOW_BOX_CURSOR;
21855 #endif
21856 return cursor_type;
21859 /* Cursor is blinked off, so determine how to "toggle" it. */
21861 /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist. */
21862 if ((alt_cursor = Fassoc (b->cursor_type, Vblink_cursor_alist), !NILP (alt_cursor)))
21863 return get_specified_cursor_type (XCDR (alt_cursor), width);
21865 /* Then see if frame has specified a specific blink off cursor type. */
21866 if (FRAME_BLINK_OFF_CURSOR (f) != DEFAULT_CURSOR)
21868 *width = FRAME_BLINK_OFF_CURSOR_WIDTH (f);
21869 return FRAME_BLINK_OFF_CURSOR (f);
21872 #if 0
21873 /* Some people liked having a permanently visible blinking cursor,
21874 while others had very strong opinions against it. So it was
21875 decided to remove it. KFS 2003-09-03 */
21877 /* Finally perform built-in cursor blinking:
21878 filled box <-> hollow box
21879 wide [h]bar <-> narrow [h]bar
21880 narrow [h]bar <-> no cursor
21881 other type <-> no cursor */
21883 if (cursor_type == FILLED_BOX_CURSOR)
21884 return HOLLOW_BOX_CURSOR;
21886 if ((cursor_type == BAR_CURSOR || cursor_type == HBAR_CURSOR) && *width > 1)
21888 *width = 1;
21889 return cursor_type;
21891 #endif
21893 return NO_CURSOR;
21897 #ifdef HAVE_WINDOW_SYSTEM
21899 /* Notice when the text cursor of window W has been completely
21900 overwritten by a drawing operation that outputs glyphs in AREA
21901 starting at X0 and ending at X1 in the line starting at Y0 and
21902 ending at Y1. X coordinates are area-relative. X1 < 0 means all
21903 the rest of the line after X0 has been written. Y coordinates
21904 are window-relative. */
21906 static void
21907 notice_overwritten_cursor (w, area, x0, x1, y0, y1)
21908 struct window *w;
21909 enum glyph_row_area area;
21910 int x0, y0, x1, y1;
21912 int cx0, cx1, cy0, cy1;
21913 struct glyph_row *row;
21915 if (!w->phys_cursor_on_p)
21916 return;
21917 if (area != TEXT_AREA)
21918 return;
21920 if (w->phys_cursor.vpos < 0
21921 || w->phys_cursor.vpos >= w->current_matrix->nrows
21922 || (row = w->current_matrix->rows + w->phys_cursor.vpos,
21923 !(row->enabled_p && row->displays_text_p)))
21924 return;
21926 if (row->cursor_in_fringe_p)
21928 row->cursor_in_fringe_p = 0;
21929 draw_fringe_bitmap (w, row, 0);
21930 w->phys_cursor_on_p = 0;
21931 return;
21934 cx0 = w->phys_cursor.x;
21935 cx1 = cx0 + w->phys_cursor_width;
21936 if (x0 > cx0 || (x1 >= 0 && x1 < cx1))
21937 return;
21939 /* The cursor image will be completely removed from the
21940 screen if the output area intersects the cursor area in
21941 y-direction. When we draw in [y0 y1[, and some part of
21942 the cursor is at y < y0, that part must have been drawn
21943 before. When scrolling, the cursor is erased before
21944 actually scrolling, so we don't come here. When not
21945 scrolling, the rows above the old cursor row must have
21946 changed, and in this case these rows must have written
21947 over the cursor image.
21949 Likewise if part of the cursor is below y1, with the
21950 exception of the cursor being in the first blank row at
21951 the buffer and window end because update_text_area
21952 doesn't draw that row. (Except when it does, but
21953 that's handled in update_text_area.) */
21955 cy0 = w->phys_cursor.y;
21956 cy1 = cy0 + w->phys_cursor_height;
21957 if ((y0 < cy0 || y0 >= cy1) && (y1 <= cy0 || y1 >= cy1))
21958 return;
21960 w->phys_cursor_on_p = 0;
21963 #endif /* HAVE_WINDOW_SYSTEM */
21966 /************************************************************************
21967 Mouse Face
21968 ************************************************************************/
21970 #ifdef HAVE_WINDOW_SYSTEM
21972 /* EXPORT for RIF:
21973 Fix the display of area AREA of overlapping row ROW in window W
21974 with respect to the overlapping part OVERLAPS. */
21976 void
21977 x_fix_overlapping_area (w, row, area, overlaps)
21978 struct window *w;
21979 struct glyph_row *row;
21980 enum glyph_row_area area;
21981 int overlaps;
21983 int i, x;
21985 BLOCK_INPUT;
21987 x = 0;
21988 for (i = 0; i < row->used[area];)
21990 if (row->glyphs[area][i].overlaps_vertically_p)
21992 int start = i, start_x = x;
21996 x += row->glyphs[area][i].pixel_width;
21997 ++i;
21999 while (i < row->used[area]
22000 && row->glyphs[area][i].overlaps_vertically_p);
22002 draw_glyphs (w, start_x, row, area,
22003 start, i,
22004 DRAW_NORMAL_TEXT, overlaps);
22006 else
22008 x += row->glyphs[area][i].pixel_width;
22009 ++i;
22013 UNBLOCK_INPUT;
22017 /* EXPORT:
22018 Draw the cursor glyph of window W in glyph row ROW. See the
22019 comment of draw_glyphs for the meaning of HL. */
22021 void
22022 draw_phys_cursor_glyph (w, row, hl)
22023 struct window *w;
22024 struct glyph_row *row;
22025 enum draw_glyphs_face hl;
22027 /* If cursor hpos is out of bounds, don't draw garbage. This can
22028 happen in mini-buffer windows when switching between echo area
22029 glyphs and mini-buffer. */
22030 if (w->phys_cursor.hpos < row->used[TEXT_AREA])
22032 int on_p = w->phys_cursor_on_p;
22033 int x1;
22034 x1 = draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
22035 w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
22036 hl, 0);
22037 w->phys_cursor_on_p = on_p;
22039 if (hl == DRAW_CURSOR)
22040 w->phys_cursor_width = x1 - w->phys_cursor.x;
22041 /* When we erase the cursor, and ROW is overlapped by other
22042 rows, make sure that these overlapping parts of other rows
22043 are redrawn. */
22044 else if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
22046 w->phys_cursor_width = x1 - w->phys_cursor.x;
22048 if (row > w->current_matrix->rows
22049 && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
22050 x_fix_overlapping_area (w, row - 1, TEXT_AREA,
22051 OVERLAPS_ERASED_CURSOR);
22053 if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
22054 && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
22055 x_fix_overlapping_area (w, row + 1, TEXT_AREA,
22056 OVERLAPS_ERASED_CURSOR);
22062 /* EXPORT:
22063 Erase the image of a cursor of window W from the screen. */
22065 void
22066 erase_phys_cursor (w)
22067 struct window *w;
22069 struct frame *f = XFRAME (w->frame);
22070 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
22071 int hpos = w->phys_cursor.hpos;
22072 int vpos = w->phys_cursor.vpos;
22073 int mouse_face_here_p = 0;
22074 struct glyph_matrix *active_glyphs = w->current_matrix;
22075 struct glyph_row *cursor_row;
22076 struct glyph *cursor_glyph;
22077 enum draw_glyphs_face hl;
22079 /* No cursor displayed or row invalidated => nothing to do on the
22080 screen. */
22081 if (w->phys_cursor_type == NO_CURSOR)
22082 goto mark_cursor_off;
22084 /* VPOS >= active_glyphs->nrows means that window has been resized.
22085 Don't bother to erase the cursor. */
22086 if (vpos >= active_glyphs->nrows)
22087 goto mark_cursor_off;
22089 /* If row containing cursor is marked invalid, there is nothing we
22090 can do. */
22091 cursor_row = MATRIX_ROW (active_glyphs, vpos);
22092 if (!cursor_row->enabled_p)
22093 goto mark_cursor_off;
22095 /* If line spacing is > 0, old cursor may only be partially visible in
22096 window after split-window. So adjust visible height. */
22097 cursor_row->visible_height = min (cursor_row->visible_height,
22098 window_text_bottom_y (w) - cursor_row->y);
22100 /* If row is completely invisible, don't attempt to delete a cursor which
22101 isn't there. This can happen if cursor is at top of a window, and
22102 we switch to a buffer with a header line in that window. */
22103 if (cursor_row->visible_height <= 0)
22104 goto mark_cursor_off;
22106 /* If cursor is in the fringe, erase by drawing actual bitmap there. */
22107 if (cursor_row->cursor_in_fringe_p)
22109 cursor_row->cursor_in_fringe_p = 0;
22110 draw_fringe_bitmap (w, cursor_row, 0);
22111 goto mark_cursor_off;
22114 /* This can happen when the new row is shorter than the old one.
22115 In this case, either draw_glyphs or clear_end_of_line
22116 should have cleared the cursor. Note that we wouldn't be
22117 able to erase the cursor in this case because we don't have a
22118 cursor glyph at hand. */
22119 if (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])
22120 goto mark_cursor_off;
22122 /* If the cursor is in the mouse face area, redisplay that when
22123 we clear the cursor. */
22124 if (! NILP (dpyinfo->mouse_face_window)
22125 && w == XWINDOW (dpyinfo->mouse_face_window)
22126 && (vpos > dpyinfo->mouse_face_beg_row
22127 || (vpos == dpyinfo->mouse_face_beg_row
22128 && hpos >= dpyinfo->mouse_face_beg_col))
22129 && (vpos < dpyinfo->mouse_face_end_row
22130 || (vpos == dpyinfo->mouse_face_end_row
22131 && hpos < dpyinfo->mouse_face_end_col))
22132 /* Don't redraw the cursor's spot in mouse face if it is at the
22133 end of a line (on a newline). The cursor appears there, but
22134 mouse highlighting does not. */
22135 && cursor_row->used[TEXT_AREA] > hpos)
22136 mouse_face_here_p = 1;
22138 /* Maybe clear the display under the cursor. */
22139 if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
22141 int x, y, left_x;
22142 int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
22143 int width;
22145 cursor_glyph = get_phys_cursor_glyph (w);
22146 if (cursor_glyph == NULL)
22147 goto mark_cursor_off;
22149 width = cursor_glyph->pixel_width;
22150 left_x = window_box_left_offset (w, TEXT_AREA);
22151 x = w->phys_cursor.x;
22152 if (x < left_x)
22153 width -= left_x - x;
22154 width = min (width, window_box_width (w, TEXT_AREA) - x);
22155 y = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, cursor_row->y));
22156 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, max (x, left_x));
22158 if (width > 0)
22159 FRAME_RIF (f)->clear_frame_area (f, x, y, width, cursor_row->visible_height);
22162 /* Erase the cursor by redrawing the character underneath it. */
22163 if (mouse_face_here_p)
22164 hl = DRAW_MOUSE_FACE;
22165 else
22166 hl = DRAW_NORMAL_TEXT;
22167 draw_phys_cursor_glyph (w, cursor_row, hl);
22169 mark_cursor_off:
22170 w->phys_cursor_on_p = 0;
22171 w->phys_cursor_type = NO_CURSOR;
22175 /* EXPORT:
22176 Display or clear cursor of window W. If ON is zero, clear the
22177 cursor. If it is non-zero, display the cursor. If ON is nonzero,
22178 where to put the cursor is specified by HPOS, VPOS, X and Y. */
22180 void
22181 display_and_set_cursor (w, on, hpos, vpos, x, y)
22182 struct window *w;
22183 int on, hpos, vpos, x, y;
22185 struct frame *f = XFRAME (w->frame);
22186 int new_cursor_type;
22187 int new_cursor_width;
22188 int active_cursor;
22189 struct glyph_row *glyph_row;
22190 struct glyph *glyph;
22192 /* This is pointless on invisible frames, and dangerous on garbaged
22193 windows and frames; in the latter case, the frame or window may
22194 be in the midst of changing its size, and x and y may be off the
22195 window. */
22196 if (! FRAME_VISIBLE_P (f)
22197 || FRAME_GARBAGED_P (f)
22198 || vpos >= w->current_matrix->nrows
22199 || hpos >= w->current_matrix->matrix_w)
22200 return;
22202 /* If cursor is off and we want it off, return quickly. */
22203 if (!on && !w->phys_cursor_on_p)
22204 return;
22206 glyph_row = MATRIX_ROW (w->current_matrix, vpos);
22207 /* If cursor row is not enabled, we don't really know where to
22208 display the cursor. */
22209 if (!glyph_row->enabled_p)
22211 w->phys_cursor_on_p = 0;
22212 return;
22215 glyph = NULL;
22216 if (!glyph_row->exact_window_width_line_p
22217 || hpos < glyph_row->used[TEXT_AREA])
22218 glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
22220 xassert (interrupt_input_blocked);
22222 /* Set new_cursor_type to the cursor we want to be displayed. */
22223 new_cursor_type = get_window_cursor_type (w, glyph,
22224 &new_cursor_width, &active_cursor);
22226 /* If cursor is currently being shown and we don't want it to be or
22227 it is in the wrong place, or the cursor type is not what we want,
22228 erase it. */
22229 if (w->phys_cursor_on_p
22230 && (!on
22231 || w->phys_cursor.x != x
22232 || w->phys_cursor.y != y
22233 || new_cursor_type != w->phys_cursor_type
22234 || ((new_cursor_type == BAR_CURSOR || new_cursor_type == HBAR_CURSOR)
22235 && new_cursor_width != w->phys_cursor_width)))
22236 erase_phys_cursor (w);
22238 /* Don't check phys_cursor_on_p here because that flag is only set
22239 to zero in some cases where we know that the cursor has been
22240 completely erased, to avoid the extra work of erasing the cursor
22241 twice. In other words, phys_cursor_on_p can be 1 and the cursor
22242 still not be visible, or it has only been partly erased. */
22243 if (on)
22245 w->phys_cursor_ascent = glyph_row->ascent;
22246 w->phys_cursor_height = glyph_row->height;
22248 /* Set phys_cursor_.* before x_draw_.* is called because some
22249 of them may need the information. */
22250 w->phys_cursor.x = x;
22251 w->phys_cursor.y = glyph_row->y;
22252 w->phys_cursor.hpos = hpos;
22253 w->phys_cursor.vpos = vpos;
22256 FRAME_RIF (f)->draw_window_cursor (w, glyph_row, x, y,
22257 new_cursor_type, new_cursor_width,
22258 on, active_cursor);
22262 /* Switch the display of W's cursor on or off, according to the value
22263 of ON. */
22265 static void
22266 update_window_cursor (w, on)
22267 struct window *w;
22268 int on;
22270 /* Don't update cursor in windows whose frame is in the process
22271 of being deleted. */
22272 if (w->current_matrix)
22274 BLOCK_INPUT;
22275 display_and_set_cursor (w, on, w->phys_cursor.hpos, w->phys_cursor.vpos,
22276 w->phys_cursor.x, w->phys_cursor.y);
22277 UNBLOCK_INPUT;
22282 /* Call update_window_cursor with parameter ON_P on all leaf windows
22283 in the window tree rooted at W. */
22285 static void
22286 update_cursor_in_window_tree (w, on_p)
22287 struct window *w;
22288 int on_p;
22290 while (w)
22292 if (!NILP (w->hchild))
22293 update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
22294 else if (!NILP (w->vchild))
22295 update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
22296 else
22297 update_window_cursor (w, on_p);
22299 w = NILP (w->next) ? 0 : XWINDOW (w->next);
22304 /* EXPORT:
22305 Display the cursor on window W, or clear it, according to ON_P.
22306 Don't change the cursor's position. */
22308 void
22309 x_update_cursor (f, on_p)
22310 struct frame *f;
22311 int on_p;
22313 update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
22317 /* EXPORT:
22318 Clear the cursor of window W to background color, and mark the
22319 cursor as not shown. This is used when the text where the cursor
22320 is is about to be rewritten. */
22322 void
22323 x_clear_cursor (w)
22324 struct window *w;
22326 if (FRAME_VISIBLE_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
22327 update_window_cursor (w, 0);
22331 /* EXPORT:
22332 Display the active region described by mouse_face_* according to DRAW. */
22334 void
22335 show_mouse_face (dpyinfo, draw)
22336 Display_Info *dpyinfo;
22337 enum draw_glyphs_face draw;
22339 struct window *w = XWINDOW (dpyinfo->mouse_face_window);
22340 struct frame *f = XFRAME (WINDOW_FRAME (w));
22342 if (/* If window is in the process of being destroyed, don't bother
22343 to do anything. */
22344 w->current_matrix != NULL
22345 /* Don't update mouse highlight if hidden */
22346 && (draw != DRAW_MOUSE_FACE || !dpyinfo->mouse_face_hidden)
22347 /* Recognize when we are called to operate on rows that don't exist
22348 anymore. This can happen when a window is split. */
22349 && dpyinfo->mouse_face_end_row < w->current_matrix->nrows)
22351 int phys_cursor_on_p = w->phys_cursor_on_p;
22352 struct glyph_row *row, *first, *last;
22354 first = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_beg_row);
22355 last = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_end_row);
22357 for (row = first; row <= last && row->enabled_p; ++row)
22359 int start_hpos, end_hpos, start_x;
22361 /* For all but the first row, the highlight starts at column 0. */
22362 if (row == first)
22364 start_hpos = dpyinfo->mouse_face_beg_col;
22365 start_x = dpyinfo->mouse_face_beg_x;
22367 else
22369 start_hpos = 0;
22370 start_x = 0;
22373 if (row == last)
22374 end_hpos = dpyinfo->mouse_face_end_col;
22375 else
22377 end_hpos = row->used[TEXT_AREA];
22378 if (draw == DRAW_NORMAL_TEXT)
22379 row->fill_line_p = 1; /* Clear to end of line */
22382 if (end_hpos > start_hpos)
22384 draw_glyphs (w, start_x, row, TEXT_AREA,
22385 start_hpos, end_hpos,
22386 draw, 0);
22388 row->mouse_face_p
22389 = draw == DRAW_MOUSE_FACE || draw == DRAW_IMAGE_RAISED;
22393 /* When we've written over the cursor, arrange for it to
22394 be displayed again. */
22395 if (phys_cursor_on_p && !w->phys_cursor_on_p)
22397 BLOCK_INPUT;
22398 display_and_set_cursor (w, 1,
22399 w->phys_cursor.hpos, w->phys_cursor.vpos,
22400 w->phys_cursor.x, w->phys_cursor.y);
22401 UNBLOCK_INPUT;
22405 /* Change the mouse cursor. */
22406 if (draw == DRAW_NORMAL_TEXT && !EQ (dpyinfo->mouse_face_window, f->tool_bar_window))
22407 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->text_cursor);
22408 else if (draw == DRAW_MOUSE_FACE)
22409 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->hand_cursor);
22410 else
22411 FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->nontext_cursor);
22414 /* EXPORT:
22415 Clear out the mouse-highlighted active region.
22416 Redraw it un-highlighted first. Value is non-zero if mouse
22417 face was actually drawn unhighlighted. */
22420 clear_mouse_face (dpyinfo)
22421 Display_Info *dpyinfo;
22423 int cleared = 0;
22425 if (!dpyinfo->mouse_face_hidden && !NILP (dpyinfo->mouse_face_window))
22427 show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
22428 cleared = 1;
22431 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
22432 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
22433 dpyinfo->mouse_face_window = Qnil;
22434 dpyinfo->mouse_face_overlay = Qnil;
22435 return cleared;
22439 /* EXPORT:
22440 Non-zero if physical cursor of window W is within mouse face. */
22443 cursor_in_mouse_face_p (w)
22444 struct window *w;
22446 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
22447 int in_mouse_face = 0;
22449 if (WINDOWP (dpyinfo->mouse_face_window)
22450 && XWINDOW (dpyinfo->mouse_face_window) == w)
22452 int hpos = w->phys_cursor.hpos;
22453 int vpos = w->phys_cursor.vpos;
22455 if (vpos >= dpyinfo->mouse_face_beg_row
22456 && vpos <= dpyinfo->mouse_face_end_row
22457 && (vpos > dpyinfo->mouse_face_beg_row
22458 || hpos >= dpyinfo->mouse_face_beg_col)
22459 && (vpos < dpyinfo->mouse_face_end_row
22460 || hpos < dpyinfo->mouse_face_end_col
22461 || dpyinfo->mouse_face_past_end))
22462 in_mouse_face = 1;
22465 return in_mouse_face;
22471 /* Find the glyph matrix position of buffer position CHARPOS in window
22472 *W. HPOS, *VPOS, *X, and *Y are set to the positions found. W's
22473 current glyphs must be up to date. If CHARPOS is above window
22474 start return (0, 0, 0, 0). If CHARPOS is after end of W, return end
22475 of last line in W. In the row containing CHARPOS, stop before glyphs
22476 having STOP as object. */
22478 #if 1 /* This is a version of fast_find_position that's more correct
22479 in the presence of hscrolling, for example. I didn't install
22480 it right away because the problem fixed is minor, it failed
22481 in 20.x as well, and I think it's too risky to install
22482 so near the release of 21.1. 2001-09-25 gerd. */
22484 static int
22485 fast_find_position (w, charpos, hpos, vpos, x, y, stop)
22486 struct window *w;
22487 EMACS_INT charpos;
22488 int *hpos, *vpos, *x, *y;
22489 Lisp_Object stop;
22491 struct glyph_row *row, *first;
22492 struct glyph *glyph, *end;
22493 int past_end = 0;
22495 first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
22496 if (charpos < MATRIX_ROW_START_CHARPOS (first))
22498 *x = first->x;
22499 *y = first->y;
22500 *hpos = 0;
22501 *vpos = MATRIX_ROW_VPOS (first, w->current_matrix);
22502 return 1;
22505 row = row_containing_pos (w, charpos, first, NULL, 0);
22506 if (row == NULL)
22508 row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
22509 past_end = 1;
22512 /* If whole rows or last part of a row came from a display overlay,
22513 row_containing_pos will skip over such rows because their end pos
22514 equals the start pos of the overlay or interval.
22516 Move back if we have a STOP object and previous row's
22517 end glyph came from STOP. */
22518 if (!NILP (stop))
22520 struct glyph_row *prev;
22521 while ((prev = row - 1, prev >= first)
22522 && MATRIX_ROW_END_CHARPOS (prev) == charpos
22523 && prev->used[TEXT_AREA] > 0)
22525 struct glyph *beg = prev->glyphs[TEXT_AREA];
22526 glyph = beg + prev->used[TEXT_AREA];
22527 while (--glyph >= beg
22528 && INTEGERP (glyph->object));
22529 if (glyph < beg
22530 || !EQ (stop, glyph->object))
22531 break;
22532 row = prev;
22536 *x = row->x;
22537 *y = row->y;
22538 *vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
22540 glyph = row->glyphs[TEXT_AREA];
22541 end = glyph + row->used[TEXT_AREA];
22543 /* Skip over glyphs not having an object at the start of the row.
22544 These are special glyphs like truncation marks on terminal
22545 frames. */
22546 if (row->displays_text_p)
22547 while (glyph < end
22548 && INTEGERP (glyph->object)
22549 && !EQ (stop, glyph->object)
22550 && glyph->charpos < 0)
22552 *x += glyph->pixel_width;
22553 ++glyph;
22556 while (glyph < end
22557 && !INTEGERP (glyph->object)
22558 && !EQ (stop, glyph->object)
22559 && (!BUFFERP (glyph->object)
22560 || glyph->charpos < charpos))
22562 *x += glyph->pixel_width;
22563 ++glyph;
22566 *hpos = glyph - row->glyphs[TEXT_AREA];
22567 return !past_end;
22570 #else /* not 1 */
22572 static int
22573 fast_find_position (w, pos, hpos, vpos, x, y, stop)
22574 struct window *w;
22575 EMACS_INT pos;
22576 int *hpos, *vpos, *x, *y;
22577 Lisp_Object stop;
22579 int i;
22580 int lastcol;
22581 int maybe_next_line_p = 0;
22582 int line_start_position;
22583 int yb = window_text_bottom_y (w);
22584 struct glyph_row *row, *best_row;
22585 int row_vpos, best_row_vpos;
22586 int current_x;
22588 row = best_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
22589 row_vpos = best_row_vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
22591 while (row->y < yb)
22593 if (row->used[TEXT_AREA])
22594 line_start_position = row->glyphs[TEXT_AREA]->charpos;
22595 else
22596 line_start_position = 0;
22598 if (line_start_position > pos)
22599 break;
22600 /* If the position sought is the end of the buffer,
22601 don't include the blank lines at the bottom of the window. */
22602 else if (line_start_position == pos
22603 && pos == BUF_ZV (XBUFFER (w->buffer)))
22605 maybe_next_line_p = 1;
22606 break;
22608 else if (line_start_position > 0)
22610 best_row = row;
22611 best_row_vpos = row_vpos;
22614 if (row->y + row->height >= yb)
22615 break;
22617 ++row;
22618 ++row_vpos;
22621 /* Find the right column within BEST_ROW. */
22622 lastcol = 0;
22623 current_x = best_row->x;
22624 for (i = 0; i < best_row->used[TEXT_AREA]; i++)
22626 struct glyph *glyph = best_row->glyphs[TEXT_AREA] + i;
22627 int charpos = glyph->charpos;
22629 if (BUFFERP (glyph->object))
22631 if (charpos == pos)
22633 *hpos = i;
22634 *vpos = best_row_vpos;
22635 *x = current_x;
22636 *y = best_row->y;
22637 return 1;
22639 else if (charpos > pos)
22640 break;
22642 else if (EQ (glyph->object, stop))
22643 break;
22645 if (charpos > 0)
22646 lastcol = i;
22647 current_x += glyph->pixel_width;
22650 /* If we're looking for the end of the buffer,
22651 and we didn't find it in the line we scanned,
22652 use the start of the following line. */
22653 if (maybe_next_line_p)
22655 ++best_row;
22656 ++best_row_vpos;
22657 lastcol = 0;
22658 current_x = best_row->x;
22661 *vpos = best_row_vpos;
22662 *hpos = lastcol + 1;
22663 *x = current_x;
22664 *y = best_row->y;
22665 return 0;
22668 #endif /* not 1 */
22671 /* Find the position of the glyph for position POS in OBJECT in
22672 window W's current matrix, and return in *X, *Y the pixel
22673 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
22675 RIGHT_P non-zero means return the position of the right edge of the
22676 glyph, RIGHT_P zero means return the left edge position.
22678 If no glyph for POS exists in the matrix, return the position of
22679 the glyph with the next smaller position that is in the matrix, if
22680 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
22681 exists in the matrix, return the position of the glyph with the
22682 next larger position in OBJECT.
22684 Value is non-zero if a glyph was found. */
22686 static int
22687 fast_find_string_pos (w, pos, object, hpos, vpos, x, y, right_p)
22688 struct window *w;
22689 EMACS_INT pos;
22690 Lisp_Object object;
22691 int *hpos, *vpos, *x, *y;
22692 int right_p;
22694 int yb = window_text_bottom_y (w);
22695 struct glyph_row *r;
22696 struct glyph *best_glyph = NULL;
22697 struct glyph_row *best_row = NULL;
22698 int best_x = 0;
22700 for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
22701 r->enabled_p && r->y < yb;
22702 ++r)
22704 struct glyph *g = r->glyphs[TEXT_AREA];
22705 struct glyph *e = g + r->used[TEXT_AREA];
22706 int gx;
22708 for (gx = r->x; g < e; gx += g->pixel_width, ++g)
22709 if (EQ (g->object, object))
22711 if (g->charpos == pos)
22713 best_glyph = g;
22714 best_x = gx;
22715 best_row = r;
22716 goto found;
22718 else if (best_glyph == NULL
22719 || ((eabs (g->charpos - pos)
22720 < eabs (best_glyph->charpos - pos))
22721 && (right_p
22722 ? g->charpos < pos
22723 : g->charpos > pos)))
22725 best_glyph = g;
22726 best_x = gx;
22727 best_row = r;
22732 found:
22734 if (best_glyph)
22736 *x = best_x;
22737 *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
22739 if (right_p)
22741 *x += best_glyph->pixel_width;
22742 ++*hpos;
22745 *y = best_row->y;
22746 *vpos = best_row - w->current_matrix->rows;
22749 return best_glyph != NULL;
22753 /* See if position X, Y is within a hot-spot of an image. */
22755 static int
22756 on_hot_spot_p (hot_spot, x, y)
22757 Lisp_Object hot_spot;
22758 int x, y;
22760 if (!CONSP (hot_spot))
22761 return 0;
22763 if (EQ (XCAR (hot_spot), Qrect))
22765 /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1)) */
22766 Lisp_Object rect = XCDR (hot_spot);
22767 Lisp_Object tem;
22768 if (!CONSP (rect))
22769 return 0;
22770 if (!CONSP (XCAR (rect)))
22771 return 0;
22772 if (!CONSP (XCDR (rect)))
22773 return 0;
22774 if (!(tem = XCAR (XCAR (rect)), INTEGERP (tem) && x >= XINT (tem)))
22775 return 0;
22776 if (!(tem = XCDR (XCAR (rect)), INTEGERP (tem) && y >= XINT (tem)))
22777 return 0;
22778 if (!(tem = XCAR (XCDR (rect)), INTEGERP (tem) && x <= XINT (tem)))
22779 return 0;
22780 if (!(tem = XCDR (XCDR (rect)), INTEGERP (tem) && y <= XINT (tem)))
22781 return 0;
22782 return 1;
22784 else if (EQ (XCAR (hot_spot), Qcircle))
22786 /* CDR is (Center . Radius) = ((x0 . y0) . r) */
22787 Lisp_Object circ = XCDR (hot_spot);
22788 Lisp_Object lr, lx0, ly0;
22789 if (CONSP (circ)
22790 && CONSP (XCAR (circ))
22791 && (lr = XCDR (circ), INTEGERP (lr) || FLOATP (lr))
22792 && (lx0 = XCAR (XCAR (circ)), INTEGERP (lx0))
22793 && (ly0 = XCDR (XCAR (circ)), INTEGERP (ly0)))
22795 double r = XFLOATINT (lr);
22796 double dx = XINT (lx0) - x;
22797 double dy = XINT (ly0) - y;
22798 return (dx * dx + dy * dy <= r * r);
22801 else if (EQ (XCAR (hot_spot), Qpoly))
22803 /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
22804 if (VECTORP (XCDR (hot_spot)))
22806 struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
22807 Lisp_Object *poly = v->contents;
22808 int n = v->size;
22809 int i;
22810 int inside = 0;
22811 Lisp_Object lx, ly;
22812 int x0, y0;
22814 /* Need an even number of coordinates, and at least 3 edges. */
22815 if (n < 6 || n & 1)
22816 return 0;
22818 /* Count edge segments intersecting line from (X,Y) to (X,infinity).
22819 If count is odd, we are inside polygon. Pixels on edges
22820 may or may not be included depending on actual geometry of the
22821 polygon. */
22822 if ((lx = poly[n-2], !INTEGERP (lx))
22823 || (ly = poly[n-1], !INTEGERP (lx)))
22824 return 0;
22825 x0 = XINT (lx), y0 = XINT (ly);
22826 for (i = 0; i < n; i += 2)
22828 int x1 = x0, y1 = y0;
22829 if ((lx = poly[i], !INTEGERP (lx))
22830 || (ly = poly[i+1], !INTEGERP (ly)))
22831 return 0;
22832 x0 = XINT (lx), y0 = XINT (ly);
22834 /* Does this segment cross the X line? */
22835 if (x0 >= x)
22837 if (x1 >= x)
22838 continue;
22840 else if (x1 < x)
22841 continue;
22842 if (y > y0 && y > y1)
22843 continue;
22844 if (y < y0 + ((y1 - y0) * (x - x0)) / (x1 - x0))
22845 inside = !inside;
22847 return inside;
22850 return 0;
22853 Lisp_Object
22854 find_hot_spot (map, x, y)
22855 Lisp_Object map;
22856 int x, y;
22858 while (CONSP (map))
22860 if (CONSP (XCAR (map))
22861 && on_hot_spot_p (XCAR (XCAR (map)), x, y))
22862 return XCAR (map);
22863 map = XCDR (map);
22866 return Qnil;
22869 DEFUN ("lookup-image-map", Flookup_image_map, Slookup_image_map,
22870 3, 3, 0,
22871 doc: /* Lookup in image map MAP coordinates X and Y.
22872 An image map is an alist where each element has the format (AREA ID PLIST).
22873 An AREA is specified as either a rectangle, a circle, or a polygon:
22874 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
22875 pixel coordinates of the upper left and bottom right corners.
22876 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
22877 and the radius of the circle; r may be a float or integer.
22878 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
22879 vector describes one corner in the polygon.
22880 Returns the alist element for the first matching AREA in MAP. */)
22881 (map, x, y)
22882 Lisp_Object map;
22883 Lisp_Object x, y;
22885 if (NILP (map))
22886 return Qnil;
22888 CHECK_NUMBER (x);
22889 CHECK_NUMBER (y);
22891 return find_hot_spot (map, XINT (x), XINT (y));
22895 /* Display frame CURSOR, optionally using shape defined by POINTER. */
22896 static void
22897 define_frame_cursor1 (f, cursor, pointer)
22898 struct frame *f;
22899 Cursor cursor;
22900 Lisp_Object pointer;
22902 /* Do not change cursor shape while dragging mouse. */
22903 if (!NILP (do_mouse_tracking))
22904 return;
22906 if (!NILP (pointer))
22908 if (EQ (pointer, Qarrow))
22909 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
22910 else if (EQ (pointer, Qhand))
22911 cursor = FRAME_X_OUTPUT (f)->hand_cursor;
22912 else if (EQ (pointer, Qtext))
22913 cursor = FRAME_X_OUTPUT (f)->text_cursor;
22914 else if (EQ (pointer, intern ("hdrag")))
22915 cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
22916 #ifdef HAVE_X_WINDOWS
22917 else if (EQ (pointer, intern ("vdrag")))
22918 cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
22919 #endif
22920 else if (EQ (pointer, intern ("hourglass")))
22921 cursor = FRAME_X_OUTPUT (f)->hourglass_cursor;
22922 else if (EQ (pointer, Qmodeline))
22923 cursor = FRAME_X_OUTPUT (f)->modeline_cursor;
22924 else
22925 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
22928 if (cursor != No_Cursor)
22929 FRAME_RIF (f)->define_frame_cursor (f, cursor);
22932 /* Take proper action when mouse has moved to the mode or header line
22933 or marginal area AREA of window W, x-position X and y-position Y.
22934 X is relative to the start of the text display area of W, so the
22935 width of bitmap areas and scroll bars must be subtracted to get a
22936 position relative to the start of the mode line. */
22938 static void
22939 note_mode_line_or_margin_highlight (window, x, y, area)
22940 Lisp_Object window;
22941 int x, y;
22942 enum window_part area;
22944 struct window *w = XWINDOW (window);
22945 struct frame *f = XFRAME (w->frame);
22946 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
22947 Cursor cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
22948 Lisp_Object pointer = Qnil;
22949 int charpos, dx, dy, width, height;
22950 Lisp_Object string, object = Qnil;
22951 Lisp_Object pos, help;
22953 Lisp_Object mouse_face;
22954 int original_x_pixel = x;
22955 struct glyph * glyph = NULL, * row_start_glyph = NULL;
22956 struct glyph_row *row;
22958 if (area == ON_MODE_LINE || area == ON_HEADER_LINE)
22960 int x0;
22961 struct glyph *end;
22963 string = mode_line_string (w, area, &x, &y, &charpos,
22964 &object, &dx, &dy, &width, &height);
22966 row = (area == ON_MODE_LINE
22967 ? MATRIX_MODE_LINE_ROW (w->current_matrix)
22968 : MATRIX_HEADER_LINE_ROW (w->current_matrix));
22970 /* Find glyph */
22971 if (row->mode_line_p && row->enabled_p)
22973 glyph = row_start_glyph = row->glyphs[TEXT_AREA];
22974 end = glyph + row->used[TEXT_AREA];
22976 for (x0 = original_x_pixel;
22977 glyph < end && x0 >= glyph->pixel_width;
22978 ++glyph)
22979 x0 -= glyph->pixel_width;
22981 if (glyph >= end)
22982 glyph = NULL;
22985 else
22987 x -= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
22988 string = marginal_area_string (w, area, &x, &y, &charpos,
22989 &object, &dx, &dy, &width, &height);
22992 help = Qnil;
22994 if (IMAGEP (object))
22996 Lisp_Object image_map, hotspot;
22997 if ((image_map = Fplist_get (XCDR (object), QCmap),
22998 !NILP (image_map))
22999 && (hotspot = find_hot_spot (image_map, dx, dy),
23000 CONSP (hotspot))
23001 && (hotspot = XCDR (hotspot), CONSP (hotspot)))
23003 Lisp_Object area_id, plist;
23005 area_id = XCAR (hotspot);
23006 /* Could check AREA_ID to see if we enter/leave this hot-spot.
23007 If so, we could look for mouse-enter, mouse-leave
23008 properties in PLIST (and do something...). */
23009 hotspot = XCDR (hotspot);
23010 if (CONSP (hotspot)
23011 && (plist = XCAR (hotspot), CONSP (plist)))
23013 pointer = Fplist_get (plist, Qpointer);
23014 if (NILP (pointer))
23015 pointer = Qhand;
23016 help = Fplist_get (plist, Qhelp_echo);
23017 if (!NILP (help))
23019 help_echo_string = help;
23020 /* Is this correct? ++kfs */
23021 XSETWINDOW (help_echo_window, w);
23022 help_echo_object = w->buffer;
23023 help_echo_pos = charpos;
23027 if (NILP (pointer))
23028 pointer = Fplist_get (XCDR (object), QCpointer);
23031 if (STRINGP (string))
23033 pos = make_number (charpos);
23034 /* If we're on a string with `help-echo' text property, arrange
23035 for the help to be displayed. This is done by setting the
23036 global variable help_echo_string to the help string. */
23037 if (NILP (help))
23039 help = Fget_text_property (pos, Qhelp_echo, string);
23040 if (!NILP (help))
23042 help_echo_string = help;
23043 XSETWINDOW (help_echo_window, w);
23044 help_echo_object = string;
23045 help_echo_pos = charpos;
23049 if (NILP (pointer))
23050 pointer = Fget_text_property (pos, Qpointer, string);
23052 /* Change the mouse pointer according to what is under X/Y. */
23053 if (NILP (pointer) && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)))
23055 Lisp_Object map;
23056 map = Fget_text_property (pos, Qlocal_map, string);
23057 if (!KEYMAPP (map))
23058 map = Fget_text_property (pos, Qkeymap, string);
23059 if (!KEYMAPP (map))
23060 cursor = dpyinfo->vertical_scroll_bar_cursor;
23063 /* Change the mouse face according to what is under X/Y. */
23064 mouse_face = Fget_text_property (pos, Qmouse_face, string);
23065 if (!NILP (mouse_face)
23066 && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
23067 && glyph)
23069 Lisp_Object b, e;
23071 struct glyph * tmp_glyph;
23073 int gpos;
23074 int gseq_length;
23075 int total_pixel_width;
23076 EMACS_INT ignore;
23078 int vpos, hpos;
23080 b = Fprevious_single_property_change (make_number (charpos + 1),
23081 Qmouse_face, string, Qnil);
23082 if (NILP (b))
23083 b = make_number (0);
23085 e = Fnext_single_property_change (pos, Qmouse_face, string, Qnil);
23086 if (NILP (e))
23087 e = make_number (SCHARS (string));
23089 /* Calculate the position(glyph position: GPOS) of GLYPH in
23090 displayed string. GPOS is different from CHARPOS.
23092 CHARPOS is the position of glyph in internal string
23093 object. A mode line string format has structures which
23094 is converted to a flatten by emacs lisp interpreter.
23095 The internal string is an element of the structures.
23096 The displayed string is the flatten string. */
23097 gpos = 0;
23098 if (glyph > row_start_glyph)
23100 tmp_glyph = glyph - 1;
23101 while (tmp_glyph >= row_start_glyph
23102 && tmp_glyph->charpos >= XINT (b)
23103 && EQ (tmp_glyph->object, glyph->object))
23105 tmp_glyph--;
23106 gpos++;
23110 /* Calculate the lenght(glyph sequence length: GSEQ_LENGTH) of
23111 displayed string holding GLYPH.
23113 GSEQ_LENGTH is different from SCHARS (STRING).
23114 SCHARS (STRING) returns the length of the internal string. */
23115 for (tmp_glyph = glyph, gseq_length = gpos;
23116 tmp_glyph->charpos < XINT (e);
23117 tmp_glyph++, gseq_length++)
23119 if (!EQ (tmp_glyph->object, glyph->object))
23120 break;
23123 total_pixel_width = 0;
23124 for (tmp_glyph = glyph - gpos; tmp_glyph != glyph; tmp_glyph++)
23125 total_pixel_width += tmp_glyph->pixel_width;
23127 /* Pre calculation of re-rendering position */
23128 vpos = (x - gpos);
23129 hpos = (area == ON_MODE_LINE
23130 ? (w->current_matrix)->nrows - 1
23131 : 0);
23133 /* If the re-rendering position is included in the last
23134 re-rendering area, we should do nothing. */
23135 if ( EQ (window, dpyinfo->mouse_face_window)
23136 && dpyinfo->mouse_face_beg_col <= vpos
23137 && vpos < dpyinfo->mouse_face_end_col
23138 && dpyinfo->mouse_face_beg_row == hpos )
23139 return;
23141 if (clear_mouse_face (dpyinfo))
23142 cursor = No_Cursor;
23144 dpyinfo->mouse_face_beg_col = vpos;
23145 dpyinfo->mouse_face_beg_row = hpos;
23147 dpyinfo->mouse_face_beg_x = original_x_pixel - (total_pixel_width + dx);
23148 dpyinfo->mouse_face_beg_y = 0;
23150 dpyinfo->mouse_face_end_col = vpos + gseq_length;
23151 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_beg_row;
23153 dpyinfo->mouse_face_end_x = 0;
23154 dpyinfo->mouse_face_end_y = 0;
23156 dpyinfo->mouse_face_past_end = 0;
23157 dpyinfo->mouse_face_window = window;
23159 dpyinfo->mouse_face_face_id = face_at_string_position (w, string,
23160 charpos,
23161 0, 0, 0, &ignore,
23162 glyph->face_id, 1);
23163 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
23165 if (NILP (pointer))
23166 pointer = Qhand;
23168 else if ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
23169 clear_mouse_face (dpyinfo);
23171 define_frame_cursor1 (f, cursor, pointer);
23175 /* EXPORT:
23176 Take proper action when the mouse has moved to position X, Y on
23177 frame F as regards highlighting characters that have mouse-face
23178 properties. Also de-highlighting chars where the mouse was before.
23179 X and Y can be negative or out of range. */
23181 void
23182 note_mouse_highlight (f, x, y)
23183 struct frame *f;
23184 int x, y;
23186 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
23187 enum window_part part;
23188 Lisp_Object window;
23189 struct window *w;
23190 Cursor cursor = No_Cursor;
23191 Lisp_Object pointer = Qnil; /* Takes precedence over cursor! */
23192 struct buffer *b;
23194 /* When a menu is active, don't highlight because this looks odd. */
23195 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (MAC_OS)
23196 if (popup_activated ())
23197 return;
23198 #endif
23200 if (NILP (Vmouse_highlight)
23201 || !f->glyphs_initialized_p)
23202 return;
23204 dpyinfo->mouse_face_mouse_x = x;
23205 dpyinfo->mouse_face_mouse_y = y;
23206 dpyinfo->mouse_face_mouse_frame = f;
23208 if (dpyinfo->mouse_face_defer)
23209 return;
23211 if (gc_in_progress)
23213 dpyinfo->mouse_face_deferred_gc = 1;
23214 return;
23217 /* Which window is that in? */
23218 window = window_from_coordinates (f, x, y, &part, 0, 0, 1);
23220 /* If we were displaying active text in another window, clear that.
23221 Also clear if we move out of text area in same window. */
23222 if (! EQ (window, dpyinfo->mouse_face_window)
23223 || (part != ON_TEXT && part != ON_MODE_LINE && part != ON_HEADER_LINE
23224 && !NILP (dpyinfo->mouse_face_window)))
23225 clear_mouse_face (dpyinfo);
23227 /* Not on a window -> return. */
23228 if (!WINDOWP (window))
23229 return;
23231 /* Reset help_echo_string. It will get recomputed below. */
23232 help_echo_string = Qnil;
23234 /* Convert to window-relative pixel coordinates. */
23235 w = XWINDOW (window);
23236 frame_to_window_pixel_xy (w, &x, &y);
23238 /* Handle tool-bar window differently since it doesn't display a
23239 buffer. */
23240 if (EQ (window, f->tool_bar_window))
23242 note_tool_bar_highlight (f, x, y);
23243 return;
23246 /* Mouse is on the mode, header line or margin? */
23247 if (part == ON_MODE_LINE || part == ON_HEADER_LINE
23248 || part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
23250 note_mode_line_or_margin_highlight (window, x, y, part);
23251 return;
23254 if (part == ON_VERTICAL_BORDER)
23256 cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
23257 help_echo_string = build_string ("drag-mouse-1: resize");
23259 else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
23260 || part == ON_SCROLL_BAR)
23261 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
23262 else
23263 cursor = FRAME_X_OUTPUT (f)->text_cursor;
23265 /* Are we in a window whose display is up to date?
23266 And verify the buffer's text has not changed. */
23267 b = XBUFFER (w->buffer);
23268 if (part == ON_TEXT
23269 && EQ (w->window_end_valid, w->buffer)
23270 && XFASTINT (w->last_modified) == BUF_MODIFF (b)
23271 && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
23273 int hpos, vpos, pos, i, dx, dy, area;
23274 struct glyph *glyph;
23275 Lisp_Object object;
23276 Lisp_Object mouse_face = Qnil, overlay = Qnil, position;
23277 Lisp_Object *overlay_vec = NULL;
23278 int noverlays;
23279 struct buffer *obuf;
23280 int obegv, ozv, same_region;
23282 /* Find the glyph under X/Y. */
23283 glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &dx, &dy, &area);
23285 /* Look for :pointer property on image. */
23286 if (glyph != NULL && glyph->type == IMAGE_GLYPH)
23288 struct image *img = IMAGE_FROM_ID (f, glyph->u.img_id);
23289 if (img != NULL && IMAGEP (img->spec))
23291 Lisp_Object image_map, hotspot;
23292 if ((image_map = Fplist_get (XCDR (img->spec), QCmap),
23293 !NILP (image_map))
23294 && (hotspot = find_hot_spot (image_map,
23295 glyph->slice.x + dx,
23296 glyph->slice.y + dy),
23297 CONSP (hotspot))
23298 && (hotspot = XCDR (hotspot), CONSP (hotspot)))
23300 Lisp_Object area_id, plist;
23302 area_id = XCAR (hotspot);
23303 /* Could check AREA_ID to see if we enter/leave this hot-spot.
23304 If so, we could look for mouse-enter, mouse-leave
23305 properties in PLIST (and do something...). */
23306 hotspot = XCDR (hotspot);
23307 if (CONSP (hotspot)
23308 && (plist = XCAR (hotspot), CONSP (plist)))
23310 pointer = Fplist_get (plist, Qpointer);
23311 if (NILP (pointer))
23312 pointer = Qhand;
23313 help_echo_string = Fplist_get (plist, Qhelp_echo);
23314 if (!NILP (help_echo_string))
23316 help_echo_window = window;
23317 help_echo_object = glyph->object;
23318 help_echo_pos = glyph->charpos;
23322 if (NILP (pointer))
23323 pointer = Fplist_get (XCDR (img->spec), QCpointer);
23327 /* Clear mouse face if X/Y not over text. */
23328 if (glyph == NULL
23329 || area != TEXT_AREA
23330 || !MATRIX_ROW (w->current_matrix, vpos)->displays_text_p)
23332 if (clear_mouse_face (dpyinfo))
23333 cursor = No_Cursor;
23334 if (NILP (pointer))
23336 if (area != TEXT_AREA)
23337 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
23338 else
23339 pointer = Vvoid_text_area_pointer;
23341 goto set_cursor;
23344 pos = glyph->charpos;
23345 object = glyph->object;
23346 if (!STRINGP (object) && !BUFFERP (object))
23347 goto set_cursor;
23349 /* If we get an out-of-range value, return now; avoid an error. */
23350 if (BUFFERP (object) && pos > BUF_Z (b))
23351 goto set_cursor;
23353 /* Make the window's buffer temporarily current for
23354 overlays_at and compute_char_face. */
23355 obuf = current_buffer;
23356 current_buffer = b;
23357 obegv = BEGV;
23358 ozv = ZV;
23359 BEGV = BEG;
23360 ZV = Z;
23362 /* Is this char mouse-active or does it have help-echo? */
23363 position = make_number (pos);
23365 if (BUFFERP (object))
23367 /* Put all the overlays we want in a vector in overlay_vec. */
23368 GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL, 0);
23369 /* Sort overlays into increasing priority order. */
23370 noverlays = sort_overlays (overlay_vec, noverlays, w);
23372 else
23373 noverlays = 0;
23375 same_region = (EQ (window, dpyinfo->mouse_face_window)
23376 && vpos >= dpyinfo->mouse_face_beg_row
23377 && vpos <= dpyinfo->mouse_face_end_row
23378 && (vpos > dpyinfo->mouse_face_beg_row
23379 || hpos >= dpyinfo->mouse_face_beg_col)
23380 && (vpos < dpyinfo->mouse_face_end_row
23381 || hpos < dpyinfo->mouse_face_end_col
23382 || dpyinfo->mouse_face_past_end));
23384 if (same_region)
23385 cursor = No_Cursor;
23387 /* Check mouse-face highlighting. */
23388 if (! same_region
23389 /* If there exists an overlay with mouse-face overlapping
23390 the one we are currently highlighting, we have to
23391 check if we enter the overlapping overlay, and then
23392 highlight only that. */
23393 || (OVERLAYP (dpyinfo->mouse_face_overlay)
23394 && mouse_face_overlay_overlaps (dpyinfo->mouse_face_overlay)))
23396 /* Find the highest priority overlay that has a mouse-face
23397 property. */
23398 overlay = Qnil;
23399 for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
23401 mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
23402 if (!NILP (mouse_face))
23403 overlay = overlay_vec[i];
23406 /* If we're actually highlighting the same overlay as
23407 before, there's no need to do that again. */
23408 if (!NILP (overlay)
23409 && EQ (overlay, dpyinfo->mouse_face_overlay))
23410 goto check_help_echo;
23412 dpyinfo->mouse_face_overlay = overlay;
23414 /* Clear the display of the old active region, if any. */
23415 if (clear_mouse_face (dpyinfo))
23416 cursor = No_Cursor;
23418 /* If no overlay applies, get a text property. */
23419 if (NILP (overlay))
23420 mouse_face = Fget_text_property (position, Qmouse_face, object);
23422 /* Handle the overlay case. */
23423 if (!NILP (overlay))
23425 /* Find the range of text around this char that
23426 should be active. */
23427 Lisp_Object before, after;
23428 EMACS_INT ignore;
23430 before = Foverlay_start (overlay);
23431 after = Foverlay_end (overlay);
23432 /* Record this as the current active region. */
23433 fast_find_position (w, XFASTINT (before),
23434 &dpyinfo->mouse_face_beg_col,
23435 &dpyinfo->mouse_face_beg_row,
23436 &dpyinfo->mouse_face_beg_x,
23437 &dpyinfo->mouse_face_beg_y, Qnil);
23439 dpyinfo->mouse_face_past_end
23440 = !fast_find_position (w, XFASTINT (after),
23441 &dpyinfo->mouse_face_end_col,
23442 &dpyinfo->mouse_face_end_row,
23443 &dpyinfo->mouse_face_end_x,
23444 &dpyinfo->mouse_face_end_y, Qnil);
23445 dpyinfo->mouse_face_window = window;
23447 dpyinfo->mouse_face_face_id
23448 = face_at_buffer_position (w, pos, 0, 0,
23449 &ignore, pos + 1,
23450 !dpyinfo->mouse_face_hidden);
23452 /* Display it as active. */
23453 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
23454 cursor = No_Cursor;
23456 /* Handle the text property case. */
23457 else if (!NILP (mouse_face) && BUFFERP (object))
23459 /* Find the range of text around this char that
23460 should be active. */
23461 Lisp_Object before, after, beginning, end;
23462 EMACS_INT ignore;
23464 beginning = Fmarker_position (w->start);
23465 end = make_number (BUF_Z (XBUFFER (object))
23466 - XFASTINT (w->window_end_pos));
23467 before
23468 = Fprevious_single_property_change (make_number (pos + 1),
23469 Qmouse_face,
23470 object, beginning);
23471 after
23472 = Fnext_single_property_change (position, Qmouse_face,
23473 object, end);
23475 /* Record this as the current active region. */
23476 fast_find_position (w, XFASTINT (before),
23477 &dpyinfo->mouse_face_beg_col,
23478 &dpyinfo->mouse_face_beg_row,
23479 &dpyinfo->mouse_face_beg_x,
23480 &dpyinfo->mouse_face_beg_y, Qnil);
23481 dpyinfo->mouse_face_past_end
23482 = !fast_find_position (w, XFASTINT (after),
23483 &dpyinfo->mouse_face_end_col,
23484 &dpyinfo->mouse_face_end_row,
23485 &dpyinfo->mouse_face_end_x,
23486 &dpyinfo->mouse_face_end_y, Qnil);
23487 dpyinfo->mouse_face_window = window;
23489 if (BUFFERP (object))
23490 dpyinfo->mouse_face_face_id
23491 = face_at_buffer_position (w, pos, 0, 0,
23492 &ignore, pos + 1,
23493 !dpyinfo->mouse_face_hidden);
23495 /* Display it as active. */
23496 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
23497 cursor = No_Cursor;
23499 else if (!NILP (mouse_face) && STRINGP (object))
23501 Lisp_Object b, e;
23502 EMACS_INT ignore;
23504 b = Fprevious_single_property_change (make_number (pos + 1),
23505 Qmouse_face,
23506 object, Qnil);
23507 e = Fnext_single_property_change (position, Qmouse_face,
23508 object, Qnil);
23509 if (NILP (b))
23510 b = make_number (0);
23511 if (NILP (e))
23512 e = make_number (SCHARS (object) - 1);
23514 fast_find_string_pos (w, XINT (b), object,
23515 &dpyinfo->mouse_face_beg_col,
23516 &dpyinfo->mouse_face_beg_row,
23517 &dpyinfo->mouse_face_beg_x,
23518 &dpyinfo->mouse_face_beg_y, 0);
23519 fast_find_string_pos (w, XINT (e), object,
23520 &dpyinfo->mouse_face_end_col,
23521 &dpyinfo->mouse_face_end_row,
23522 &dpyinfo->mouse_face_end_x,
23523 &dpyinfo->mouse_face_end_y, 1);
23524 dpyinfo->mouse_face_past_end = 0;
23525 dpyinfo->mouse_face_window = window;
23526 dpyinfo->mouse_face_face_id
23527 = face_at_string_position (w, object, pos, 0, 0, 0, &ignore,
23528 glyph->face_id, 1);
23529 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
23530 cursor = No_Cursor;
23532 else if (STRINGP (object) && NILP (mouse_face))
23534 /* A string which doesn't have mouse-face, but
23535 the text ``under'' it might have. */
23536 struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
23537 int start = MATRIX_ROW_START_CHARPOS (r);
23539 pos = string_buffer_position (w, object, start);
23540 if (pos > 0)
23541 mouse_face = get_char_property_and_overlay (make_number (pos),
23542 Qmouse_face,
23543 w->buffer,
23544 &overlay);
23545 if (!NILP (mouse_face) && !NILP (overlay))
23547 Lisp_Object before = Foverlay_start (overlay);
23548 Lisp_Object after = Foverlay_end (overlay);
23549 EMACS_INT ignore;
23551 /* Note that we might not be able to find position
23552 BEFORE in the glyph matrix if the overlay is
23553 entirely covered by a `display' property. In
23554 this case, we overshoot. So let's stop in
23555 the glyph matrix before glyphs for OBJECT. */
23556 fast_find_position (w, XFASTINT (before),
23557 &dpyinfo->mouse_face_beg_col,
23558 &dpyinfo->mouse_face_beg_row,
23559 &dpyinfo->mouse_face_beg_x,
23560 &dpyinfo->mouse_face_beg_y,
23561 object);
23563 dpyinfo->mouse_face_past_end
23564 = !fast_find_position (w, XFASTINT (after),
23565 &dpyinfo->mouse_face_end_col,
23566 &dpyinfo->mouse_face_end_row,
23567 &dpyinfo->mouse_face_end_x,
23568 &dpyinfo->mouse_face_end_y,
23569 Qnil);
23570 dpyinfo->mouse_face_window = window;
23571 dpyinfo->mouse_face_face_id
23572 = face_at_buffer_position (w, pos, 0, 0,
23573 &ignore, pos + 1,
23574 !dpyinfo->mouse_face_hidden);
23576 /* Display it as active. */
23577 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
23578 cursor = No_Cursor;
23583 check_help_echo:
23585 /* Look for a `help-echo' property. */
23586 if (NILP (help_echo_string)) {
23587 Lisp_Object help, overlay;
23589 /* Check overlays first. */
23590 help = overlay = Qnil;
23591 for (i = noverlays - 1; i >= 0 && NILP (help); --i)
23593 overlay = overlay_vec[i];
23594 help = Foverlay_get (overlay, Qhelp_echo);
23597 if (!NILP (help))
23599 help_echo_string = help;
23600 help_echo_window = window;
23601 help_echo_object = overlay;
23602 help_echo_pos = pos;
23604 else
23606 Lisp_Object object = glyph->object;
23607 int charpos = glyph->charpos;
23609 /* Try text properties. */
23610 if (STRINGP (object)
23611 && charpos >= 0
23612 && charpos < SCHARS (object))
23614 help = Fget_text_property (make_number (charpos),
23615 Qhelp_echo, object);
23616 if (NILP (help))
23618 /* If the string itself doesn't specify a help-echo,
23619 see if the buffer text ``under'' it does. */
23620 struct glyph_row *r
23621 = MATRIX_ROW (w->current_matrix, vpos);
23622 int start = MATRIX_ROW_START_CHARPOS (r);
23623 int pos = string_buffer_position (w, object, start);
23624 if (pos > 0)
23626 help = Fget_char_property (make_number (pos),
23627 Qhelp_echo, w->buffer);
23628 if (!NILP (help))
23630 charpos = pos;
23631 object = w->buffer;
23636 else if (BUFFERP (object)
23637 && charpos >= BEGV
23638 && charpos < ZV)
23639 help = Fget_text_property (make_number (charpos), Qhelp_echo,
23640 object);
23642 if (!NILP (help))
23644 help_echo_string = help;
23645 help_echo_window = window;
23646 help_echo_object = object;
23647 help_echo_pos = charpos;
23652 /* Look for a `pointer' property. */
23653 if (NILP (pointer))
23655 /* Check overlays first. */
23656 for (i = noverlays - 1; i >= 0 && NILP (pointer); --i)
23657 pointer = Foverlay_get (overlay_vec[i], Qpointer);
23659 if (NILP (pointer))
23661 Lisp_Object object = glyph->object;
23662 int charpos = glyph->charpos;
23664 /* Try text properties. */
23665 if (STRINGP (object)
23666 && charpos >= 0
23667 && charpos < SCHARS (object))
23669 pointer = Fget_text_property (make_number (charpos),
23670 Qpointer, object);
23671 if (NILP (pointer))
23673 /* If the string itself doesn't specify a pointer,
23674 see if the buffer text ``under'' it does. */
23675 struct glyph_row *r
23676 = MATRIX_ROW (w->current_matrix, vpos);
23677 int start = MATRIX_ROW_START_CHARPOS (r);
23678 int pos = string_buffer_position (w, object, start);
23679 if (pos > 0)
23680 pointer = Fget_char_property (make_number (pos),
23681 Qpointer, w->buffer);
23684 else if (BUFFERP (object)
23685 && charpos >= BEGV
23686 && charpos < ZV)
23687 pointer = Fget_text_property (make_number (charpos),
23688 Qpointer, object);
23692 BEGV = obegv;
23693 ZV = ozv;
23694 current_buffer = obuf;
23697 set_cursor:
23699 define_frame_cursor1 (f, cursor, pointer);
23703 /* EXPORT for RIF:
23704 Clear any mouse-face on window W. This function is part of the
23705 redisplay interface, and is called from try_window_id and similar
23706 functions to ensure the mouse-highlight is off. */
23708 void
23709 x_clear_window_mouse_face (w)
23710 struct window *w;
23712 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
23713 Lisp_Object window;
23715 BLOCK_INPUT;
23716 XSETWINDOW (window, w);
23717 if (EQ (window, dpyinfo->mouse_face_window))
23718 clear_mouse_face (dpyinfo);
23719 UNBLOCK_INPUT;
23723 /* EXPORT:
23724 Just discard the mouse face information for frame F, if any.
23725 This is used when the size of F is changed. */
23727 void
23728 cancel_mouse_face (f)
23729 struct frame *f;
23731 Lisp_Object window;
23732 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
23734 window = dpyinfo->mouse_face_window;
23735 if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
23737 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
23738 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
23739 dpyinfo->mouse_face_window = Qnil;
23744 #endif /* HAVE_WINDOW_SYSTEM */
23747 /***********************************************************************
23748 Exposure Events
23749 ***********************************************************************/
23751 #ifdef HAVE_WINDOW_SYSTEM
23753 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
23754 which intersects rectangle R. R is in window-relative coordinates. */
23756 static void
23757 expose_area (w, row, r, area)
23758 struct window *w;
23759 struct glyph_row *row;
23760 XRectangle *r;
23761 enum glyph_row_area area;
23763 struct glyph *first = row->glyphs[area];
23764 struct glyph *end = row->glyphs[area] + row->used[area];
23765 struct glyph *last;
23766 int first_x, start_x, x;
23768 if (area == TEXT_AREA && row->fill_line_p)
23769 /* If row extends face to end of line write the whole line. */
23770 draw_glyphs (w, 0, row, area,
23771 0, row->used[area],
23772 DRAW_NORMAL_TEXT, 0);
23773 else
23775 /* Set START_X to the window-relative start position for drawing glyphs of
23776 AREA. The first glyph of the text area can be partially visible.
23777 The first glyphs of other areas cannot. */
23778 start_x = window_box_left_offset (w, area);
23779 x = start_x;
23780 if (area == TEXT_AREA)
23781 x += row->x;
23783 /* Find the first glyph that must be redrawn. */
23784 while (first < end
23785 && x + first->pixel_width < r->x)
23787 x += first->pixel_width;
23788 ++first;
23791 /* Find the last one. */
23792 last = first;
23793 first_x = x;
23794 while (last < end
23795 && x < r->x + r->width)
23797 x += last->pixel_width;
23798 ++last;
23801 /* Repaint. */
23802 if (last > first)
23803 draw_glyphs (w, first_x - start_x, row, area,
23804 first - row->glyphs[area], last - row->glyphs[area],
23805 DRAW_NORMAL_TEXT, 0);
23810 /* Redraw the parts of the glyph row ROW on window W intersecting
23811 rectangle R. R is in window-relative coordinates. Value is
23812 non-zero if mouse-face was overwritten. */
23814 static int
23815 expose_line (w, row, r)
23816 struct window *w;
23817 struct glyph_row *row;
23818 XRectangle *r;
23820 xassert (row->enabled_p);
23822 if (row->mode_line_p || w->pseudo_window_p)
23823 draw_glyphs (w, 0, row, TEXT_AREA,
23824 0, row->used[TEXT_AREA],
23825 DRAW_NORMAL_TEXT, 0);
23826 else
23828 if (row->used[LEFT_MARGIN_AREA])
23829 expose_area (w, row, r, LEFT_MARGIN_AREA);
23830 if (row->used[TEXT_AREA])
23831 expose_area (w, row, r, TEXT_AREA);
23832 if (row->used[RIGHT_MARGIN_AREA])
23833 expose_area (w, row, r, RIGHT_MARGIN_AREA);
23834 draw_row_fringe_bitmaps (w, row);
23837 return row->mouse_face_p;
23841 /* Redraw those parts of glyphs rows during expose event handling that
23842 overlap other rows. Redrawing of an exposed line writes over parts
23843 of lines overlapping that exposed line; this function fixes that.
23845 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
23846 row in W's current matrix that is exposed and overlaps other rows.
23847 LAST_OVERLAPPING_ROW is the last such row. */
23849 static void
23850 expose_overlaps (w, first_overlapping_row, last_overlapping_row, r)
23851 struct window *w;
23852 struct glyph_row *first_overlapping_row;
23853 struct glyph_row *last_overlapping_row;
23854 XRectangle *r;
23856 struct glyph_row *row;
23858 for (row = first_overlapping_row; row <= last_overlapping_row; ++row)
23859 if (row->overlapping_p)
23861 xassert (row->enabled_p && !row->mode_line_p);
23863 row->clip = r;
23864 if (row->used[LEFT_MARGIN_AREA])
23865 x_fix_overlapping_area (w, row, LEFT_MARGIN_AREA, OVERLAPS_BOTH);
23867 if (row->used[TEXT_AREA])
23868 x_fix_overlapping_area (w, row, TEXT_AREA, OVERLAPS_BOTH);
23870 if (row->used[RIGHT_MARGIN_AREA])
23871 x_fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, OVERLAPS_BOTH);
23872 row->clip = NULL;
23877 /* Return non-zero if W's cursor intersects rectangle R. */
23879 static int
23880 phys_cursor_in_rect_p (w, r)
23881 struct window *w;
23882 XRectangle *r;
23884 XRectangle cr, result;
23885 struct glyph *cursor_glyph;
23886 struct glyph_row *row;
23888 if (w->phys_cursor.vpos >= 0
23889 && w->phys_cursor.vpos < w->current_matrix->nrows
23890 && (row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos),
23891 row->enabled_p)
23892 && row->cursor_in_fringe_p)
23894 /* Cursor is in the fringe. */
23895 cr.x = window_box_right_offset (w,
23896 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
23897 ? RIGHT_MARGIN_AREA
23898 : TEXT_AREA));
23899 cr.y = row->y;
23900 cr.width = WINDOW_RIGHT_FRINGE_WIDTH (w);
23901 cr.height = row->height;
23902 return x_intersect_rectangles (&cr, r, &result);
23905 cursor_glyph = get_phys_cursor_glyph (w);
23906 if (cursor_glyph)
23908 /* r is relative to W's box, but w->phys_cursor.x is relative
23909 to left edge of W's TEXT area. Adjust it. */
23910 cr.x = window_box_left_offset (w, TEXT_AREA) + w->phys_cursor.x;
23911 cr.y = w->phys_cursor.y;
23912 cr.width = cursor_glyph->pixel_width;
23913 cr.height = w->phys_cursor_height;
23914 /* ++KFS: W32 version used W32-specific IntersectRect here, but
23915 I assume the effect is the same -- and this is portable. */
23916 return x_intersect_rectangles (&cr, r, &result);
23918 /* If we don't understand the format, pretend we're not in the hot-spot. */
23919 return 0;
23923 /* EXPORT:
23924 Draw a vertical window border to the right of window W if W doesn't
23925 have vertical scroll bars. */
23927 void
23928 x_draw_vertical_border (w)
23929 struct window *w;
23931 struct frame *f = XFRAME (WINDOW_FRAME (w));
23933 /* We could do better, if we knew what type of scroll-bar the adjacent
23934 windows (on either side) have... But we don't :-(
23935 However, I think this works ok. ++KFS 2003-04-25 */
23937 /* Redraw borders between horizontally adjacent windows. Don't
23938 do it for frames with vertical scroll bars because either the
23939 right scroll bar of a window, or the left scroll bar of its
23940 neighbor will suffice as a border. */
23941 if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w->frame)))
23942 return;
23944 if (!WINDOW_RIGHTMOST_P (w)
23945 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
23947 int x0, x1, y0, y1;
23949 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
23950 y1 -= 1;
23952 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
23953 x1 -= 1;
23955 FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
23957 else if (!WINDOW_LEFTMOST_P (w)
23958 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
23960 int x0, x1, y0, y1;
23962 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
23963 y1 -= 1;
23965 if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
23966 x0 -= 1;
23968 FRAME_RIF (f)->draw_vertical_window_border (w, x0, y0, y1);
23973 /* Redraw the part of window W intersection rectangle FR. Pixel
23974 coordinates in FR are frame-relative. Call this function with
23975 input blocked. Value is non-zero if the exposure overwrites
23976 mouse-face. */
23978 static int
23979 expose_window (w, fr)
23980 struct window *w;
23981 XRectangle *fr;
23983 struct frame *f = XFRAME (w->frame);
23984 XRectangle wr, r;
23985 int mouse_face_overwritten_p = 0;
23987 /* If window is not yet fully initialized, do nothing. This can
23988 happen when toolkit scroll bars are used and a window is split.
23989 Reconfiguring the scroll bar will generate an expose for a newly
23990 created window. */
23991 if (w->current_matrix == NULL)
23992 return 0;
23994 /* When we're currently updating the window, display and current
23995 matrix usually don't agree. Arrange for a thorough display
23996 later. */
23997 if (w == updated_window)
23999 SET_FRAME_GARBAGED (f);
24000 return 0;
24003 /* Frame-relative pixel rectangle of W. */
24004 wr.x = WINDOW_LEFT_EDGE_X (w);
24005 wr.y = WINDOW_TOP_EDGE_Y (w);
24006 wr.width = WINDOW_TOTAL_WIDTH (w);
24007 wr.height = WINDOW_TOTAL_HEIGHT (w);
24009 if (x_intersect_rectangles (fr, &wr, &r))
24011 int yb = window_text_bottom_y (w);
24012 struct glyph_row *row;
24013 int cursor_cleared_p;
24014 struct glyph_row *first_overlapping_row, *last_overlapping_row;
24016 TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
24017 r.x, r.y, r.width, r.height));
24019 /* Convert to window coordinates. */
24020 r.x -= WINDOW_LEFT_EDGE_X (w);
24021 r.y -= WINDOW_TOP_EDGE_Y (w);
24023 /* Turn off the cursor. */
24024 if (!w->pseudo_window_p
24025 && phys_cursor_in_rect_p (w, &r))
24027 x_clear_cursor (w);
24028 cursor_cleared_p = 1;
24030 else
24031 cursor_cleared_p = 0;
24033 /* Update lines intersecting rectangle R. */
24034 first_overlapping_row = last_overlapping_row = NULL;
24035 for (row = w->current_matrix->rows;
24036 row->enabled_p;
24037 ++row)
24039 int y0 = row->y;
24040 int y1 = MATRIX_ROW_BOTTOM_Y (row);
24042 if ((y0 >= r.y && y0 < r.y + r.height)
24043 || (y1 > r.y && y1 < r.y + r.height)
24044 || (r.y >= y0 && r.y < y1)
24045 || (r.y + r.height > y0 && r.y + r.height < y1))
24047 /* A header line may be overlapping, but there is no need
24048 to fix overlapping areas for them. KFS 2005-02-12 */
24049 if (row->overlapping_p && !row->mode_line_p)
24051 if (first_overlapping_row == NULL)
24052 first_overlapping_row = row;
24053 last_overlapping_row = row;
24056 row->clip = fr;
24057 if (expose_line (w, row, &r))
24058 mouse_face_overwritten_p = 1;
24059 row->clip = NULL;
24061 else if (row->overlapping_p)
24063 /* We must redraw a row overlapping the exposed area. */
24064 if (y0 < r.y
24065 ? y0 + row->phys_height > r.y
24066 : y0 + row->ascent - row->phys_ascent < r.y +r.height)
24068 if (first_overlapping_row == NULL)
24069 first_overlapping_row = row;
24070 last_overlapping_row = row;
24074 if (y1 >= yb)
24075 break;
24078 /* Display the mode line if there is one. */
24079 if (WINDOW_WANTS_MODELINE_P (w)
24080 && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
24081 row->enabled_p)
24082 && row->y < r.y + r.height)
24084 if (expose_line (w, row, &r))
24085 mouse_face_overwritten_p = 1;
24088 if (!w->pseudo_window_p)
24090 /* Fix the display of overlapping rows. */
24091 if (first_overlapping_row)
24092 expose_overlaps (w, first_overlapping_row, last_overlapping_row,
24093 fr);
24095 /* Draw border between windows. */
24096 x_draw_vertical_border (w);
24098 /* Turn the cursor on again. */
24099 if (cursor_cleared_p)
24100 update_window_cursor (w, 1);
24104 return mouse_face_overwritten_p;
24109 /* Redraw (parts) of all windows in the window tree rooted at W that
24110 intersect R. R contains frame pixel coordinates. Value is
24111 non-zero if the exposure overwrites mouse-face. */
24113 static int
24114 expose_window_tree (w, r)
24115 struct window *w;
24116 XRectangle *r;
24118 struct frame *f = XFRAME (w->frame);
24119 int mouse_face_overwritten_p = 0;
24121 while (w && !FRAME_GARBAGED_P (f))
24123 if (!NILP (w->hchild))
24124 mouse_face_overwritten_p
24125 |= expose_window_tree (XWINDOW (w->hchild), r);
24126 else if (!NILP (w->vchild))
24127 mouse_face_overwritten_p
24128 |= expose_window_tree (XWINDOW (w->vchild), r);
24129 else
24130 mouse_face_overwritten_p |= expose_window (w, r);
24132 w = NILP (w->next) ? NULL : XWINDOW (w->next);
24135 return mouse_face_overwritten_p;
24139 /* EXPORT:
24140 Redisplay an exposed area of frame F. X and Y are the upper-left
24141 corner of the exposed rectangle. W and H are width and height of
24142 the exposed area. All are pixel values. W or H zero means redraw
24143 the entire frame. */
24145 void
24146 expose_frame (f, x, y, w, h)
24147 struct frame *f;
24148 int x, y, w, h;
24150 XRectangle r;
24151 int mouse_face_overwritten_p = 0;
24153 TRACE ((stderr, "expose_frame "));
24155 /* No need to redraw if frame will be redrawn soon. */
24156 if (FRAME_GARBAGED_P (f))
24158 TRACE ((stderr, " garbaged\n"));
24159 return;
24162 /* If basic faces haven't been realized yet, there is no point in
24163 trying to redraw anything. This can happen when we get an expose
24164 event while Emacs is starting, e.g. by moving another window. */
24165 if (FRAME_FACE_CACHE (f) == NULL
24166 || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
24168 TRACE ((stderr, " no faces\n"));
24169 return;
24172 if (w == 0 || h == 0)
24174 r.x = r.y = 0;
24175 r.width = FRAME_COLUMN_WIDTH (f) * FRAME_COLS (f);
24176 r.height = FRAME_LINE_HEIGHT (f) * FRAME_LINES (f);
24178 else
24180 r.x = x;
24181 r.y = y;
24182 r.width = w;
24183 r.height = h;
24186 TRACE ((stderr, "(%d, %d, %d, %d)\n", r.x, r.y, r.width, r.height));
24187 mouse_face_overwritten_p = expose_window_tree (XWINDOW (f->root_window), &r);
24189 if (WINDOWP (f->tool_bar_window))
24190 mouse_face_overwritten_p
24191 |= expose_window (XWINDOW (f->tool_bar_window), &r);
24193 #ifdef HAVE_X_WINDOWS
24194 #ifndef MSDOS
24195 #ifndef USE_X_TOOLKIT
24196 if (WINDOWP (f->menu_bar_window))
24197 mouse_face_overwritten_p
24198 |= expose_window (XWINDOW (f->menu_bar_window), &r);
24199 #endif /* not USE_X_TOOLKIT */
24200 #endif
24201 #endif
24203 /* Some window managers support a focus-follows-mouse style with
24204 delayed raising of frames. Imagine a partially obscured frame,
24205 and moving the mouse into partially obscured mouse-face on that
24206 frame. The visible part of the mouse-face will be highlighted,
24207 then the WM raises the obscured frame. With at least one WM, KDE
24208 2.1, Emacs is not getting any event for the raising of the frame
24209 (even tried with SubstructureRedirectMask), only Expose events.
24210 These expose events will draw text normally, i.e. not
24211 highlighted. Which means we must redo the highlight here.
24212 Subsume it under ``we love X''. --gerd 2001-08-15 */
24213 /* Included in Windows version because Windows most likely does not
24214 do the right thing if any third party tool offers
24215 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
24216 if (mouse_face_overwritten_p && !FRAME_GARBAGED_P (f))
24218 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
24219 if (f == dpyinfo->mouse_face_mouse_frame)
24221 int x = dpyinfo->mouse_face_mouse_x;
24222 int y = dpyinfo->mouse_face_mouse_y;
24223 clear_mouse_face (dpyinfo);
24224 note_mouse_highlight (f, x, y);
24230 /* EXPORT:
24231 Determine the intersection of two rectangles R1 and R2. Return
24232 the intersection in *RESULT. Value is non-zero if RESULT is not
24233 empty. */
24236 x_intersect_rectangles (r1, r2, result)
24237 XRectangle *r1, *r2, *result;
24239 XRectangle *left, *right;
24240 XRectangle *upper, *lower;
24241 int intersection_p = 0;
24243 /* Rearrange so that R1 is the left-most rectangle. */
24244 if (r1->x < r2->x)
24245 left = r1, right = r2;
24246 else
24247 left = r2, right = r1;
24249 /* X0 of the intersection is right.x0, if this is inside R1,
24250 otherwise there is no intersection. */
24251 if (right->x <= left->x + left->width)
24253 result->x = right->x;
24255 /* The right end of the intersection is the minimum of the
24256 the right ends of left and right. */
24257 result->width = (min (left->x + left->width, right->x + right->width)
24258 - result->x);
24260 /* Same game for Y. */
24261 if (r1->y < r2->y)
24262 upper = r1, lower = r2;
24263 else
24264 upper = r2, lower = r1;
24266 /* The upper end of the intersection is lower.y0, if this is inside
24267 of upper. Otherwise, there is no intersection. */
24268 if (lower->y <= upper->y + upper->height)
24270 result->y = lower->y;
24272 /* The lower end of the intersection is the minimum of the lower
24273 ends of upper and lower. */
24274 result->height = (min (lower->y + lower->height,
24275 upper->y + upper->height)
24276 - result->y);
24277 intersection_p = 1;
24281 return intersection_p;
24284 #endif /* HAVE_WINDOW_SYSTEM */
24287 /***********************************************************************
24288 Initialization
24289 ***********************************************************************/
24291 void
24292 syms_of_xdisp ()
24294 Vwith_echo_area_save_vector = Qnil;
24295 staticpro (&Vwith_echo_area_save_vector);
24297 Vmessage_stack = Qnil;
24298 staticpro (&Vmessage_stack);
24300 Qinhibit_redisplay = intern ("inhibit-redisplay");
24301 staticpro (&Qinhibit_redisplay);
24303 message_dolog_marker1 = Fmake_marker ();
24304 staticpro (&message_dolog_marker1);
24305 message_dolog_marker2 = Fmake_marker ();
24306 staticpro (&message_dolog_marker2);
24307 message_dolog_marker3 = Fmake_marker ();
24308 staticpro (&message_dolog_marker3);
24310 #if GLYPH_DEBUG
24311 defsubr (&Sdump_frame_glyph_matrix);
24312 defsubr (&Sdump_glyph_matrix);
24313 defsubr (&Sdump_glyph_row);
24314 defsubr (&Sdump_tool_bar_row);
24315 defsubr (&Strace_redisplay);
24316 defsubr (&Strace_to_stderr);
24317 #endif
24318 #ifdef HAVE_WINDOW_SYSTEM
24319 defsubr (&Stool_bar_lines_needed);
24320 defsubr (&Slookup_image_map);
24321 #endif
24322 defsubr (&Sformat_mode_line);
24323 defsubr (&Sinvisible_p);
24325 staticpro (&Qmenu_bar_update_hook);
24326 Qmenu_bar_update_hook = intern ("menu-bar-update-hook");
24328 staticpro (&Qoverriding_terminal_local_map);
24329 Qoverriding_terminal_local_map = intern ("overriding-terminal-local-map");
24331 staticpro (&Qoverriding_local_map);
24332 Qoverriding_local_map = intern ("overriding-local-map");
24334 staticpro (&Qwindow_scroll_functions);
24335 Qwindow_scroll_functions = intern ("window-scroll-functions");
24337 staticpro (&Qwindow_text_change_functions);
24338 Qwindow_text_change_functions = intern ("window-text-change-functions");
24340 staticpro (&Qredisplay_end_trigger_functions);
24341 Qredisplay_end_trigger_functions = intern ("redisplay-end-trigger-functions");
24343 staticpro (&Qinhibit_point_motion_hooks);
24344 Qinhibit_point_motion_hooks = intern ("inhibit-point-motion-hooks");
24346 QCdata = intern (":data");
24347 staticpro (&QCdata);
24348 Qdisplay = intern ("display");
24349 staticpro (&Qdisplay);
24350 Qspace_width = intern ("space-width");
24351 staticpro (&Qspace_width);
24352 Qraise = intern ("raise");
24353 staticpro (&Qraise);
24354 Qslice = intern ("slice");
24355 staticpro (&Qslice);
24356 Qspace = intern ("space");
24357 staticpro (&Qspace);
24358 Qmargin = intern ("margin");
24359 staticpro (&Qmargin);
24360 Qpointer = intern ("pointer");
24361 staticpro (&Qpointer);
24362 Qleft_margin = intern ("left-margin");
24363 staticpro (&Qleft_margin);
24364 Qright_margin = intern ("right-margin");
24365 staticpro (&Qright_margin);
24366 Qcenter = intern ("center");
24367 staticpro (&Qcenter);
24368 Qline_height = intern ("line-height");
24369 staticpro (&Qline_height);
24370 QCalign_to = intern (":align-to");
24371 staticpro (&QCalign_to);
24372 QCrelative_width = intern (":relative-width");
24373 staticpro (&QCrelative_width);
24374 QCrelative_height = intern (":relative-height");
24375 staticpro (&QCrelative_height);
24376 QCeval = intern (":eval");
24377 staticpro (&QCeval);
24378 QCpropertize = intern (":propertize");
24379 staticpro (&QCpropertize);
24380 QCfile = intern (":file");
24381 staticpro (&QCfile);
24382 Qfontified = intern ("fontified");
24383 staticpro (&Qfontified);
24384 Qfontification_functions = intern ("fontification-functions");
24385 staticpro (&Qfontification_functions);
24386 Qtrailing_whitespace = intern ("trailing-whitespace");
24387 staticpro (&Qtrailing_whitespace);
24388 Qescape_glyph = intern ("escape-glyph");
24389 staticpro (&Qescape_glyph);
24390 Qnobreak_space = intern ("nobreak-space");
24391 staticpro (&Qnobreak_space);
24392 Qimage = intern ("image");
24393 staticpro (&Qimage);
24394 QCmap = intern (":map");
24395 staticpro (&QCmap);
24396 QCpointer = intern (":pointer");
24397 staticpro (&QCpointer);
24398 Qrect = intern ("rect");
24399 staticpro (&Qrect);
24400 Qcircle = intern ("circle");
24401 staticpro (&Qcircle);
24402 Qpoly = intern ("poly");
24403 staticpro (&Qpoly);
24404 Qmessage_truncate_lines = intern ("message-truncate-lines");
24405 staticpro (&Qmessage_truncate_lines);
24406 Qgrow_only = intern ("grow-only");
24407 staticpro (&Qgrow_only);
24408 Qinhibit_menubar_update = intern ("inhibit-menubar-update");
24409 staticpro (&Qinhibit_menubar_update);
24410 Qinhibit_eval_during_redisplay = intern ("inhibit-eval-during-redisplay");
24411 staticpro (&Qinhibit_eval_during_redisplay);
24412 Qposition = intern ("position");
24413 staticpro (&Qposition);
24414 Qbuffer_position = intern ("buffer-position");
24415 staticpro (&Qbuffer_position);
24416 Qobject = intern ("object");
24417 staticpro (&Qobject);
24418 Qbar = intern ("bar");
24419 staticpro (&Qbar);
24420 Qhbar = intern ("hbar");
24421 staticpro (&Qhbar);
24422 Qbox = intern ("box");
24423 staticpro (&Qbox);
24424 Qhollow = intern ("hollow");
24425 staticpro (&Qhollow);
24426 Qhand = intern ("hand");
24427 staticpro (&Qhand);
24428 Qarrow = intern ("arrow");
24429 staticpro (&Qarrow);
24430 Qtext = intern ("text");
24431 staticpro (&Qtext);
24432 Qrisky_local_variable = intern ("risky-local-variable");
24433 staticpro (&Qrisky_local_variable);
24434 Qinhibit_free_realized_faces = intern ("inhibit-free-realized-faces");
24435 staticpro (&Qinhibit_free_realized_faces);
24437 list_of_error = Fcons (Fcons (intern ("error"),
24438 Fcons (intern ("void-variable"), Qnil)),
24439 Qnil);
24440 staticpro (&list_of_error);
24442 Qlast_arrow_position = intern ("last-arrow-position");
24443 staticpro (&Qlast_arrow_position);
24444 Qlast_arrow_string = intern ("last-arrow-string");
24445 staticpro (&Qlast_arrow_string);
24447 Qoverlay_arrow_string = intern ("overlay-arrow-string");
24448 staticpro (&Qoverlay_arrow_string);
24449 Qoverlay_arrow_bitmap = intern ("overlay-arrow-bitmap");
24450 staticpro (&Qoverlay_arrow_bitmap);
24452 echo_buffer[0] = echo_buffer[1] = Qnil;
24453 staticpro (&echo_buffer[0]);
24454 staticpro (&echo_buffer[1]);
24456 echo_area_buffer[0] = echo_area_buffer[1] = Qnil;
24457 staticpro (&echo_area_buffer[0]);
24458 staticpro (&echo_area_buffer[1]);
24460 Vmessages_buffer_name = build_string ("*Messages*");
24461 staticpro (&Vmessages_buffer_name);
24463 mode_line_proptrans_alist = Qnil;
24464 staticpro (&mode_line_proptrans_alist);
24465 mode_line_string_list = Qnil;
24466 staticpro (&mode_line_string_list);
24467 mode_line_string_face = Qnil;
24468 staticpro (&mode_line_string_face);
24469 mode_line_string_face_prop = Qnil;
24470 staticpro (&mode_line_string_face_prop);
24471 Vmode_line_unwind_vector = Qnil;
24472 staticpro (&Vmode_line_unwind_vector);
24474 help_echo_string = Qnil;
24475 staticpro (&help_echo_string);
24476 help_echo_object = Qnil;
24477 staticpro (&help_echo_object);
24478 help_echo_window = Qnil;
24479 staticpro (&help_echo_window);
24480 previous_help_echo_string = Qnil;
24481 staticpro (&previous_help_echo_string);
24482 help_echo_pos = -1;
24484 #ifdef HAVE_WINDOW_SYSTEM
24485 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
24486 doc: /* *Non-nil means draw block cursor as wide as the glyph under it.
24487 For example, if a block cursor is over a tab, it will be drawn as
24488 wide as that tab on the display. */);
24489 x_stretch_cursor_p = 0;
24490 #endif
24492 DEFVAR_LISP ("show-trailing-whitespace", &Vshow_trailing_whitespace,
24493 doc: /* *Non-nil means highlight trailing whitespace.
24494 The face used for trailing whitespace is `trailing-whitespace'. */);
24495 Vshow_trailing_whitespace = Qnil;
24497 DEFVAR_LISP ("nobreak-char-display", &Vnobreak_char_display,
24498 doc: /* *Control highlighting of nobreak space and soft hyphen.
24499 A value of t means highlight the character itself (for nobreak space,
24500 use face `nobreak-space').
24501 A value of nil means no highlighting.
24502 Other values mean display the escape glyph followed by an ordinary
24503 space or ordinary hyphen. */);
24504 Vnobreak_char_display = Qt;
24506 DEFVAR_LISP ("void-text-area-pointer", &Vvoid_text_area_pointer,
24507 doc: /* *The pointer shape to show in void text areas.
24508 A value of nil means to show the text pointer. Other options are `arrow',
24509 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'. */);
24510 Vvoid_text_area_pointer = Qarrow;
24512 DEFVAR_LISP ("inhibit-redisplay", &Vinhibit_redisplay,
24513 doc: /* Non-nil means don't actually do any redisplay.
24514 This is used for internal purposes. */);
24515 Vinhibit_redisplay = Qnil;
24517 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string,
24518 doc: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
24519 Vglobal_mode_string = Qnil;
24521 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position,
24522 doc: /* Marker for where to display an arrow on top of the buffer text.
24523 This must be the beginning of a line in order to work.
24524 See also `overlay-arrow-string'. */);
24525 Voverlay_arrow_position = Qnil;
24527 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string,
24528 doc: /* String to display as an arrow in non-window frames.
24529 See also `overlay-arrow-position'. */);
24530 Voverlay_arrow_string = build_string ("=>");
24532 DEFVAR_LISP ("overlay-arrow-variable-list", &Voverlay_arrow_variable_list,
24533 doc: /* List of variables (symbols) which hold markers for overlay arrows.
24534 The symbols on this list are examined during redisplay to determine
24535 where to display overlay arrows. */);
24536 Voverlay_arrow_variable_list
24537 = Fcons (intern ("overlay-arrow-position"), Qnil);
24539 DEFVAR_INT ("scroll-step", &scroll_step,
24540 doc: /* *The number of lines to try scrolling a window by when point moves out.
24541 If that fails to bring point back on frame, point is centered instead.
24542 If this is zero, point is always centered after it moves off frame.
24543 If you want scrolling to always be a line at a time, you should set
24544 `scroll-conservatively' to a large value rather than set this to 1. */);
24546 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively,
24547 doc: /* *Scroll up to this many lines, to bring point back on screen.
24548 If point moves off-screen, redisplay will scroll by up to
24549 `scroll-conservatively' lines in order to bring point just barely
24550 onto the screen again. If that cannot be done, then redisplay
24551 recenters point as usual.
24553 A value of zero means always recenter point if it moves off screen. */);
24554 scroll_conservatively = 0;
24556 DEFVAR_INT ("scroll-margin", &scroll_margin,
24557 doc: /* *Number of lines of margin at the top and bottom of a window.
24558 Recenter the window whenever point gets within this many lines
24559 of the top or bottom of the window. */);
24560 scroll_margin = 0;
24562 DEFVAR_LISP ("display-pixels-per-inch", &Vdisplay_pixels_per_inch,
24563 doc: /* Pixels per inch value for non-window system displays.
24564 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI). */);
24565 Vdisplay_pixels_per_inch = make_float (72.0);
24567 #if GLYPH_DEBUG
24568 DEFVAR_INT ("debug-end-pos", &debug_end_pos, doc: /* Don't ask. */);
24569 #endif
24571 DEFVAR_BOOL ("truncate-partial-width-windows",
24572 &truncate_partial_width_windows,
24573 doc: /* *Non-nil means truncate lines in all windows less than full frame wide. */);
24574 truncate_partial_width_windows = 1;
24576 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video,
24577 doc: /* When nil, display the mode-line/header-line/menu-bar in the default face.
24578 Any other value means to use the appropriate face, `mode-line',
24579 `header-line', or `menu' respectively. */);
24580 mode_line_inverse_video = 1;
24582 DEFVAR_LISP ("line-number-display-limit", &Vline_number_display_limit,
24583 doc: /* *Maximum buffer size for which line number should be displayed.
24584 If the buffer is bigger than this, the line number does not appear
24585 in the mode line. A value of nil means no limit. */);
24586 Vline_number_display_limit = Qnil;
24588 DEFVAR_INT ("line-number-display-limit-width",
24589 &line_number_display_limit_width,
24590 doc: /* *Maximum line width (in characters) for line number display.
24591 If the average length of the lines near point is bigger than this, then the
24592 line number may be omitted from the mode line. */);
24593 line_number_display_limit_width = 200;
24595 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows,
24596 doc: /* *Non-nil means highlight region even in nonselected windows. */);
24597 highlight_nonselected_windows = 0;
24599 DEFVAR_BOOL ("multiple-frames", &multiple_frames,
24600 doc: /* Non-nil if more than one frame is visible on this display.
24601 Minibuffer-only frames don't count, but iconified frames do.
24602 This variable is not guaranteed to be accurate except while processing
24603 `frame-title-format' and `icon-title-format'. */);
24605 DEFVAR_LISP ("frame-title-format", &Vframe_title_format,
24606 doc: /* Template for displaying the title bar of visible frames.
24607 \(Assuming the window manager supports this feature.)
24609 This variable has the same structure as `mode-line-format', except that
24610 the %c and %l constructs are ignored. It is used only on frames for
24611 which no explicit name has been set \(see `modify-frame-parameters'). */);
24613 DEFVAR_LISP ("icon-title-format", &Vicon_title_format,
24614 doc: /* Template for displaying the title bar of an iconified frame.
24615 \(Assuming the window manager supports this feature.)
24616 This variable has the same structure as `mode-line-format' (which see),
24617 and is used only on frames for which no explicit name has been set
24618 \(see `modify-frame-parameters'). */);
24619 Vicon_title_format
24620 = Vframe_title_format
24621 = Fcons (intern ("multiple-frames"),
24622 Fcons (build_string ("%b"),
24623 Fcons (Fcons (empty_unibyte_string,
24624 Fcons (intern ("invocation-name"),
24625 Fcons (build_string ("@"),
24626 Fcons (intern ("system-name"),
24627 Qnil)))),
24628 Qnil)));
24630 DEFVAR_LISP ("message-log-max", &Vmessage_log_max,
24631 doc: /* Maximum number of lines to keep in the message log buffer.
24632 If nil, disable message logging. If t, log messages but don't truncate
24633 the buffer when it becomes large. */);
24634 Vmessage_log_max = make_number (100);
24636 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions,
24637 doc: /* Functions called before redisplay, if window sizes have changed.
24638 The value should be a list of functions that take one argument.
24639 Just before redisplay, for each frame, if any of its windows have changed
24640 size since the last redisplay, or have been split or deleted,
24641 all the functions in the list are called, with the frame as argument. */);
24642 Vwindow_size_change_functions = Qnil;
24644 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions,
24645 doc: /* List of functions to call before redisplaying a window with scrolling.
24646 Each function is called with two arguments, the window
24647 and its new display-start position. Note that the value of `window-end'
24648 is not valid when these functions are called. */);
24649 Vwindow_scroll_functions = Qnil;
24651 DEFVAR_LISP ("window-text-change-functions",
24652 &Vwindow_text_change_functions,
24653 doc: /* Functions to call in redisplay when text in the window might change. */);
24654 Vwindow_text_change_functions = Qnil;
24656 DEFVAR_LISP ("redisplay-end-trigger-functions", &Vredisplay_end_trigger_functions,
24657 doc: /* Functions called when redisplay of a window reaches the end trigger.
24658 Each function is called with two arguments, the window and the end trigger value.
24659 See `set-window-redisplay-end-trigger'. */);
24660 Vredisplay_end_trigger_functions = Qnil;
24662 DEFVAR_LISP ("mouse-autoselect-window", &Vmouse_autoselect_window,
24663 doc: /* *Non-nil means autoselect window with mouse pointer.
24664 If nil, do not autoselect windows.
24665 A positive number means delay autoselection by that many seconds: a
24666 window is autoselected only after the mouse has remained in that
24667 window for the duration of the delay.
24668 A negative number has a similar effect, but causes windows to be
24669 autoselected only after the mouse has stopped moving. \(Because of
24670 the way Emacs compares mouse events, you will occasionally wait twice
24671 that time before the window gets selected.\)
24672 Any other value means to autoselect window instantaneously when the
24673 mouse pointer enters it.
24675 Autoselection selects the minibuffer only if it is active, and never
24676 unselects the minibuffer if it is active.
24678 When customizing this variable make sure that the actual value of
24679 `focus-follows-mouse' matches the behavior of your window manager. */);
24680 Vmouse_autoselect_window = Qnil;
24682 DEFVAR_LISP ("auto-resize-tool-bars", &Vauto_resize_tool_bars,
24683 doc: /* *Non-nil means automatically resize tool-bars.
24684 This dynamically changes the tool-bar's height to the minimum height
24685 that is needed to make all tool-bar items visible.
24686 If value is `grow-only', the tool-bar's height is only increased
24687 automatically; to decrease the tool-bar height, use \\[recenter]. */);
24688 Vauto_resize_tool_bars = Qt;
24690 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", &auto_raise_tool_bar_buttons_p,
24691 doc: /* *Non-nil means raise tool-bar buttons when the mouse moves over them. */);
24692 auto_raise_tool_bar_buttons_p = 1;
24694 DEFVAR_BOOL ("make-cursor-line-fully-visible", &make_cursor_line_fully_visible_p,
24695 doc: /* *Non-nil means to scroll (recenter) cursor line if it is not fully visible. */);
24696 make_cursor_line_fully_visible_p = 1;
24698 DEFVAR_LISP ("tool-bar-border", &Vtool_bar_border,
24699 doc: /* *Border below tool-bar in pixels.
24700 If an integer, use it as the height of the border.
24701 If it is one of `internal-border-width' or `border-width', use the
24702 value of the corresponding frame parameter.
24703 Otherwise, no border is added below the tool-bar. */);
24704 Vtool_bar_border = Qinternal_border_width;
24706 DEFVAR_LISP ("tool-bar-button-margin", &Vtool_bar_button_margin,
24707 doc: /* *Margin around tool-bar buttons in pixels.
24708 If an integer, use that for both horizontal and vertical margins.
24709 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
24710 HORZ specifying the horizontal margin, and VERT specifying the
24711 vertical margin. */);
24712 Vtool_bar_button_margin = make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
24714 DEFVAR_INT ("tool-bar-button-relief", &tool_bar_button_relief,
24715 doc: /* *Relief thickness of tool-bar buttons. */);
24716 tool_bar_button_relief = DEFAULT_TOOL_BAR_BUTTON_RELIEF;
24718 DEFVAR_LISP ("fontification-functions", &Vfontification_functions,
24719 doc: /* List of functions to call to fontify regions of text.
24720 Each function is called with one argument POS. Functions must
24721 fontify a region starting at POS in the current buffer, and give
24722 fontified regions the property `fontified'. */);
24723 Vfontification_functions = Qnil;
24724 Fmake_variable_buffer_local (Qfontification_functions);
24726 DEFVAR_BOOL ("unibyte-display-via-language-environment",
24727 &unibyte_display_via_language_environment,
24728 doc: /* *Non-nil means display unibyte text according to language environment.
24729 Specifically this means that unibyte non-ASCII characters
24730 are displayed by converting them to the equivalent multibyte characters
24731 according to the current language environment. As a result, they are
24732 displayed according to the current fontset. */);
24733 unibyte_display_via_language_environment = 0;
24735 DEFVAR_LISP ("max-mini-window-height", &Vmax_mini_window_height,
24736 doc: /* *Maximum height for resizing mini-windows.
24737 If a float, it specifies a fraction of the mini-window frame's height.
24738 If an integer, it specifies a number of lines. */);
24739 Vmax_mini_window_height = make_float (0.25);
24741 DEFVAR_LISP ("resize-mini-windows", &Vresize_mini_windows,
24742 doc: /* *How to resize mini-windows.
24743 A value of nil means don't automatically resize mini-windows.
24744 A value of t means resize them to fit the text displayed in them.
24745 A value of `grow-only', the default, means let mini-windows grow
24746 only, until their display becomes empty, at which point the windows
24747 go back to their normal size. */);
24748 Vresize_mini_windows = Qgrow_only;
24750 DEFVAR_LISP ("blink-cursor-alist", &Vblink_cursor_alist,
24751 doc: /* Alist specifying how to blink the cursor off.
24752 Each element has the form (ON-STATE . OFF-STATE). Whenever the
24753 `cursor-type' frame-parameter or variable equals ON-STATE,
24754 comparing using `equal', Emacs uses OFF-STATE to specify
24755 how to blink it off. ON-STATE and OFF-STATE are values for
24756 the `cursor-type' frame parameter.
24758 If a frame's ON-STATE has no entry in this list,
24759 the frame's other specifications determine how to blink the cursor off. */);
24760 Vblink_cursor_alist = Qnil;
24762 DEFVAR_BOOL ("auto-hscroll-mode", &automatic_hscrolling_p,
24763 doc: /* *Non-nil means scroll the display automatically to make point visible. */);
24764 automatic_hscrolling_p = 1;
24765 Qauto_hscroll_mode = intern ("auto-hscroll-mode");
24766 staticpro (&Qauto_hscroll_mode);
24768 DEFVAR_INT ("hscroll-margin", &hscroll_margin,
24769 doc: /* *How many columns away from the window edge point is allowed to get
24770 before automatic hscrolling will horizontally scroll the window. */);
24771 hscroll_margin = 5;
24773 DEFVAR_LISP ("hscroll-step", &Vhscroll_step,
24774 doc: /* *How many columns to scroll the window when point gets too close to the edge.
24775 When point is less than `hscroll-margin' columns from the window
24776 edge, automatic hscrolling will scroll the window by the amount of columns
24777 determined by this variable. If its value is a positive integer, scroll that
24778 many columns. If it's a positive floating-point number, it specifies the
24779 fraction of the window's width to scroll. If it's nil or zero, point will be
24780 centered horizontally after the scroll. Any other value, including negative
24781 numbers, are treated as if the value were zero.
24783 Automatic hscrolling always moves point outside the scroll margin, so if
24784 point was more than scroll step columns inside the margin, the window will
24785 scroll more than the value given by the scroll step.
24787 Note that the lower bound for automatic hscrolling specified by `scroll-left'
24788 and `scroll-right' overrides this variable's effect. */);
24789 Vhscroll_step = make_number (0);
24791 DEFVAR_BOOL ("message-truncate-lines", &message_truncate_lines,
24792 doc: /* If non-nil, messages are truncated instead of resizing the echo area.
24793 Bind this around calls to `message' to let it take effect. */);
24794 message_truncate_lines = 0;
24796 DEFVAR_LISP ("menu-bar-update-hook", &Vmenu_bar_update_hook,
24797 doc: /* Normal hook run to update the menu bar definitions.
24798 Redisplay runs this hook before it redisplays the menu bar.
24799 This is used to update submenus such as Buffers,
24800 whose contents depend on various data. */);
24801 Vmenu_bar_update_hook = Qnil;
24803 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame,
24804 doc: /* Frame for which we are updating a menu.
24805 The enable predicate for a menu binding should check this variable. */);
24806 Vmenu_updating_frame = Qnil;
24808 DEFVAR_BOOL ("inhibit-menubar-update", &inhibit_menubar_update,
24809 doc: /* Non-nil means don't update menu bars. Internal use only. */);
24810 inhibit_menubar_update = 0;
24812 DEFVAR_BOOL ("inhibit-eval-during-redisplay", &inhibit_eval_during_redisplay,
24813 doc: /* Non-nil means don't eval Lisp during redisplay. */);
24814 inhibit_eval_during_redisplay = 0;
24816 DEFVAR_BOOL ("inhibit-free-realized-faces", &inhibit_free_realized_faces,
24817 doc: /* Non-nil means don't free realized faces. Internal use only. */);
24818 inhibit_free_realized_faces = 0;
24820 #if GLYPH_DEBUG
24821 DEFVAR_BOOL ("inhibit-try-window-id", &inhibit_try_window_id,
24822 doc: /* Inhibit try_window_id display optimization. */);
24823 inhibit_try_window_id = 0;
24825 DEFVAR_BOOL ("inhibit-try-window-reusing", &inhibit_try_window_reusing,
24826 doc: /* Inhibit try_window_reusing display optimization. */);
24827 inhibit_try_window_reusing = 0;
24829 DEFVAR_BOOL ("inhibit-try-cursor-movement", &inhibit_try_cursor_movement,
24830 doc: /* Inhibit try_cursor_movement display optimization. */);
24831 inhibit_try_cursor_movement = 0;
24832 #endif /* GLYPH_DEBUG */
24834 DEFVAR_INT ("overline-margin", &overline_margin,
24835 doc: /* *Space between overline and text, in pixels.
24836 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
24837 margin to the caracter height. */);
24838 overline_margin = 2;
24842 /* Initialize this module when Emacs starts. */
24844 void
24845 init_xdisp ()
24847 Lisp_Object root_window;
24848 struct window *mini_w;
24850 current_header_line_height = current_mode_line_height = -1;
24852 CHARPOS (this_line_start_pos) = 0;
24854 mini_w = XWINDOW (minibuf_window);
24855 root_window = FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w)));
24857 if (!noninteractive)
24859 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (root_window)));
24860 int i;
24862 XWINDOW (root_window)->top_line = make_number (FRAME_TOP_MARGIN (f));
24863 set_window_height (root_window,
24864 FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f),
24866 mini_w->top_line = make_number (FRAME_LINES (f) - 1);
24867 set_window_height (minibuf_window, 1, 0);
24869 XWINDOW (root_window)->total_cols = make_number (FRAME_COLS (f));
24870 mini_w->total_cols = make_number (FRAME_COLS (f));
24872 scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
24873 scratch_glyph_row.glyphs[TEXT_AREA + 1]
24874 = scratch_glyphs + MAX_SCRATCH_GLYPHS;
24876 /* The default ellipsis glyphs `...'. */
24877 for (i = 0; i < 3; ++i)
24878 default_invis_vector[i] = make_number ('.');
24882 /* Allocate the buffer for frame titles.
24883 Also used for `format-mode-line'. */
24884 int size = 100;
24885 mode_line_noprop_buf = (char *) xmalloc (size);
24886 mode_line_noprop_buf_end = mode_line_noprop_buf + size;
24887 mode_line_noprop_ptr = mode_line_noprop_buf;
24888 mode_line_target = MODE_LINE_DISPLAY;
24891 help_echo_showing_p = 0;
24895 /* arch-tag: eacc864d-bb6a-4b74-894a-1a4399a1358b
24896 (do not change this comment) */