1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 /*#include <ctype.h>*/
30 #include "dispextern.h"
37 #include "termhooks.h"
38 #include "intervals.h"
43 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
44 extern void set_frame_menubar ();
45 extern int pending_menu_activation
;
48 extern int interrupt_input
;
49 extern int command_loop_level
;
51 extern int minibuffer_auto_raise
;
53 extern Lisp_Object Qface
;
55 extern Lisp_Object Voverriding_local_map
;
56 extern Lisp_Object Voverriding_local_map_menu_flag
;
58 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
59 Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
60 Lisp_Object Qredisplay_end_trigger_functions
;
62 /* Nonzero means print newline to stdout before next minibuffer message. */
64 int noninteractive_need_newline
;
66 /* Nonzero means print newline to message log before next message. */
68 static int message_log_need_newline
;
70 #define min(a, b) ((a) < (b) ? (a) : (b))
71 #define max(a, b) ((a) > (b) ? (a) : (b))
72 #define minmax(floor, val, ceil) \
73 ((val) < (floor) ? (floor) : (val) > (ceil) ? (ceil) : (val))
75 /* The buffer position of the first character appearing
76 entirely or partially on the current frame line.
77 Or zero, which disables the optimization for the current frame line. */
78 static int this_line_bufpos
;
80 /* Number of characters past the end of this line,
81 including the terminating newline */
82 static int this_line_endpos
;
84 /* The vertical position of this frame line. */
85 static int this_line_vpos
;
87 /* Hpos value for start of display on this frame line.
88 Usually zero, but negative if first character really began
90 static int this_line_start_hpos
;
92 /* Buffer that this_line variables are describing. */
93 static struct buffer
*this_line_buffer
;
95 /* Value of echo_area_glyphs when it was last acted on.
96 If this is nonzero, there is a message on the frame
97 in the minibuffer and it should be erased as soon
98 as it is no longer requested to appear. */
99 char *previous_echo_glyphs
;
101 /* Nonzero means truncate lines in all windows less wide than the frame */
102 int truncate_partial_width_windows
;
104 /* Nonzero means we have more than one non-minibuffer-only frame.
105 Not guaranteed to be accurate except while parsing frame-title-format. */
108 Lisp_Object Vglobal_mode_string
;
110 /* Marker for where to display an arrow on top of the buffer text. */
111 Lisp_Object Voverlay_arrow_position
;
113 /* String to display for the arrow. */
114 Lisp_Object Voverlay_arrow_string
;
116 /* Like mode-line-format, but for the titlebar on a visible frame. */
117 Lisp_Object Vframe_title_format
;
119 /* Like mode-line-format, but for the titlebar on an iconified frame. */
120 Lisp_Object Vicon_title_format
;
122 /* List of functions to call when a window's size changes. These
123 functions get one arg, a frame on which one or more windows' sizes
125 static Lisp_Object Vwindow_size_change_functions
;
127 /* Values of those variables at last redisplay. */
128 static Lisp_Object last_arrow_position
, last_arrow_string
;
130 Lisp_Object Qmenu_bar_update_hook
;
132 /* Nonzero if overlay arrow has been displayed once in this window. */
133 static int overlay_arrow_seen
;
135 /* Nonzero if visible end of buffer has already been displayed once
136 in this window. (We need this variable in case there are overlay
137 strings that get displayed there.) */
138 static int zv_strings_seen
;
140 /* Nonzero means highlight the region even in nonselected windows. */
141 static int highlight_nonselected_windows
;
143 /* If cursor motion alone moves point off frame,
144 Try scrolling this many lines up or down if that will bring it back. */
145 static int scroll_step
;
147 /* Non-0 means scroll just far enough to bring point back on the screen,
149 static int scroll_conservatively
;
151 /* Recenter the window whenever point gets within this many lines
152 of the top or bottom of the window. */
155 /* Nonzero if try_window_id has made blank lines at window bottom
156 since the last redisplay that paused */
157 static int blank_end_of_window
;
159 /* Number of windows showing the buffer of the selected window
160 (or another buffer with the same base buffer).
161 keyboard.c refers to this. */
164 /* display_text_line sets these to the frame position (origin 0) of point,
165 whether the window is selected or not.
166 Set one to -1 first to determine whether point was found afterwards. */
168 static int cursor_vpos
;
169 static int cursor_hpos
;
171 static int debug_end_pos
;
173 /* Nonzero means display mode line highlighted */
174 int mode_line_inverse_video
;
176 static void redisplay_internal ();
177 static int message_log_check_duplicate ();
178 static void echo_area_display ();
179 void mark_window_display_accurate ();
180 static void redisplay_windows ();
181 static void redisplay_window ();
182 static void update_menu_bar ();
183 static void try_window ();
184 static int try_window_id ();
185 static struct position
*display_text_line ();
186 static void display_mode_line ();
187 static int display_mode_element ();
188 static char *decode_mode_spec ();
189 static int display_string ();
190 static void display_menu_bar ();
191 static int display_count_lines ();
193 /* Prompt to display in front of the minibuffer contents */
194 Lisp_Object minibuf_prompt
;
196 /* Width in columns of current minibuffer prompt. */
197 int minibuf_prompt_width
;
199 /* Message to display instead of minibuffer contents
200 This is what the functions error and message make,
201 and command echoing uses it as well.
202 It overrides the minibuf_prompt as well as the buffer. */
203 char *echo_area_glyphs
;
205 /* This is the length of the message in echo_area_glyphs. */
206 int echo_area_glyphs_length
;
208 /* This is the window where the echo area message was displayed.
209 It is always a minibuffer window, but it may not be the
210 same window currently active as a minibuffer. */
211 Lisp_Object echo_area_window
;
213 /* true iff we should redraw the mode lines on the next redisplay */
214 int update_mode_lines
;
216 /* Smallest number of characters before the gap
217 at any time since last redisplay that finished.
218 Valid for current buffer when try_window_id can be called. */
221 /* Smallest number of characters after the gap
222 at any time since last redisplay that finished.
223 Valid for current buffer when try_window_id can be called. */
226 /* MODIFF as of last redisplay that finished;
227 if it matches MODIFF, and overlay_unchanged_modified
228 matches OVERLAY_MODIFF, that means beg_unchanged and end_unchanged
229 contain no useful information */
230 int unchanged_modified
;
232 /* OVERLAY_MODIFF as of last redisplay that finished. */
233 int overlay_unchanged_modified
;
235 /* Nonzero if window sizes or contents have changed
236 since last redisplay that finished */
237 int windows_or_buffers_changed
;
239 /* Nonzero after display_mode_line if %l was used
240 and it displayed a line number. */
241 int line_number_displayed
;
243 /* Maximum buffer size for which to display line numbers. */
244 static int line_number_display_limit
;
246 /* Number of lines to keep in the message log buffer.
247 t means infinite. nil means don't log at all. */
248 Lisp_Object Vmessage_log_max
;
250 /* Output a newline in the *Messages* buffer if "needs" one. */
253 message_log_maybe_newline ()
255 if (message_log_need_newline
)
256 message_dolog ("", 0, 1);
260 /* Add a string to the message log, optionally terminated with a newline.
261 This function calls low-level routines in order to bypass text property
262 hooks, etc. which might not be safe to run. */
265 message_dolog (m
, len
, nlflag
)
269 if (!NILP (Vmessage_log_max
))
271 struct buffer
*oldbuf
;
272 int oldpoint
, oldbegv
, oldzv
;
273 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
275 oldbuf
= current_buffer
;
276 Fset_buffer (Fget_buffer_create (build_string ("*Messages*")));
277 current_buffer
->undo_list
= Qt
;
284 oldpoint
+= len
+ nlflag
;
286 oldzv
+= len
+ nlflag
;
289 insert_1 (m
, len
, 1, 0);
292 int this_bol
, prev_bol
, dup
;
293 insert_1 ("\n", 1, 1, 0);
295 this_bol
= scan_buffer ('\n', Z
, 0, -2, 0, 0);
298 prev_bol
= scan_buffer ('\n', this_bol
, 0, -2, 0, 0);
299 dup
= message_log_check_duplicate (prev_bol
, this_bol
);
302 if (oldpoint
> prev_bol
)
303 oldpoint
-= min (this_bol
, oldpoint
) - prev_bol
;
304 if (oldbegv
> prev_bol
)
305 oldbegv
-= min (this_bol
, oldbegv
) - prev_bol
;
306 if (oldzv
> prev_bol
)
307 oldzv
-= min (this_bol
, oldzv
) - prev_bol
;
308 del_range_1 (prev_bol
, this_bol
, 0);
314 /* If you change this format, don't forget to also
315 change message_log_check_duplicate. */
316 sprintf (dupstr
, " [%d times]", dup
);
317 duplen
= strlen (dupstr
);
323 insert_1 (dupstr
, duplen
, 1, 0);
328 if (NATNUMP (Vmessage_log_max
))
330 int pos
= scan_buffer ('\n', Z
, 0,
331 -XFASTINT (Vmessage_log_max
) - 1, 0, 0);
332 oldpoint
-= min (pos
, oldpoint
) - BEG
;
333 oldbegv
-= min (pos
, oldbegv
) - BEG
;
334 oldzv
-= min (pos
, oldzv
) - BEG
;
335 del_range_1 (BEG
, pos
, 0);
340 TEMP_SET_PT (oldpoint
);
341 set_buffer_internal (oldbuf
);
342 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
343 message_log_need_newline
= !nlflag
;
347 /* We are at the end of the buffer after just having inserted a newline.
348 (Note: We depend on the fact we won't be crossing the gap.)
349 Check to see if the most recent message looks a lot like the previous one.
350 Return 0 if different, 1 if the new one should just replace it, or a
351 value N > 1 if we should also append " [N times]". */
354 message_log_check_duplicate (prev_bol
, this_bol
)
355 int prev_bol
, this_bol
;
358 int len
= Z
- 1 - this_bol
;
360 unsigned char *p1
= BUF_CHAR_ADDRESS (current_buffer
, prev_bol
);
361 unsigned char *p2
= BUF_CHAR_ADDRESS (current_buffer
, this_bol
);
363 for (i
= 0; i
< len
; i
++)
365 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.'
374 if (*p1
++ == ' ' && *p1
++ == '[')
377 while (*p1
>= '0' && *p1
<= '9')
378 n
= n
* 10 + *p1
++ - '0';
379 if (strncmp (p1
, " times]\n", 8) == 0)
385 /* Display an echo area message M with a specified length of LEN chars.
386 The string may include null characters. If M is 0, clear out any
387 existing message, and let the minibuffer text show through.
389 The buffer M must continue to exist until after the echo area
390 gets cleared or some other message gets displayed there.
392 Do not pass text that is stored in a Lisp string.
393 Do not pass text in a buffer that was alloca'd. */
400 /* First flush out any partial line written with print. */
401 message_log_maybe_newline ();
403 message_dolog (m
, len
, 1);
404 message2_nolog (m
, len
);
408 /* The non-logging counterpart of message2. */
411 message2_nolog (m
, len
)
417 if (noninteractive_need_newline
)
419 noninteractive_need_newline
= 0;
420 fwrite (m
, len
, 1, stderr
);
421 if (cursor_in_echo_area
== 0)
422 fprintf (stderr
, "\n");
425 /* A null message buffer means that the frame hasn't really been
426 initialized yet. Error messages get reported properly by
427 cmd_error, so this must be just an informative message; toss it. */
428 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
430 Lisp_Object mini_window
;
433 /* Get the frame containing the minibuffer
434 that the selected frame is using. */
435 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
436 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
438 FRAME_SAMPLE_VISIBILITY (f
);
439 if (FRAME_VISIBLE_P (selected_frame
)
440 && ! FRAME_VISIBLE_P (f
))
441 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
445 echo_area_glyphs
= m
;
446 echo_area_glyphs_length
= len
;
448 if (minibuffer_auto_raise
)
449 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
452 echo_area_glyphs
= previous_echo_glyphs
= 0;
454 do_pending_window_change ();
455 echo_area_display ();
456 update_frame (f
, 1, 1);
457 do_pending_window_change ();
458 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
459 (*frame_up_to_date_hook
) (f
);
463 /* Display a null-terminated echo area message M. If M is 0, clear out any
464 existing message, and let the minibuffer text show through.
466 The buffer M must continue to exist until after the echo area
467 gets cleared or some other message gets displayed there.
469 Do not pass text that is stored in a Lisp string.
470 Do not pass text in a buffer that was alloca'd. */
476 message2 (m
, (m
? strlen (m
) : 0));
483 message2_nolog (m
, (m
? strlen (m
) : 0));
486 /* Truncate what will be displayed in the echo area
487 the next time we display it--but don't redisplay it now. */
490 truncate_echo_area (len
)
493 /* A null message buffer means that the frame hasn't really been
494 initialized yet. Error messages get reported properly by
495 cmd_error, so this must be just an informative message; toss it. */
496 if (!noninteractive
&& INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
497 echo_area_glyphs_length
= len
;
500 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
501 zero if being used by message. */
502 int message_buf_print
;
504 /* Dump an informative message to the minibuf. If M is 0, clear out
505 any existing message, and let the minibuffer text show through. */
509 message (m
, a1
, a2
, a3
)
511 EMACS_INT a1
, a2
, a3
;
517 if (noninteractive_need_newline
)
519 noninteractive_need_newline
= 0;
520 fprintf (stderr
, m
, a1
, a2
, a3
);
521 if (cursor_in_echo_area
== 0)
522 fprintf (stderr
, "\n");
526 else if (INTERACTIVE
)
528 /* The frame whose minibuffer we're going to display the message on.
529 It may be larger than the selected frame, so we need
530 to use its buffer, not the selected frame's buffer. */
531 Lisp_Object mini_window
;
534 /* Get the frame containing the minibuffer
535 that the selected frame is using. */
536 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
537 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
539 /* A null message buffer means that the frame hasn't really been
540 initialized yet. Error messages get reported properly by
541 cmd_error, so this must be just an informative message; toss it. */
542 if (FRAME_MESSAGE_BUF (f
))
553 len
= doprnt (FRAME_MESSAGE_BUF (f
),
554 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
556 len
= doprnt (FRAME_MESSAGE_BUF (f
),
557 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, &a1
);
558 #endif /* NO_ARG_ARRAY */
560 message2 (FRAME_MESSAGE_BUF (f
), len
);
565 /* Print should start at the beginning of the message
567 message_buf_print
= 0;
572 /* The non-logging version of message. */
574 message_nolog (m
, a1
, a2
, a3
)
576 EMACS_INT a1
, a2
, a3
;
578 Lisp_Object old_log_max
;
579 old_log_max
= Vmessage_log_max
;
580 Vmessage_log_max
= Qnil
;
581 message (m
, a1
, a2
, a3
);
582 Vmessage_log_max
= old_log_max
;
588 message2 (echo_area_glyphs
, echo_area_glyphs_length
);
596 Lisp_Object mini_window
;
598 /* Choose the minibuffer window for this display.
599 It is the minibuffer window used by the selected frame. */
600 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
601 /* This is the frame that window is in. */
602 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
604 if (! FRAME_VISIBLE_P (f
))
609 redraw_garbaged_frames ();
613 if (echo_area_glyphs
|| minibuf_level
== 0)
617 echo_area_window
= mini_window
;
619 vpos
= XFASTINT (XWINDOW (mini_window
)->top
);
620 get_display_line (f
, vpos
, 0);
622 /* Make sure the columns that overlap a left-hand scroll bar
624 for (i
= 0; i
< FRAME_LEFT_SCROLL_BAR_WIDTH (f
); i
++)
625 f
->desired_glyphs
->glyphs
[vpos
][i
] = SPACEGLYPH
;
627 display_string (XWINDOW (mini_window
), vpos
,
628 echo_area_glyphs
? echo_area_glyphs
: "",
629 echo_area_glyphs
? echo_area_glyphs_length
: -1,
630 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
631 0, 0, 0, FRAME_WIDTH (f
));
633 #if 0 /* This just gets in the way. update_frame does the job. */
634 /* If desired cursor location is on this line, put it at end of text */
635 if (cursor_in_echo_area
)
636 FRAME_CURSOR_Y (f
) = vpos
;
637 if (FRAME_CURSOR_Y (f
) == vpos
)
638 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
641 /* Fill the rest of the minibuffer window with blank lines. */
646 i
< vpos
+ XFASTINT (XWINDOW (mini_window
)->height
); i
++)
648 get_display_line (f
, i
, 0);
649 display_string (XWINDOW (mini_window
), vpos
,
651 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
652 0, 0, 0, FRAME_WIDTH (f
));
656 else if (!EQ (mini_window
, selected_window
))
657 windows_or_buffers_changed
++;
659 if (EQ (mini_window
, selected_window
))
660 this_line_bufpos
= 0;
662 previous_echo_glyphs
= echo_area_glyphs
;
665 /* Update frame titles. */
667 #ifdef HAVE_WINDOW_SYSTEM
668 static char frame_title_buf
[512];
669 static char *frame_title_ptr
;
672 store_frame_title (str
, mincol
, maxcol
)
677 if (maxcol
< 0 || maxcol
>= sizeof(frame_title_buf
))
678 maxcol
= sizeof (frame_title_buf
);
679 limit
= &frame_title_buf
[maxcol
];
680 while (*str
!= '\0' && frame_title_ptr
< limit
)
681 *frame_title_ptr
++ = *str
++;
682 while (frame_title_ptr
< &frame_title_buf
[mincol
])
683 *frame_title_ptr
++ = ' ';
684 return frame_title_ptr
- frame_title_buf
;
688 x_consider_frame_title (frame
)
694 FRAME_PTR f
= XFRAME (frame
);
696 if (!(FRAME_WINDOW_P (f
) || FRAME_MINIBUF_ONLY_P (f
) || f
->explicit_name
))
699 /* Do we have more than one visible frame on this X display? */
703 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
705 FRAME_PTR tf
= XFRAME (XCONS (tail
)->car
);
707 if (tf
!= f
&& FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
708 && !FRAME_MINIBUF_ONLY_P (tf
)
709 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
713 multiple_frames
= CONSP (tail
);
716 obuf
= current_buffer
;
717 Fset_buffer (XWINDOW (f
->selected_window
)->buffer
);
718 fmt
= (FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
);
719 frame_title_ptr
= frame_title_buf
;
720 len
= display_mode_element (XWINDOW (f
->selected_window
), 0, 0, 0,
721 0, sizeof (frame_title_buf
), fmt
);
723 set_buffer_internal (obuf
);
724 /* Set the name only if it's changed. This avoids consing
725 in the common case where it hasn't. (If it turns out that we've
726 already wasted too much time by walking through the list with
727 display_mode_element, then we might need to optimize at a higher
729 if (! STRINGP (f
->name
) || XSTRING (f
->name
)->size
!= len
730 || bcmp (frame_title_buf
, XSTRING (f
->name
)->data
, len
) != 0)
731 x_implicitly_set_name (f
, make_string (frame_title_buf
, len
), Qnil
);
734 #define frame_title_ptr ((char *)0)
735 #define store_frame_title(str, mincol, maxcol) 0
738 /* Prepare for redisplay by updating menu-bar item lists when appropriate.
739 This can call eval. */
744 register struct window
*w
= XWINDOW (selected_window
);
746 struct gcpro gcpro1
, gcpro2
;
748 all_windows
= (update_mode_lines
|| buffer_shared
> 1
749 || windows_or_buffers_changed
);
751 /* Update all frame titles based on their buffer names, etc.
752 We do this before the menu bars so that the buffer-menu
753 will show the up-to-date frame titles.
755 This used to be done after the menu bars, for a reason that
756 was stated as follows but which I do not understand:
757 "We do this after the menu bars so that the frame will first
758 create its menu bar using the name `emacs' if no other name
759 has yet been specified."
760 I think that is no longer a concern. */
761 #ifdef HAVE_WINDOW_SYSTEM
762 if (windows_or_buffers_changed
|| update_mode_lines
)
764 Lisp_Object tail
, frame
;
766 FOR_EACH_FRAME (tail
, frame
)
767 if (FRAME_VISIBLE_P (XFRAME (frame
))
768 || FRAME_ICONIFIED_P (XFRAME (frame
)))
769 x_consider_frame_title (frame
);
773 /* Update the menu bar item lists, if appropriate.
774 This has to be done before any actual redisplay
775 or generation of display lines. */
778 Lisp_Object tail
, frame
;
779 int count
= specpdl_ptr
- specpdl
;
781 record_unwind_protect (Fstore_match_data
, Fmatch_data (Qnil
, Qnil
));
783 FOR_EACH_FRAME (tail
, frame
)
785 /* If a window on this frame changed size,
786 report that to the user and clear the size-change flag. */
787 if (FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)))
789 Lisp_Object functions
;
790 /* Clear flag first in case we get error below. */
791 FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)) = 0;
792 functions
= Vwindow_size_change_functions
;
793 GCPRO2 (tail
, functions
);
794 while (CONSP (functions
))
796 call1 (XCONS (functions
)->car
, frame
);
797 functions
= XCONS (functions
)->cdr
;
802 update_menu_bar (XFRAME (frame
), 0);
806 unbind_to (count
, Qnil
);
809 update_menu_bar (selected_frame
, 1);
811 /* Motif needs this. See comment in xmenu.c.
812 Turn it off when pending_menu_activation is not defined. */
814 pending_menu_activation
= 0;
818 /* Do a frame update, taking possible shortcuts into account.
819 This is the main external entry point for redisplay.
821 If the last redisplay displayed an echo area message and that
822 message is no longer requested, we clear the echo area
823 or bring back the minibuffer if that is in use.
825 Do not call eval from within this function.
826 Calls to eval after the call to echo_area_display would confuse
827 the display_line mechanism and would cause a crash.
828 Calls to eval before that point will work most of the time,
829 but can still lose, because this function
830 can be called from signal handlers; with alarms set up;
831 or with synchronous processes running.
833 See Fcall_process; if you called it from here, it could be
834 entered recursively. */
836 static int do_verify_charstarts
;
838 /* Counter is used to clear the face cache
839 no more than once ever 1000 redisplays. */
840 static int clear_face_cache_count
;
842 /* Record the previous terminal frame we displayed. */
843 static FRAME_PTR previous_terminal_frame
;
848 redisplay_internal (0);
851 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay
852 is not in response to any user action; therefore, we should
853 preserve the echo area. (Actually, our caller does that job.)
854 Perhaps in the future avoid recentering windows
855 if it is not necessary; currently that causes some problems. */
858 redisplay_internal (preserve_echo_area
)
859 int preserve_echo_area
;
861 register struct window
*w
= XWINDOW (selected_window
);
865 register int tlbufpos
, tlendpos
;
872 if (popup_activated ())
876 if (! FRAME_WINDOW_P (selected_frame
)
877 && previous_terminal_frame
!= selected_frame
)
879 /* Since frames on an ASCII terminal share the same display area,
880 displaying a different frame means redisplay the whole thing. */
881 windows_or_buffers_changed
++;
882 SET_FRAME_GARBAGED (selected_frame
);
883 XSETFRAME (Vterminal_frame
, selected_frame
);
885 previous_terminal_frame
= selected_frame
;
887 /* Set the visible flags for all frames.
888 Do this before checking for resized or garbaged frames; they want
889 to know if their frames are visible.
890 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
892 Lisp_Object tail
, frame
;
894 FOR_EACH_FRAME (tail
, frame
)
896 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
898 /* Clear out all the display lines in which we will generate the
899 glyphs to display. */
900 init_desired_glyphs (XFRAME (frame
));
904 /* Notice any pending interrupt request to change frame size. */
905 do_pending_window_change ();
909 redraw_garbaged_frames ();
913 prepare_menu_bars ();
915 if (windows_or_buffers_changed
)
918 /* Detect case that we need to write or remove a star in the mode line. */
919 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
921 w
->update_mode_line
= Qt
;
922 if (buffer_shared
> 1)
926 /* If %c is in use, update it if needed. */
927 if (!NILP (w
->column_number_displayed
)
928 /* This alternative quickly identifies a common case
929 where no change is needed. */
930 && !(PT
== XFASTINT (w
->last_point
)
931 && XFASTINT (w
->last_modified
) >= MODIFF
932 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
933 && XFASTINT (w
->column_number_displayed
) != current_column ())
934 w
->update_mode_line
= Qt
;
936 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
938 all_windows
= update_mode_lines
|| buffer_shared
> 1;
940 /* If specs for an arrow have changed, do thorough redisplay
941 to ensure we remove any arrow that should no longer exist. */
942 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
943 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
946 /* Normally the message* functions will have already displayed and
947 updated the echo area, but the frame may have been trashed, or
948 the update may have been preempted, so display the echo area
950 if (echo_area_glyphs
|| previous_echo_glyphs
)
952 echo_area_display ();
956 /* If showing region, and mark has changed, must redisplay whole window. */
957 if (((!NILP (Vtransient_mark_mode
)
958 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
959 != !NILP (w
->region_showing
))
960 || (!NILP (w
->region_showing
)
961 && !EQ (w
->region_showing
,
962 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
963 this_line_bufpos
= -1;
965 tlbufpos
= this_line_bufpos
;
966 tlendpos
= this_line_endpos
;
967 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
968 && !current_buffer
->clip_changed
969 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
970 /* Make sure recorded data applies to current buffer, etc */
971 && this_line_buffer
== current_buffer
972 && current_buffer
== XBUFFER (w
->buffer
)
973 && NILP (w
->force_start
)
974 /* Point must be on the line that we have info recorded about */
976 && PT
<= Z
- tlendpos
977 /* All text outside that line, including its final newline,
979 && ((XFASTINT (w
->last_modified
) >= MODIFF
980 && (XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
))
981 || (beg_unchanged
>= tlbufpos
- 1
983 /* If selective display, can't optimize
984 if the changes start at the beginning of the line. */
985 && ((INTEGERP (current_buffer
->selective_display
)
986 && XINT (current_buffer
->selective_display
) > 0
987 ? (beg_unchanged
>= tlbufpos
990 && end_unchanged
>= tlendpos
991 && Z
- GPT
>= tlendpos
)))
993 if (tlbufpos
> BEGV
&& FETCH_BYTE (tlbufpos
- 1) != '\n'
995 || FETCH_BYTE (tlbufpos
) == '\n'))
996 /* Former continuation line has disappeared by becoming empty */
998 else if (XFASTINT (w
->last_modified
) < MODIFF
999 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
1000 || MINI_WINDOW_P (w
))
1002 /* We have to handle the case of continuation around a
1003 wide-column character (See the comment in indent.c around
1006 For instance, in the following case:
1008 -------- Insert --------
1009 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
1010 J_I_ ==> J_I_ `^^' are cursors.
1014 As we have to redraw the line above, we should goto cancel. */
1016 struct position val
;
1019 prevline
= find_next_newline (tlbufpos
, -1);
1020 val
= *compute_motion (prevline
, 0,
1021 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1024 1 << (BITS_PER_SHORT
- 1),
1025 1 << (BITS_PER_SHORT
- 1),
1026 window_internal_width (w
) - 1,
1027 XINT (w
->hscroll
), 0, w
);
1028 if (val
.hpos
!= this_line_start_hpos
)
1032 overlay_arrow_seen
= 0;
1033 zv_strings_seen
= 0;
1034 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
1035 pos_tab_offset (w
, tlbufpos
), 0);
1036 /* If line contains point, is not continued,
1037 and ends at same distance from eob as before, we win */
1038 if (cursor_vpos
>= 0 && this_line_bufpos
1039 && this_line_endpos
== tlendpos
)
1041 /* If this is not the window's last line,
1042 we must adjust the charstarts of the lines below. */
1043 if (this_line_vpos
+ 1
1044 < XFASTINT (w
->top
) + window_internal_height (w
))
1046 int left
= WINDOW_LEFT_MARGIN (w
);
1047 int *charstart_next_line
1048 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[this_line_vpos
+ 1];
1051 if (Z
- tlendpos
== ZV
)
1052 /* This line ends at end of (accessible part of) buffer.
1053 There is no newline to count. */
1054 adjust
= Z
- tlendpos
- charstart_next_line
[left
];
1056 /* This line ends in a newline.
1057 Must take account of the newline and the rest of the
1058 text that follows. */
1059 adjust
= Z
- tlendpos
+ 1 - charstart_next_line
[left
];
1061 adjust_window_charstarts (w
, this_line_vpos
, adjust
);
1064 if (!WINDOW_FULL_WIDTH_P (w
))
1065 preserve_other_columns (w
);
1071 else if (PT
== XFASTINT (w
->last_point
)
1072 /* Make sure the cursor was last displayed
1073 in this window. Otherwise we have to reposition it. */
1074 && XINT (w
->top
) <= FRAME_CURSOR_Y (selected_frame
)
1075 && (XINT (w
->top
) + XINT (w
->height
)
1076 > FRAME_CURSOR_Y (selected_frame
)))
1080 do_pending_window_change ();
1085 /* If highlighting the region, or if the cursor is in the echo area,
1086 then we can't just move the cursor. */
1087 else if (! (!NILP (Vtransient_mark_mode
)
1088 && !NILP (current_buffer
->mark_active
))
1089 && w
== XWINDOW (current_buffer
->last_selected_window
)
1090 && NILP (w
->region_showing
)
1091 && !cursor_in_echo_area
)
1093 pos
= *compute_motion (tlbufpos
, 0,
1094 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1096 PT
, 2, - (1 << (BITS_PER_SHORT
- 1)),
1097 window_internal_width (w
) - 1,
1099 pos_tab_offset (w
, tlbufpos
), w
);
1102 int width
= window_internal_width (w
) - 1;
1103 FRAME_CURSOR_X (selected_frame
)
1104 = WINDOW_LEFT_MARGIN (w
) + minmax (0, pos
.hpos
, width
);
1105 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
1112 /* Text changed drastically or point moved off of line */
1113 cancel_line (this_line_vpos
, selected_frame
);
1116 this_line_bufpos
= 0;
1117 all_windows
|= buffer_shared
> 1;
1119 clear_face_cache_count
++;
1123 Lisp_Object tail
, frame
;
1126 /* Clear the face cache, only when we do a full redisplay
1127 and not too often either. */
1128 if (clear_face_cache_count
> 1000)
1130 clear_face_cache ();
1131 clear_face_cache_count
= 0;
1135 /* Recompute # windows showing selected buffer.
1136 This will be incremented each time such a window is displayed. */
1139 FOR_EACH_FRAME (tail
, frame
)
1141 FRAME_PTR f
= XFRAME (frame
);
1142 if (FRAME_WINDOW_P (f
) || f
== selected_frame
)
1145 /* Mark all the scroll bars to be removed; we'll redeem the ones
1146 we want when we redisplay their windows. */
1147 if (condemn_scroll_bars_hook
)
1148 (*condemn_scroll_bars_hook
) (f
);
1150 if (FRAME_VISIBLE_P (f
))
1151 redisplay_windows (FRAME_ROOT_WINDOW (f
), preserve_echo_area
);
1153 /* Any scroll bars which redisplay_windows should have nuked
1154 should now go away. */
1155 if (judge_scroll_bars_hook
)
1156 (*judge_scroll_bars_hook
) (f
);
1160 else if (FRAME_VISIBLE_P (selected_frame
))
1162 redisplay_window (selected_window
, 1, preserve_echo_area
);
1163 if (!WINDOW_FULL_WIDTH_P (w
))
1164 preserve_other_columns (w
);
1168 /* Prevent various kinds of signals during display update.
1169 stdio is not robust about handling signals,
1170 which can cause an apparent I/O error. */
1171 if (interrupt_input
)
1181 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1185 if (!FRAMEP (XCONS (tail
)->car
))
1188 f
= XFRAME (XCONS (tail
)->car
);
1190 if ((FRAME_WINDOW_P (f
) || f
== selected_frame
)
1191 && FRAME_VISIBLE_P (f
))
1193 pause
|= update_frame (f
, 0, 0);
1196 mark_window_display_accurate (f
->root_window
, 1);
1197 if (frame_up_to_date_hook
!= 0)
1198 (*frame_up_to_date_hook
) (f
);
1205 if (FRAME_VISIBLE_P (selected_frame
))
1206 pause
= update_frame (selected_frame
, 0, 0);
1210 /* We may have called echo_area_display at the top of this
1211 function. If the echo area is on another frame, that may
1212 have put text on a frame other than the selected one, so the
1213 above call to update_frame would not have caught it. Catch
1216 Lisp_Object mini_window
;
1217 FRAME_PTR mini_frame
;
1219 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
1220 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
1222 if (mini_frame
!= selected_frame
&& FRAME_WINDOW_P (mini_frame
))
1223 pause
|= update_frame (mini_frame
, 0, 0);
1227 /* If frame does not match, prevent doing single-line-update next time.
1228 Also, don't forget to check every line to update the arrow. */
1231 this_line_bufpos
= 0;
1232 if (!NILP (last_arrow_position
))
1234 last_arrow_position
= Qt
;
1235 last_arrow_string
= Qt
;
1237 /* If we pause after scrolling, some lines in current_frame
1238 may be null, so preserve_other_columns won't be able to
1239 preserve all the vertical-bar separators. So, avoid using it
1241 if (!WINDOW_FULL_WIDTH_P (w
))
1242 update_mode_lines
= 1;
1245 /* Now text on frame agrees with windows, so
1246 put info into the windows for partial redisplay to follow */
1250 register struct buffer
*b
= XBUFFER (w
->buffer
);
1252 blank_end_of_window
= 0;
1253 unchanged_modified
= BUF_MODIFF (b
);
1254 overlay_unchanged_modified
= BUF_OVERLAY_MODIFF (b
);
1255 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
1256 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
1258 XSETFASTINT (w
->last_point
, BUF_PT (b
));
1259 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (selected_frame
));
1260 XSETFASTINT (w
->last_point_y
, FRAME_CURSOR_Y (selected_frame
));
1263 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
1266 b
->clip_changed
= 0;
1267 w
->update_mode_line
= Qnil
;
1268 XSETFASTINT (w
->last_modified
, BUF_MODIFF (b
));
1269 XSETFASTINT (w
->last_overlay_modified
, BUF_OVERLAY_MODIFF (b
));
1271 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1273 w
->window_end_valid
= w
->buffer
;
1274 last_arrow_position
= Voverlay_arrow_position
;
1275 last_arrow_string
= Voverlay_arrow_string
;
1276 if (do_verify_charstarts
)
1277 verify_charstarts (w
);
1278 if (frame_up_to_date_hook
!= 0)
1279 (*frame_up_to_date_hook
) (selected_frame
);
1281 update_mode_lines
= 0;
1282 windows_or_buffers_changed
= 0;
1285 /* Start SIGIO interrupts coming again.
1286 Having them off during the code above
1287 makes it less likely one will discard output,
1288 but not impossible, since there might be stuff
1289 in the system buffer here.
1290 But it is much hairier to try to do anything about that. */
1292 if (interrupt_input
)
1296 /* Change frame size now if a change is pending. */
1297 do_pending_window_change ();
1299 /* If we just did a pending size change, redisplay again
1300 for the new size. */
1301 if (windows_or_buffers_changed
&& !pause
)
1305 /* Redisplay, but leave alone any recent echo area message
1306 unless another message has been requested in its place.
1308 This is useful in situations where you need to redisplay but no
1309 user action has occurred, making it inappropriate for the message
1310 area to be cleared. See tracking_off and
1311 wait_reading_process_input for examples of these situations. */
1313 redisplay_preserve_echo_area ()
1315 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
1317 echo_area_glyphs
= previous_echo_glyphs
;
1318 redisplay_internal (1);
1319 echo_area_glyphs
= 0;
1322 redisplay_internal (1);
1326 mark_window_display_accurate (window
, flag
)
1330 register struct window
*w
;
1332 for (;!NILP (window
); window
= w
->next
)
1334 if (!WINDOWP (window
)) abort ();
1335 w
= XWINDOW (window
);
1337 if (!NILP (w
->buffer
))
1339 XSETFASTINT (w
->last_modified
,
1340 !flag
? 0 : BUF_MODIFF (XBUFFER (w
->buffer
)));
1341 XSETFASTINT (w
->last_overlay_modified
,
1342 !flag
? 0 : BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
)));
1344 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1347 /* Record if we are showing a region, so can make sure to
1348 update it fully at next redisplay. */
1349 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
1350 && w
== XWINDOW (current_buffer
->last_selected_window
)
1351 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
1352 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
1356 w
->window_end_valid
= w
->buffer
;
1357 w
->update_mode_line
= Qnil
;
1358 if (!NILP (w
->buffer
) && flag
)
1359 XBUFFER (w
->buffer
)->clip_changed
= 0;
1361 if (!NILP (w
->vchild
))
1362 mark_window_display_accurate (w
->vchild
, flag
);
1363 if (!NILP (w
->hchild
))
1364 mark_window_display_accurate (w
->hchild
, flag
);
1369 last_arrow_position
= Voverlay_arrow_position
;
1370 last_arrow_string
= Voverlay_arrow_string
;
1374 /* t is unequal to any useful value of Voverlay_arrow_... */
1375 last_arrow_position
= Qt
;
1376 last_arrow_string
= Qt
;
1380 /* Update the menu bar item list for frame F.
1381 This has to be done before we start to fill in any display lines,
1382 because it can call eval.
1384 If SAVE_MATCH_DATA is 1, we must save and restore it here. */
1387 update_menu_bar (f
, save_match_data
)
1389 int save_match_data
;
1391 struct buffer
*old
= current_buffer
;
1393 register struct window
*w
;
1395 window
= FRAME_SELECTED_WINDOW (f
);
1396 w
= XWINDOW (window
);
1398 if (update_mode_lines
)
1399 w
->update_mode_line
= Qt
;
1401 if (FRAME_WINDOW_P (f
)
1403 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1404 FRAME_EXTERNAL_MENU_BAR (f
)
1406 FRAME_MENU_BAR_LINES (f
) > 0
1408 : FRAME_MENU_BAR_LINES (f
) > 0)
1410 /* If the user has switched buffers or windows, we need to
1411 recompute to reflect the new bindings. But we'll
1412 recompute when update_mode_lines is set too; that means
1413 that people can use force-mode-line-update to request
1414 that the menu bar be recomputed. The adverse effect on
1415 the rest of the redisplay algorithm is about the same as
1416 windows_or_buffers_changed anyway. */
1417 if (windows_or_buffers_changed
1418 || !NILP (w
->update_mode_line
)
1419 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1420 < BUF_MODIFF (XBUFFER (w
->buffer
)))
1421 != !NILP (w
->last_had_star
))
1422 || ((!NILP (Vtransient_mark_mode
)
1423 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
1424 != !NILP (w
->region_showing
)))
1426 struct buffer
*prev
= current_buffer
;
1427 int count
= specpdl_ptr
- specpdl
;
1429 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1430 if (save_match_data
)
1431 record_unwind_protect (Fstore_match_data
, Fmatch_data (Qnil
, Qnil
));
1432 if (NILP (Voverriding_local_map_menu_flag
))
1434 specbind (Qoverriding_terminal_local_map
, Qnil
);
1435 specbind (Qoverriding_local_map
, Qnil
);
1438 /* Run the Lucid hook. */
1439 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1440 /* If it has changed current-menubar from previous value,
1441 really recompute the menubar from the value. */
1442 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1443 call0 (Qrecompute_lucid_menubar
);
1444 safe_run_hooks (Qmenu_bar_update_hook
);
1445 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1446 /* Redisplay the menu bar in case we changed it. */
1447 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1448 if (FRAME_WINDOW_P (f
))
1449 set_frame_menubar (f
, 0, 0);
1451 /* On a terminal screen, the menu bar is an ordinary screen
1452 line, and this makes it get updated. */
1453 w
->update_mode_line
= Qt
;
1454 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
1455 /* In the non-toolkit version, the menu bar is an ordinary screen
1456 line, and this makes it get updated. */
1457 w
->update_mode_line
= Qt
;
1458 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
1460 unbind_to (count
, Qnil
);
1461 set_buffer_internal_1 (prev
);
1468 /* Redisplay WINDOW and its subwindows and siblings. */
1471 redisplay_windows (window
, preserve_echo_area
)
1473 int preserve_echo_area
;
1475 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
1476 redisplay_window (window
, 0, preserve_echo_area
);
1479 /* Return value in display table DP (Lisp_Char_Table *) for character
1480 C. Since a display table doesn't have any parent, we don't have to
1481 follow parent. Do not call this function directly but use the
1482 macro DISP_CHAR_VECTOR. */
1484 disp_char_vector (dp
, c
)
1485 struct Lisp_Char_Table
*dp
;
1491 if (SINGLE_BYTE_CHAR_P (c
)) return (dp
->contents
[c
]);
1493 SPLIT_NON_ASCII_CHAR (c
, code
[0], code
[1], code
[2]);
1494 if (code
[0] != CHARSET_COMPOSITION
)
1496 if (code
[1] < 32) code
[1] = -1;
1497 else if (code
[2] < 32) code
[2] = -1;
1499 /* Here, the possible range of CODE[0] (== charset ID) is
1500 128..MAX_CHARSET. Since the top level char table contains data
1501 for multibyte characters after 256th element, we must increment
1502 CODE[0] by 128 to get a correct index. */
1504 code
[3] = -1; /* anchor */
1506 for (i
= 0; code
[i
] >= 0; i
++, dp
= XCHAR_TABLE (val
))
1508 val
= dp
->contents
[code
[i
]];
1509 if (!SUB_CHAR_TABLE_P (val
))
1510 return (NILP (val
) ? dp
->defalt
: val
);
1512 /* Here, VAL is a sub char table. We return the default value of it. */
1513 return (dp
->defalt
);
1516 /* Redisplay window WINDOW and its subwindows. */
1519 redisplay_window (window
, just_this_one
, preserve_echo_area
)
1521 int just_this_one
, preserve_echo_area
;
1523 register struct window
*w
= XWINDOW (window
);
1524 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1526 register int lpoint
= PT
;
1527 struct buffer
*old
= current_buffer
;
1528 register int width
= window_internal_width (w
) - 1;
1529 register int startp
;
1530 register int hscroll
= XINT (w
->hscroll
);
1531 struct position pos
;
1534 int update_mode_line
;
1535 struct Lisp_Char_Table
*dp
= window_display_table (w
);
1537 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1539 /* If this is a combination window, do its children; that's all. */
1541 if (!NILP (w
->vchild
))
1543 redisplay_windows (w
->vchild
, preserve_echo_area
);
1546 if (!NILP (w
->hchild
))
1548 redisplay_windows (w
->hchild
, preserve_echo_area
);
1551 if (NILP (w
->buffer
))
1554 height
= window_internal_height (w
);
1555 update_mode_line
= (!NILP (w
->update_mode_line
) || update_mode_lines
);
1556 if (XBUFFER (w
->buffer
)->clip_changed
)
1557 update_mode_line
= 1;
1559 if (MINI_WINDOW_P (w
))
1561 if (w
== XWINDOW (echo_area_window
) && echo_area_glyphs
)
1562 /* We've already displayed the echo area glyphs in this window. */
1563 goto finish_scroll_bars
;
1564 else if (w
!= XWINDOW (minibuf_window
))
1566 /* This is a minibuffer, but it's not the currently active one,
1568 int vpos
= XFASTINT (w
->top
);
1571 for (i
= 0; i
< height
; i
++)
1573 get_display_line (f
, vpos
+ i
, 0);
1574 display_string (w
, vpos
+ i
, "", 0,
1575 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
1579 goto finish_scroll_bars
;
1583 /* Otherwise set up data on this window; select its buffer and point value */
1585 if (update_mode_line
)
1586 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1588 set_buffer_temp (XBUFFER (w
->buffer
));
1592 /* If %c is in mode line, update it if needed. */
1593 if (!NILP (w
->column_number_displayed
)
1594 /* This alternative quickly identifies a common case
1595 where no change is needed. */
1596 && !(PT
== XFASTINT (w
->last_point
)
1597 && XFASTINT (w
->last_modified
) >= MODIFF
1598 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
1599 && XFASTINT (w
->column_number_displayed
) != current_column ())
1600 update_mode_line
= 1;
1602 /* Count number of windows showing the selected buffer.
1603 An indirect buffer counts as its base buffer. */
1607 struct buffer
*current_base
, *window_base
;
1608 current_base
= current_buffer
;
1609 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1610 if (current_base
->base_buffer
)
1611 current_base
= current_base
->base_buffer
;
1612 if (window_base
->base_buffer
)
1613 window_base
= window_base
->base_buffer
;
1614 if (current_base
== window_base
)
1618 /* POINT refers normally to the selected window.
1619 For any other window, set up appropriate value. */
1621 if (!EQ (window
, selected_window
))
1623 int new_pt
= marker_position (w
->pointm
);
1627 Fset_marker (w
->pointm
, make_number (new_pt
), Qnil
);
1629 else if (new_pt
> (ZV
- 1))
1632 Fset_marker (w
->pointm
, make_number (new_pt
), Qnil
);
1634 /* We don't use SET_PT so that the point-motion hooks don't run. */
1635 BUF_PT (current_buffer
) = new_pt
;
1638 /* If any of the character widths specified in the display table
1639 have changed, invalidate the width run cache. It's true that this
1640 may be a bit late to catch such changes, but the rest of
1641 redisplay goes (non-fatally) haywire when the display table is
1642 changed, so why should we worry about doing any better? */
1643 if (current_buffer
->width_run_cache
)
1645 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
1647 if (! disptab_matches_widthtab (disptab
,
1648 XVECTOR (current_buffer
->width_table
)))
1650 invalidate_region_cache (current_buffer
,
1651 current_buffer
->width_run_cache
,
1653 recompute_width_table (current_buffer
, disptab
);
1657 /* If window-start is screwed up, choose a new one. */
1658 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
1661 startp
= marker_position (w
->start
);
1663 /* If someone specified a new starting point but did not insist,
1664 check whether it can be used. */
1665 if (!NILP (w
->optional_new_start
))
1667 w
->optional_new_start
= Qnil
;
1668 /* Check whether this start pos is usable given where point is. */
1670 pos
= *compute_motion (startp
, 0,
1671 (((EQ (window
, minibuf_window
)
1673 ? minibuf_prompt_width
: 0)
1674 + (hscroll
? 1 - hscroll
: 0)),
1677 /* BUG FIX: See the comment of
1678 Fpos_visible_in_window_p (window.c). */
1679 - (1 << (BITS_PER_SHORT
- 1)),
1680 width
, hscroll
, pos_tab_offset (w
, startp
), w
);
1681 /* If PT does fit on the screen, we will use this start pos,
1682 so do so by setting force_start. */
1683 if (pos
.bufpos
== PT
)
1684 w
->force_start
= Qt
;
1687 /* Handle case where place to start displaying has been specified,
1688 unless the specified location is outside the accessible range. */
1689 if (!NILP (w
->force_start
))
1691 w
->force_start
= Qnil
;
1692 /* Forget any recorded base line for line number display. */
1693 w
->base_line_number
= Qnil
;
1694 /* Redisplay the mode line. Select the buffer properly for that.
1695 Also, run the hook window-scroll-functions
1696 because we have scrolled. */
1697 /* Note, we do this after clearing force_start because
1698 if there's an error, it is better to forget about force_start
1699 than to get into an infinite loop calling the hook functions
1700 and having them get more errors. */
1701 if (!update_mode_line
1702 || ! NILP (Vwindow_scroll_functions
))
1704 Lisp_Object temp
[3];
1706 set_buffer_temp (old
);
1707 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1708 update_mode_line
= 1;
1709 w
->update_mode_line
= Qt
;
1710 if (! NILP (Vwindow_scroll_functions
))
1712 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1713 make_number (startp
));
1714 startp
= marker_position (w
->start
);
1717 XSETFASTINT (w
->last_modified
, 0);
1718 XSETFASTINT (w
->last_overlay_modified
, 0);
1719 if (startp
< BEGV
) startp
= BEGV
;
1720 if (startp
> ZV
) startp
= ZV
;
1721 try_window (window
, startp
);
1722 if (cursor_vpos
< 0)
1724 /* If point does not appear, move point so it does appear */
1725 pos
= *compute_motion (startp
, 0,
1726 (((EQ (window
, minibuf_window
)
1728 ? minibuf_prompt_width
: 0)
1729 + (hscroll
? 1 - hscroll
: 0)),
1732 - (1 << (BITS_PER_SHORT
- 1)),
1733 width
, hscroll
, pos_tab_offset (w
, startp
), w
);
1734 BUF_PT (current_buffer
) = pos
.bufpos
;
1735 if (w
!= XWINDOW (selected_window
))
1736 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
1739 if (current_buffer
== old
)
1741 FRAME_CURSOR_X (f
) = (WINDOW_LEFT_MARGIN (w
)
1742 + minmax (0, pos
.hpos
, width
));
1743 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1745 /* If we are highlighting the region,
1746 then we just changed the region, so redisplay to show it. */
1747 if (!NILP (Vtransient_mark_mode
)
1748 && !NILP (current_buffer
->mark_active
))
1750 cancel_my_columns (XWINDOW (window
));
1751 try_window (window
, startp
);
1757 /* Handle case where text has not changed, only point,
1758 and it has not moved off the frame. */
1760 /* This code is not used for minibuffer for the sake of
1761 the case of redisplaying to replace an echo area message;
1762 since in that case the minibuffer contents per se are usually unchanged.
1763 This code is of no real use in the minibuffer since
1764 the handling of this_line_bufpos, etc.,
1765 in redisplay handles the same cases. */
1767 if (XFASTINT (w
->last_modified
) >= MODIFF
1768 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
1769 && PT
>= startp
&& !current_buffer
->clip_changed
1770 && (just_this_one
|| WINDOW_FULL_WIDTH_P (w
))
1771 /* If force-mode-line-update was called, really redisplay;
1772 that's how redisplay is forced after e.g. changing
1773 buffer-invisibility-spec. */
1774 && NILP (w
->update_mode_line
)
1775 /* Can't use this case if highlighting a region. */
1776 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1777 && NILP (w
->region_showing
)
1778 /* If end pos is out of date, scroll bar and percentage will be wrong */
1779 && INTEGERP (w
->window_end_vpos
)
1780 && XFASTINT (w
->window_end_vpos
) < XFASTINT (w
->height
)
1781 && !EQ (window
, minibuf_window
))
1783 int this_scroll_margin
= scroll_margin
;
1785 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0), 0,
1787 /* BUG FIX: See the comment of
1788 Fpos_visible_in_window_p (window.c). */
1789 - (1 << (BITS_PER_SHORT
- 1)),
1791 pos_tab_offset (w
, startp
), w
);
1793 /* Don't use a scroll margin that is negative or too large. */
1794 if (this_scroll_margin
< 0)
1795 this_scroll_margin
= 0;
1797 if (XINT (w
->height
) < 4 * scroll_margin
)
1798 this_scroll_margin
= XINT (w
->height
) / 4;
1800 /* If point fits on the screen, and not within the scroll margin,
1802 if (pos
.vpos
< height
- this_scroll_margin
1803 && (pos
.vpos
>= this_scroll_margin
|| startp
== BEGV
))
1805 /* Ok, point is still on frame */
1806 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
1808 /* These variables are supposed to be origin 1 */
1809 FRAME_CURSOR_X (f
) = (WINDOW_LEFT_MARGIN (w
)
1810 + minmax (0, pos
.hpos
, width
));
1811 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1813 /* This doesn't do the trick, because if a window to the right of
1814 this one must be redisplayed, this does nothing because there
1815 is nothing in DesiredFrame yet, and then the other window is
1816 redisplayed, making likes that are empty in this window's columns.
1817 if (WINDOW_FULL_WIDTH_P (w))
1818 preserve_my_columns (w);
1822 /* Don't bother trying redisplay with same start;
1823 we already know it will lose */
1825 /* If current starting point was originally the beginning of a line
1826 but no longer is, find a new starting point. */
1827 else if (!NILP (w
->start_at_line_beg
)
1829 || FETCH_BYTE (startp
- 1) == '\n'))
1833 else if (just_this_one
&& !MINI_WINDOW_P (w
)
1835 && XFASTINT (w
->last_modified
)
1836 /* or else vmotion on first line won't work. */
1837 && ! NILP (w
->start_at_line_beg
)
1838 && ! EQ (w
->window_end_valid
, Qnil
)
1839 && do_id
&& !current_buffer
->clip_changed
1840 && !blank_end_of_window
1841 && WINDOW_FULL_WIDTH_P (w
)
1842 /* Can't use this case if highlighting a region. */
1843 && !(!NILP (Vtransient_mark_mode
)
1844 && !NILP (current_buffer
->mark_active
))
1845 /* Don't use try_window_id if newline
1846 doesn't display as the end of a line. */
1847 && !(dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, '\n')))
1848 && NILP (w
->region_showing
)
1849 && EQ (last_arrow_position
, Voverlay_arrow_position
)
1850 && EQ (last_arrow_string
, Voverlay_arrow_string
)
1851 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
1854 /* tem > 0 means success. tem == -1 means choose new start.
1855 tem == -2 means try again with same start,
1856 and nothing but whitespace follows the changed stuff.
1857 tem == 0 means try again with same start. */
1861 else if (startp
>= BEGV
&& startp
<= ZV
1863 /* Avoid starting at end of buffer. */
1864 #if 0 /* This change causes trouble for M-! finger & RET.
1865 It will have to be considered later. */
1866 || ! EQ (window
, selected_window
)
1867 /* Don't do the recentering if redisplay
1868 is not for no user action. */
1869 || preserve_echo_area
1872 || (XFASTINT (w
->last_modified
) >= MODIFF
1873 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
1875 /* Try to redisplay starting at same place as before */
1876 /* If point has not moved off frame, accept the results */
1877 try_window (window
, startp
);
1878 if (cursor_vpos
>= 0)
1880 if (!just_this_one
|| current_buffer
->clip_changed
1881 || beg_unchanged
< startp
)
1882 /* Forget any recorded base line for line number display. */
1883 w
->base_line_number
= Qnil
;
1887 cancel_my_columns (w
);
1890 XSETFASTINT (w
->last_modified
, 0);
1891 XSETFASTINT (w
->last_overlay_modified
, 0);
1892 /* Redisplay the mode line. Select the buffer properly for that. */
1893 if (!update_mode_line
)
1895 set_buffer_temp (old
);
1896 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1897 update_mode_line
= 1;
1898 w
->update_mode_line
= Qt
;
1901 /* Try to scroll by specified few lines */
1903 if (scroll_conservatively
&& !current_buffer
->clip_changed
1904 && startp
>= BEGV
&& startp
<= ZV
)
1906 int this_scroll_margin
= scroll_margin
;
1908 /* Don't use a scroll margin that is negative or too large. */
1909 if (this_scroll_margin
< 0)
1910 this_scroll_margin
= 0;
1912 if (XINT (w
->height
) < 4 * scroll_margin
)
1913 this_scroll_margin
= XINT (w
->height
) / 4;
1915 if (PT
>= Z
- XFASTINT (w
->window_end_pos
))
1917 struct position pos
;
1918 pos
= *compute_motion (Z
- XFASTINT (w
->window_end_pos
), 0, 0, 0,
1919 PT
, XFASTINT (w
->height
), 0,
1920 XFASTINT (w
->width
), XFASTINT (w
->hscroll
),
1921 pos_tab_offset (w
, startp
), w
);
1922 if (pos
.vpos
> scroll_conservatively
)
1925 pos
= *vmotion (startp
, pos
.vpos
+ 1 + this_scroll_margin
, w
);
1927 if (! NILP (Vwindow_scroll_functions
))
1929 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
1930 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1931 make_number (pos
.bufpos
));
1932 pos
.bufpos
= marker_position (w
->start
);
1934 try_window (window
, pos
.bufpos
);
1935 if (cursor_vpos
>= 0)
1937 if (!just_this_one
|| current_buffer
->clip_changed
1938 || beg_unchanged
< startp
)
1939 /* Forget any recorded base line for line number display. */
1940 w
->base_line_number
= Qnil
;
1944 cancel_my_columns (w
);
1948 struct position pos
;
1949 pos
= *compute_motion (PT
, 0, 0, 0,
1950 startp
, XFASTINT (w
->height
), 0,
1951 XFASTINT (w
->width
), XFASTINT (w
->hscroll
),
1952 pos_tab_offset (w
, startp
), w
);
1953 if (pos
.vpos
>= scroll_conservatively
)
1956 pos
= *vmotion (startp
, - pos
.vpos
- this_scroll_margin
, w
);
1958 if (! NILP (Vwindow_scroll_functions
))
1960 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
1961 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1962 make_number (pos
.bufpos
));
1963 pos
.bufpos
= marker_position (w
->start
);
1965 try_window (window
, pos
.bufpos
);
1966 if (cursor_vpos
>= 0)
1968 if (!just_this_one
|| current_buffer
->clip_changed
1969 || beg_unchanged
< startp
)
1970 /* Forget any recorded base line for line number display. */
1971 w
->base_line_number
= Qnil
;
1975 cancel_my_columns (w
);
1980 if (scroll_step
&& !current_buffer
->clip_changed
1981 && startp
>= BEGV
&& startp
<= ZV
)
1985 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), scroll_step
, w
);
1986 if (pos
.vpos
>= height
)
1990 pos
= *vmotion (startp
, (PT
< startp
? - scroll_step
: scroll_step
), w
);
1992 if (PT
>= pos
.bufpos
)
1994 if (! NILP (Vwindow_scroll_functions
))
1996 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
1997 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1998 make_number (pos
.bufpos
));
1999 pos
.bufpos
= marker_position (w
->start
);
2001 try_window (window
, pos
.bufpos
);
2002 if (cursor_vpos
>= 0)
2004 if (!just_this_one
|| current_buffer
->clip_changed
2005 || beg_unchanged
< startp
)
2006 /* Forget any recorded base line for line number display. */
2007 w
->base_line_number
= Qnil
;
2011 cancel_my_columns (w
);
2016 /* Finally, just choose place to start which centers point */
2019 /* Forget any previously recorded base line for line number display. */
2020 w
->base_line_number
= Qnil
;
2022 pos
= *vmotion (PT
, - (height
/ 2), w
);
2023 /* Set startp here explicitly in case that helps avoid an infinite loop
2024 in case the window-scroll-functions functions get errors. */
2025 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
2026 if (! NILP (Vwindow_scroll_functions
))
2028 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2029 make_number (pos
.bufpos
));
2030 pos
.bufpos
= marker_position (w
->start
);
2032 try_window (window
, pos
.bufpos
);
2034 startp
= marker_position (w
->start
);
2035 w
->start_at_line_beg
2036 = (startp
== BEGV
|| FETCH_BYTE (startp
- 1) == '\n') ? Qt
: Qnil
;
2039 if ((update_mode_line
2040 /* If window not full width, must redo its mode line
2041 if the window to its side is being redone */
2042 || (!just_this_one
&& !WINDOW_FULL_WIDTH_P (w
))
2043 || INTEGERP (w
->base_line_pos
)
2044 || (!NILP (w
->column_number_displayed
)
2045 && XFASTINT (w
->column_number_displayed
) != current_column ()))
2046 && height
!= XFASTINT (w
->height
))
2047 display_mode_line (w
);
2048 if (! line_number_displayed
2049 && ! BUFFERP (w
->base_line_pos
))
2051 w
->base_line_pos
= Qnil
;
2052 w
->base_line_number
= Qnil
;
2055 /* When we reach a frame's selected window, redo the frame's menu bar. */
2056 if (update_mode_line
2057 && (FRAME_WINDOW_P (f
)
2059 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
2060 FRAME_EXTERNAL_MENU_BAR (f
)
2062 FRAME_MENU_BAR_LINES (f
) > 0
2064 : FRAME_MENU_BAR_LINES (f
) > 0)
2065 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
2066 display_menu_bar (w
);
2069 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2071 int start
, end
, whole
;
2073 /* Calculate the start and end positions for the current window.
2074 At some point, it would be nice to choose between scrollbars
2075 which reflect the whole buffer size, with special markers
2076 indicating narrowing, and scrollbars which reflect only the
2079 Note that minibuffers sometimes aren't displaying any text. */
2080 if (! MINI_WINDOW_P (w
)
2081 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
2084 start
= marker_position (w
->start
) - BEGV
;
2085 /* I don't think this is guaranteed to be right. For the
2086 moment, we'll pretend it is. */
2087 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
2089 if (end
< start
) end
= start
;
2090 if (whole
< (end
- start
)) whole
= end
- start
;
2093 start
= end
= whole
= 0;
2095 /* Indicate what this scroll bar ought to be displaying now. */
2096 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
2098 /* Note that we actually used the scroll bar attached to this window,
2099 so it shouldn't be deleted at the end of redisplay. */
2100 (*redeem_scroll_bar_hook
) (w
);
2103 BUF_PT (current_buffer
) = opoint
;
2104 if (update_mode_line
)
2105 set_buffer_internal_1 (old
);
2107 set_buffer_temp (old
);
2108 BUF_PT (current_buffer
) = lpoint
;
2111 /* Do full redisplay on one window, starting at position `pos'. */
2114 try_window (window
, pos
)
2118 register struct window
*w
= XWINDOW (window
);
2119 register int height
= window_internal_height (w
);
2120 register int vpos
= XFASTINT (w
->top
);
2121 register int last_text_vpos
= vpos
;
2122 FRAME_PTR f
= XFRAME (w
->frame
);
2123 int width
= window_internal_width (w
) - 1;
2124 struct position val
;
2126 /* POS should never be out of range! */
2127 if (pos
< XBUFFER (w
->buffer
)->begv
2128 || pos
> XBUFFER (w
->buffer
)->zv
)
2131 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2133 overlay_arrow_seen
= 0;
2134 zv_strings_seen
= 0;
2135 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
2136 val
.ovstring_chars_done
= 0;
2137 val
.tab_offset
= pos_tab_offset (w
, pos
);
2139 while (--height
>= 0)
2141 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, val
.tab_offset
,
2142 val
.ovstring_chars_done
);
2143 /* The following code is omitted because we maintain tab_offset
2146 tab_offset
+= width
;
2147 if (val
.vpos
) tab_offset
= 0;
2150 if (pos
!= val
.bufpos
)
2153 #ifdef USE_TEXT_PROPERTIES
2154 Lisp_Object invis_prop
;
2155 invis_prop
= Fget_char_property (val
.bufpos
-1, Qinvisible
, window
);
2156 invis
= TEXT_PROP_MEANS_INVISIBLE (invis_prop
);
2160 /* Next line, unless prev line ended in end of buffer with no cr */
2162 && (FETCH_BYTE (val
.bufpos
- 1) != '\n' || invis
));
2167 /* If last line is continued in middle of character,
2168 include the split character in the text considered on the frame */
2169 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2172 /* If bottom just moved off end of frame, change mode line percentage. */
2173 if (XFASTINT (w
->window_end_pos
) == 0
2175 w
->update_mode_line
= Qt
;
2177 /* Say where last char on frame will be, once redisplay is finished. */
2178 XSETFASTINT (w
->window_end_pos
, Z
- pos
);
2179 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
- XFASTINT (w
->top
));
2180 /* But that is not valid info until redisplay finishes. */
2181 w
->window_end_valid
= Qnil
;
2184 /* Try to redisplay when buffer is modified locally,
2185 computing insert/delete line to preserve text outside
2186 the bounds of the changes.
2187 Return 1 if successful, 0 if if cannot tell what to do,
2188 or -1 to tell caller to find a new window start,
2189 or -2 to tell caller to do normal redisplay with same window start. */
2192 try_window_id (window
)
2196 register struct window
*w
= XWINDOW (window
);
2197 register int height
= window_internal_height (w
);
2198 FRAME_PTR f
= XFRAME (w
->frame
);
2199 int top
= XFASTINT (w
->top
);
2200 int start
= marker_position (w
->start
);
2201 int width
= window_internal_width (w
) - 1;
2202 int hscroll
= XINT (w
->hscroll
);
2203 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
2206 register int i
, tem
;
2207 int last_text_vpos
= 0;
2209 int selective
= (INTEGERP (current_buffer
->selective_display
)
2210 ? XINT (current_buffer
->selective_display
)
2211 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
2213 struct position val
, bp
, ep
, xp
, pp
;
2214 int scroll_amount
= 0;
2218 if (GPT
- BEG
< beg_unchanged
)
2219 beg_unchanged
= GPT
- BEG
;
2220 if (Z
- GPT
< end_unchanged
)
2221 end_unchanged
= Z
- GPT
;
2223 if (beg_unchanged
+ BEG
< start
)
2224 return 0; /* Give up if changes go above top of window */
2226 /* Find position before which nothing is changed. */
2227 bp
= *compute_motion (start
, 0, lmargin
, 0,
2228 min (ZV
, beg_unchanged
+ BEG
), height
,
2229 /* BUG FIX: See the comment of
2230 Fpos_visible_in_window_p() (window.c). */
2231 - (1 << (BITS_PER_SHORT
- 1)),
2232 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2233 if (bp
.vpos
>= height
)
2237 /* All changes are beyond the window end, and point is on the screen.
2238 We don't need to change the text at all.
2239 But we need to update window_end_pos to account for
2240 any change in buffer size. */
2241 bp
= *compute_motion (start
, 0, lmargin
, 0,
2243 /* BUG FIX: See the comment of
2244 Fpos_visible_in_window_p() (window.c). */
2245 - (1 << (BITS_PER_SHORT
- 1)),
2246 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2247 XSETFASTINT (w
->window_end_vpos
, height
);
2248 XSETFASTINT (w
->window_end_pos
, Z
- bp
.bufpos
);
2256 /* Find beginning of that frame line. Must display from there. */
2257 bp
= *vmotion (bp
.bufpos
, 0, w
);
2265 /* If about to start displaying at the beginning of a continuation line,
2266 really start with previous frame line, in case it was not
2267 continued when last redisplayed */
2268 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
2270 /* Likewise if we have to worry about selective display. */
2271 (selective
> 0 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
2273 bp
= *vmotion (bp
.bufpos
, -1, w
);
2277 val
.tab_offset
= bp
.tab_offset
; /* Update tab offset. */
2279 if (bp
.contin
&& bp
.hpos
!= lmargin
)
2281 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
2282 val
.tab_offset
= bp
.tab_offset
+ bp
.prevhpos
- width
;
2289 /* Find first visible newline after which no more is changed. */
2290 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
2292 while (tem
< ZV
- 1 && (indented_beyond_p (tem
, selective
)))
2293 tem
= find_next_newline (tem
, 1);
2295 /* Compute the cursor position after that newline. */
2296 ep
= *compute_motion (pos
, vpos
, val
.hpos
, did_motion
, tem
,
2297 height
, - (1 << (BITS_PER_SHORT
- 1)),
2299 /* We have tab offset in VAL, use it. */
2302 /* If changes reach past the text available on the frame,
2303 just display rest of frame. */
2304 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
2307 stop_vpos
= ep
.vpos
;
2309 /* If no newline before ep, the line ep is on includes some changes
2310 that must be displayed. Make sure we don't stop before it. */
2311 /* Also, if changes reach all the way until ep.bufpos,
2312 it is possible that something was deleted after the
2313 newline before it, so the following line must be redrawn. */
2314 if (stop_vpos
== ep
.vpos
2315 && (ep
.bufpos
== BEGV
2316 || FETCH_BYTE (ep
.bufpos
- 1) != '\n'
2317 || ep
.bufpos
== Z
- end_unchanged
))
2318 stop_vpos
= ep
.vpos
+ 1;
2321 overlay_arrow_seen
= 0;
2322 zv_strings_seen
= 0;
2324 /* If changes do not reach to bottom of window,
2325 figure out how much to scroll the rest of the window */
2326 if (stop_vpos
< height
)
2328 /* Now determine how far up or down the rest of the window has moved */
2329 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2330 Z
- XFASTINT (w
->window_end_pos
),
2331 /* Don't care for VPOS... */
2332 1 << (BITS_PER_SHORT
- 1),
2334 1 << (BITS_PER_SHORT
- 1),
2335 width
, hscroll
, ep
.tab_offset
, w
);
2336 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
2338 /* Is everything on frame below the changes whitespace?
2339 If so, no scrolling is really necessary. */
2340 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
2342 tem
= FETCH_BYTE (i
);
2343 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
2349 XSETFASTINT (w
->window_end_vpos
,
2350 XFASTINT (w
->window_end_vpos
) + scroll_amount
);
2352 /* Before doing any scrolling, verify that point will be on frame. */
2353 if (PT
> ep
.bufpos
&& !(PT
<= xp
.bufpos
&& xp
.vpos
< height
))
2355 if (PT
<= xp
.bufpos
)
2357 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2358 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2360 /* We have tab offset in EP, use it. */
2365 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
, 1,
2366 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2368 /* We have tab offset in XP, use it. */
2371 if (pp
.bufpos
< PT
|| pp
.vpos
== height
)
2373 cursor_vpos
= pp
.vpos
+ top
;
2374 cursor_hpos
= WINDOW_LEFT_MARGIN (w
) + minmax (0, pp
.hpos
, width
);
2377 if (stop_vpos
- scroll_amount
>= height
2378 || ep
.bufpos
== xp
.bufpos
)
2380 if (scroll_amount
< 0)
2381 stop_vpos
-= scroll_amount
;
2383 /* In this path, we have altered window_end_vpos
2384 and not left it negative.
2385 We must make sure that, in case display is preempted
2386 before the frame changes to reflect what we do here,
2387 further updates will not come to try_window_id
2388 and assume the frame and window_end_vpos match. */
2389 blank_end_of_window
= 1;
2391 else if (!scroll_amount
)
2393 /* Even if we don't need to scroll, we must adjust the
2394 charstarts of subsequent lines (that we won't redisplay)
2395 according to the amount of text inserted or deleted. */
2396 int oldpos
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2397 int adjust
= ep
.bufpos
- oldpos
;
2398 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1, adjust
);
2400 else if (bp
.bufpos
== Z
- end_unchanged
)
2402 /* If reprinting everything is nearly as fast as scrolling,
2403 don't bother scrolling. Can happen if lines are short. */
2404 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
2405 top
+ height
- max (0, scroll_amount
),
2407 > xp
.bufpos
- bp
.bufpos
- 20)
2408 /* Return "try normal display with same window-start."
2409 Too bad we can't prevent further scroll-thinking. */
2411 /* If pure deletion, scroll up as many lines as possible.
2412 In common case of killing a line, this can save the
2413 following line from being overwritten by scrolling
2414 and therefore having to be redrawn. */
2415 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
2416 top
+ height
- max (0, scroll_amount
),
2417 scroll_amount
, bp
.bufpos
);
2422 /* scroll_frame_lines did not properly adjust subsequent
2423 lines' charstarts in the case where the text of the
2424 screen line at bp.vpos has changed.
2425 (This can happen in a deletion that ends in mid-line.)
2426 To adjust properly, we need to make things consistent
2428 So do a second adjust to make that happen.
2429 Note that stop_vpos >= ep.vpos, so it is sufficient
2430 to update the charstarts for lines at ep.vpos and below. */
2432 = FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2433 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1,
2434 ep
.bufpos
- oldstart
);
2437 else if (scroll_amount
)
2439 /* If reprinting everything is nearly as fast as scrolling,
2440 don't bother scrolling. Can happen if lines are short. */
2441 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
2442 overestimate of cost of reprinting, since xp.bufpos
2443 would end up below the bottom of the window. */
2444 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
2445 top
+ height
- max (0, scroll_amount
),
2447 > xp
.bufpos
- ep
.bufpos
- 20)
2448 /* Return "try normal display with same window-start."
2449 Too bad we can't prevent further scroll-thinking. */
2451 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
2452 top
+ height
- max (0, scroll_amount
),
2453 scroll_amount
, ep
.bufpos
);
2454 if (!tem
) stop_vpos
= height
;
2458 /* In any case, do not display past bottom of window */
2459 if (stop_vpos
>= height
)
2465 /* Handle case where pos is before w->start --
2466 can happen if part of line had been clipped and is not clipped now */
2467 if (vpos
== 0 && pos
< marker_position (w
->start
))
2468 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2470 /* Redisplay the lines where the text was changed */
2471 last_text_vpos
= vpos
;
2472 /* The following code is omitted because we maintain tab offset in
2475 tab_offset
= pos_tab_offset (w
, pos
);
2476 /* If we are starting display in mid-character, correct tab_offset
2477 to account for passing the line that that character really starts in. */
2478 if (val
.hpos
< lmargin
)
2479 tab_offset
+= width
;
2482 while (vpos
< stop_vpos
)
2484 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, val
.tab_offset
,
2485 val
.ovstring_chars_done
);
2486 /* If display_text_line ran a hook and changed some text,
2487 redisplay all the way to bottom of buffer
2488 So that we show the changes. */
2489 if (old_tick
!= MODIFF
)
2491 /* The following code is omitted because we maintain tab offset
2492 in val.tab_offset. */
2494 tab_offset
+= width
;
2495 if (val
.vpos
) tab_offset
= 0;
2497 if (pos
!= val
.bufpos
)
2499 /* Next line, unless prev line ended in end of buffer with no cr */
2500 = vpos
- (val
.vpos
&& FETCH_BYTE (val
.bufpos
- 1) != '\n');
2504 /* There are two cases:
2505 1) we have displayed down to the bottom of the window
2506 2) we have scrolled lines below stop_vpos by scroll_amount */
2510 /* If last line is continued in middle of character,
2511 include the split character in the text considered on the frame */
2512 if (val
.hpos
< lmargin
)
2514 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
);
2515 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2518 /* If scrolling made blank lines at window bottom,
2519 redisplay to fill those lines */
2520 if (scroll_amount
< 0)
2522 /* Don't consider these lines for general-purpose scrolling.
2523 That will save time in the scrolling computation. */
2524 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
2528 val
.tab_offset
= xp
.tab_offset
;
2530 { /* Display from next line */
2531 vpos
= height
+ scroll_amount
;
2535 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
2537 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
2538 val
.tab_offset
= xp
.tab_offset
+ bp
.prevhpos
- width
;
2542 blank_end_of_window
= 1;
2543 /* The following code is omitted because we maintain tab offset
2544 in val.tab_offset. */
2546 tab_offset
= pos_tab_offset (w
, pos
);
2547 /* If we are starting display in mid-character, correct tab_offset
2548 to account for passing the line that that character starts in. */
2549 if (val
.hpos
< lmargin
)
2550 tab_offset
+= width
;
2552 while (vpos
< height
)
2554 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
,
2555 val
.tab_offset
, val
.ovstring_chars_done
);
2556 /* The following code is omitted because we maintain tab
2557 offset in val.tab_offset. */
2559 tab_offset
+= width
;
2560 if (val
.vpos
) tab_offset
= 0;
2565 /* Here is a case where display_text_line sets cursor_vpos wrong.
2566 Make it be fixed up, below. */
2572 /* If bottom just moved off end of frame, change mode line percentage. */
2573 if (XFASTINT (w
->window_end_pos
) == 0
2575 w
->update_mode_line
= Qt
;
2577 /* Attempt to adjust end-of-text positions to new bottom line */
2580 delta
= height
- xp
.vpos
;
2582 || (delta
> 0 && xp
.bufpos
<= ZV
)
2583 || (delta
== 0 && xp
.hpos
))
2585 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), delta
, w
);
2586 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2587 XSETFASTINT (w
->window_end_vpos
,
2588 XFASTINT (w
->window_end_vpos
) + val
.vpos
);
2592 w
->window_end_valid
= Qnil
;
2594 /* If point was not in a line that was displayed, find it */
2595 if (cursor_vpos
< 0)
2598 val
= *compute_motion (start
, 0, lmargin
, 0, PT
,
2599 /* Don't care for VPOS... */
2600 1 << (BITS_PER_SHORT
- 1),
2602 1 << (BITS_PER_SHORT
- 1),
2603 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2604 /* Admit failure if point is off frame now */
2605 if (val
.vpos
>= height
)
2607 for (vpos
= 0; vpos
< height
; vpos
++)
2608 cancel_line (vpos
+ top
, f
);
2611 cursor_vpos
= val
.vpos
+ top
;
2612 cursor_hpos
= WINDOW_LEFT_MARGIN (w
) + minmax (0, val
.hpos
, width
);
2615 FRAME_CURSOR_X (f
) = cursor_hpos
;
2616 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2620 val
= *compute_motion (start
, 0, lmargin
, 0, ZV
,
2621 height
, - (1 << (BITS_PER_SHORT
- 1)),
2622 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2623 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
2625 if (XFASTINT (w
->window_end_pos
)
2633 /* Copy LEN glyphs starting address FROM to the rope TO.
2634 But don't actually copy the parts that would come in before S.
2635 Value is TO, advanced past the copied data.
2636 F is the frame we are displaying in. */
2639 copy_part_of_rope (f
, to
, s
, from
, len
, face
)
2641 register GLYPH
*to
; /* Copy to here. */
2642 register GLYPH
*s
; /* Starting point. */
2643 Lisp_Object
*from
; /* Data to copy. */
2645 int face
; /* Face to apply to glyphs which don't specify one. */
2648 register Lisp_Object
*fp
= from
;
2649 /* These cache the results of the last call to compute_glyph_face. */
2651 int last_merged
= 0;
2654 if (! FRAME_TERMCAP_P (f
))
2657 GLYPH glyph
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
2659 unsigned int c
= FAST_GLYPH_CHAR (glyph
);
2662 /* For an invalid character code, use space. */
2665 if (FAST_GLYPH_FACE (glyph
) == 0)
2666 /* If GLYPH has no face code, use FACE. */
2668 else if (FAST_GLYPH_FACE (glyph
) == last_code
)
2669 /* If it's same as previous glyph, use same result. */
2670 facecode
= last_merged
;
2673 /* Merge this glyph's face and remember the result. */
2674 last_code
= FAST_GLYPH_FACE (glyph
);
2675 last_merged
= facecode
= compute_glyph_face (f
, last_code
, face
);
2679 *to
= FAST_MAKE_GLYPH (c
, facecode
);
2687 if (to
>= s
) *to
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
2694 /* Correct a glyph by replacing its specified user-level face code
2695 with a displayable computed face code. */
2698 fix_glyph (f
, glyph
, cface
)
2704 if (! FRAME_TERMCAP_P (f
))
2706 if (FAST_GLYPH_FACE (glyph
) != 0)
2707 cface
= compute_glyph_face (f
, FAST_GLYPH_FACE (glyph
), cface
);
2708 glyph
= FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph
), cface
);
2714 /* Display one line of window W, starting at position START in W's buffer.
2716 Display starting at horizontal position HPOS, expressed relative to
2717 W's left edge. In situations where the text at START shouldn't
2718 start at the left margin (i.e. when the window is hscrolled, or
2719 we're continuing a line which left off in the midst of a
2720 multi-column character), HPOS should be negative; we throw away
2721 characters up 'til hpos = 0. So, HPOS must take hscrolling into
2724 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
2726 OVSTR_DONE is the number of chars of overlay before/after strings
2727 at this position which have already been processed.
2729 Display on position VPOS on the frame. It is origin 0, relative to
2730 the top of the frame, not W.
2732 Returns a STRUCT POSITION giving character to start next line with
2733 and where to display it, including a zero or negative hpos.
2734 The vpos field is not really a vpos; it is 1 unless the line is continued */
2736 struct position val_display_text_line
;
2738 static struct position
*
2739 display_text_line (w
, start
, vpos
, hpos
, taboffset
, ovstr_done
)
2747 register int pos
= start
;
2751 register unsigned char *p
;
2753 register GLYPH
*leftmargin
;
2754 register GLYPH
*p1prev
;
2755 register GLYPH
*p1start
;
2758 FRAME_PTR f
= XFRAME (w
->frame
);
2759 int tab_width
= XINT (current_buffer
->tab_width
);
2760 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
2761 int width
= window_internal_width (w
) - 1;
2762 struct position val
;
2765 int last_invis_skip
= 0;
2766 Lisp_Object last_invis_prop
;
2767 int hscroll
= XINT (w
->hscroll
);
2768 int truncate
= (hscroll
2769 || (truncate_partial_width_windows
2770 && !WINDOW_FULL_WIDTH_P (w
))
2771 || !NILP (current_buffer
->truncate_lines
));
2773 /* 1 if we should highlight the region. */
2774 int highlight_region
2775 = (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
)
2776 && XWINDOW (current_buffer
->last_selected_window
) == w
);
2777 int region_beg
, region_end
;
2779 int selective
= (INTEGERP (current_buffer
->selective_display
)
2780 ? XINT (current_buffer
->selective_display
)
2781 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
2782 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
2783 register struct Lisp_Char_Table
*dp
= window_display_table (w
);
2785 Lisp_Object default_invis_vector
[3];
2786 /* Number of characters of ellipsis to display after an invisible line
2787 if it calls for an ellipsis.
2788 Note that this value can be nonzero regardless of whether
2789 selective display is enabled--you must check that separately. */
2791 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
2792 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
2793 : !NILP (current_buffer
->selective_display_ellipses
) ? 3 : 0);
2794 /* This is the sequence of Lisp objects to display
2795 when there are invisible lines. */
2796 Lisp_Object
*invis_vector_contents
2797 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
2798 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
2799 : default_invis_vector
);
2801 GLYPH truncator
= (dp
== 0 || !INTEGERP (DISP_TRUNC_GLYPH (dp
))
2802 || !GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (dp
)))
2803 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
2804 GLYPH continuer
= (dp
== 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp
))
2805 || !GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (dp
)))
2806 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
2808 /* If 1, we must handle multibyte characters. */
2809 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
2810 /* Length of multibyte form of each character. */
2812 /* Glyphs generated should be set this bit mask if text must be
2813 displayed from right to left. */
2814 GLYPH rev_dir_bit
= (NILP (current_buffer
->direction_reversed
)
2815 ? 0 : GLYPH_MASK_REV_DIR
);
2817 /* The next buffer location at which the face should change, due
2818 to overlays or text property changes. */
2819 int next_face_change
;
2821 /* The next location where the `invisible' property changes, or an
2822 overlay starts or ends. */
2825 /* The face we're currently using. */
2826 int current_face
= 0;
2829 XSETFASTINT (default_invis_vector
[2], '.');
2830 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
2832 hpos
+= WINDOW_LEFT_MARGIN (w
);
2833 get_display_line (f
, vpos
, WINDOW_LEFT_MARGIN (w
));
2834 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
2836 /* Show where to highlight the region. */
2837 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
2838 /* Maybe highlight only in selected window. */
2839 && (highlight_nonselected_windows
2840 || w
== XWINDOW (selected_window
)))
2842 region_beg
= marker_position (current_buffer
->mark
);
2843 if (PT
< region_beg
)
2845 region_end
= region_beg
;
2850 w
->region_showing
= Qt
;
2853 region_beg
= region_end
= -1;
2855 if (MINI_WINDOW_P (w
)
2857 && vpos
== XFASTINT (w
->top
))
2859 if (! NILP (minibuf_prompt
))
2861 minibuf_prompt_width
2862 = (display_string (w
, vpos
, XSTRING (minibuf_prompt
)->data
,
2863 XSTRING (minibuf_prompt
)->size
, hpos
,
2864 /* Display a space if we truncate. */
2867 /* Truncate the prompt a little before the
2868 margin, so user input can at least start
2869 on the first line. */
2870 w
->width
> 10 ? w
->width
- 4 : -1)
2872 hpos
+= minibuf_prompt_width
;
2873 taboffset
-= minibuf_prompt_width
;
2876 minibuf_prompt_width
= 0;
2879 /* If we're hscrolled at all, use compute_motion to skip over any
2880 text off the left edge of the window. compute_motion may know
2881 tricks to do this faster than we can. */
2884 struct position
*left_edge
2885 = compute_motion (pos
, vpos
, hpos
, 0,
2887 width
, hscroll
, taboffset
, w
);
2889 /* Retrieve the buffer position and column provided by
2890 compute_motion. We can't assume that the column will be
2891 zero, because you may have multi-column characters crossing
2894 compute_motion may have moved us past the screen position we
2895 requested, if we hit a multi-column character, or the end of
2896 the line. If so, back up. */
2897 if (left_edge
->vpos
> vpos
2898 || left_edge
->hpos
> 0)
2900 pos
= left_edge
->bufpos
;
2901 /* Since this should not be a valid multibyte character, we
2902 can decrease POS by 1. */
2904 hpos
= left_edge
->prevhpos
;
2908 pos
= left_edge
->bufpos
;
2909 hpos
= left_edge
->hpos
;
2913 desired_glyphs
->bufp
[vpos
] = start
;
2914 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2916 charstart
= desired_glyphs
->charstarts
[vpos
] + hpos
;
2917 /* In case we don't ever write anything into it... */
2918 desired_glyphs
->charstarts
[vpos
][WINDOW_LEFT_MARGIN (w
)] = -1;
2919 leftmargin
= desired_glyphs
->glyphs
[vpos
] + WINDOW_LEFT_MARGIN (w
);
2920 endp
= leftmargin
+ width
;
2922 /* Arrange the overlays nicely for our purposes. Usually, we call
2923 display_text_line on only one line at a time, in which case this
2924 can't really hurt too much, or we call it on lines which appear
2925 one after another in the buffer, in which case all calls to
2926 recenter_overlay_lists but the first will be pretty cheap. */
2927 recenter_overlay_lists (current_buffer
, pos
);
2929 /* Loop generating characters.
2930 Stop at end of buffer, before newline,
2931 if reach or pass continuation column,
2932 or at face change. */
2934 next_face_change
= pos
;
2935 next_boundary
= pos
;
2944 while (pos
== next_boundary
)
2946 Lisp_Object position
, limit
, prop
, ww
;
2948 /* Display the overlay strings here, unless we're at ZV
2949 and have already displayed the appropriate strings
2950 on an earlier line. */
2951 if (pos
< ZV
|| !zv_strings_seen
++)
2954 unsigned char *ovstr
;
2955 ovlen
= overlay_strings (pos
, w
, &ovstr
);
2959 /* Skip the ones we did in a previous line. */
2960 ovstr
+= ovstr_done
;
2961 ovlen
-= ovstr_done
;
2970 c
= STRING_CHAR_AND_LENGTH (ovstr
, ovlen
, len
);
2971 ovstr
+= len
, ovlen
-= len
, ovstr_done
+= len
;
2972 charset
= CHAR_CHARSET (c
);
2973 cols
= (charset
== CHARSET_COMPOSITION
2974 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
2975 : CHARSET_WIDTH (charset
));
2979 c
= *ovstr
++, ovlen
--, ovstr_done
++;
2982 g
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
2985 if (p1
>= leftmargin
&& p1
< endp
)
2986 *p1
= g
, g
|= GLYPH_MASK_PADDING
;
2990 /* If we did all the overlay strings
2991 and we have room for text, clear ovstr_done
2992 just for neatness' sake. */
2993 if (ovlen
== 0 && p1
< endp
)
2998 /* Did we reach point? Record the cursor location. */
2999 if (pos
== PT
&& cursor_vpos
< 0)
3002 cursor_hpos
= p1
- leftmargin
;
3008 XSETFASTINT (position
, pos
);
3009 limit
= Fnext_overlay_change (position
);
3010 #ifdef USE_TEXT_PROPERTIES
3011 /* This is just an estimate to give reasonable
3012 performance; nothing should go wrong if it is too small. */
3013 if (XFASTINT (limit
) > pos
+ 50)
3015 int limitpos
= pos
+ 50;
3017 INC_POS (limitpos
); /* Adjust to character boundary. */
3018 XSETFASTINT (limit
, limitpos
);
3020 limit
= Fnext_single_property_change (position
, Qinvisible
,
3021 Fcurrent_buffer (), limit
);
3023 next_boundary
= XFASTINT (limit
);
3024 /* if the `invisible' property is set, we can skip to
3025 the next property change. */
3027 prop
= Fget_char_property (position
, Qinvisible
, ww
);
3028 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
3030 if (pos
< PT
&& next_boundary
>= PT
)
3033 cursor_hpos
= p1
- leftmargin
;
3035 pos
= next_boundary
;
3036 last_invis_skip
= pos
;
3037 last_invis_prop
= prop
;
3041 /* Did we reach point? Record the cursor location. */
3042 if (pos
== PT
&& cursor_vpos
< 0)
3045 cursor_hpos
= p1
- leftmargin
;
3048 /* Did we hit the end of the visible region of the buffer?
3052 /* Update charstarts for the end of this line. */
3053 /* Do nothing if off the left edge or at the right edge. */
3054 if (p1
>= leftmargin
&& p1
+ 1 != endp
)
3056 int *p2x
= &charstart
[(p1
< leftmargin
3064 /* Figure out where (if at all) the
3065 redisplay_end_trigger-hook should run. */
3066 if (MARKERP (w
->redisplay_end_trigger
)
3067 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
3068 e_t_h
= marker_position (w
->redisplay_end_trigger
);
3069 else if (INTEGERP (w
->redisplay_end_trigger
))
3070 e_t_h
= XINT (w
->redisplay_end_trigger
);
3074 /* If we've gone past the place to run a hook,
3076 if (pos
>= e_t_h
&& e_t_h
!= ZV
)
3078 Lisp_Object args
[3];
3080 args
[0] = Qredisplay_end_trigger_functions
;
3081 XSETWINDOW (args
[1], w
);
3082 XSETINT (args
[2], e_t_h
);
3084 /* Since we are *trying* to run these functions,
3085 don't try to run them again, even if they get an error. */
3086 w
->redisplay_end_trigger
= Qnil
;
3087 Frun_hook_with_args (3, args
);
3090 /* Notice if it changed the face of this character. */
3091 next_face_change
= pos
;
3095 /* Did we hit a face change? Figure out what face we should
3096 use now. We also hit this the first time through the
3097 loop, to see what face we should start with. */
3098 if (pos
>= next_face_change
3099 && (FRAME_WINDOW_P (f
) || FRAME_MSDOS_P (f
)))
3101 int limit
= pos
+ 50;
3103 if (limit
< Z
&& !CHAR_HEAD_P (POS_ADDR (limit
)))
3104 INC_POS (limit
); /* Adjust to character boundary. */
3105 current_face
= compute_char_face (f
, w
, pos
,
3106 region_beg
, region_end
,
3107 &next_face_change
, limit
, 0);
3111 /* Compute the next place we need to stop
3112 and do something special; set PAUSE. */
3116 if (pos
< next_boundary
&& next_boundary
< pause
)
3117 pause
= next_boundary
;
3118 if (pos
< next_face_change
&& next_face_change
< pause
)
3119 pause
= next_face_change
;
3124 /* Wouldn't you hate to read the next line to someone over
3126 if (pos
< PT
&& PT
< pause
)
3128 if (pos
< GPT
&& GPT
< pause
)
3140 /* PAUSE is surely at character boundary. */
3141 c
= STRING_CHAR_AND_LENGTH (p
, pause
- pos
, len
), p
+= len
;
3144 /* Let a display table override all standard display methods. */
3145 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
3147 p1
= copy_part_of_rope (f
, p1
, leftmargin
,
3148 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
3149 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
3150 current_face
, rev_dir_bit
);
3152 else if (c
>= 040 && c
< 0177)
3154 if (p1
>= leftmargin
)
3155 *p1
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3161 if (last_invis_skip
== pos
3162 && TEXT_PROP_MEANS_INVISIBLE_WITH_ELLIPSIS (last_invis_prop
))
3166 && indented_beyond_p (pos
+ 1, selective
))
3169 pos
= find_next_newline (pos
+ 1, 1);
3170 if (FETCH_BYTE (pos
- 1) == '\n')
3173 if (invis
&& selective_rlen
> 0 && p1
>= leftmargin
)
3175 p1
+= selective_rlen
;
3176 if (p1
- leftmargin
> width
)
3178 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
3179 (p1
- p1prev
), current_face
, rev_dir_bit
);
3182 /* Draw the face of the newline character as extending all the
3183 way to the end of the frame line. */
3186 if (p1
< leftmargin
)
3189 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
) | rev_dir_bit
;
3193 /* Update charstarts for the newline that ended this line. */
3194 /* Do nothing here for a char that's entirely off the left edge
3195 or if it starts at the right edge. */
3196 if (p1
>= leftmargin
&& p1prev
!= endp
)
3198 /* Store the newline's position into charstarts
3199 for the column where the newline starts.
3200 Store -1 for the rest of the glyphs it occupies. */
3201 int *p2x
= &charstart
[(p1prev
< leftmargin
3202 ? leftmargin
: p1prev
)
3204 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3217 if (p1
>= leftmargin
&& p1
< endp
)
3218 *p1
= MAKE_GLYPH (f
, ' ', current_face
) | rev_dir_bit
;
3221 while ((p1
- leftmargin
+ taboffset
+ hscroll
- (hscroll
> 0))
3224 else if (c
== Ctl ('M') && selective
== -1)
3226 pos
= find_next_newline (pos
, 1);
3227 if (FETCH_BYTE (pos
- 1) == '\n')
3229 if (selective_rlen
> 0)
3231 p1
+= selective_rlen
;
3232 if (p1
- leftmargin
> width
)
3234 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
3235 (p1
- p1prev
), current_face
, rev_dir_bit
);
3238 /* Draw the face of the newline character as extending all the
3239 way to the end of the frame line. */
3242 if (p1
< leftmargin
)
3245 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
) | rev_dir_bit
;
3249 /* Update charstarts for the ^M that ended this line. */
3250 /* Do nothing here for a char that's entirely off the left edge
3251 or if it starts at the right edge. */
3252 if (p1
>= leftmargin
&& p1prev
!= endp
)
3254 /* Store the newline's position into charstarts
3255 for the column where the newline starts.
3256 Store -1 for the rest of the glyphs it occupies. */
3257 int *p2x
= &charstart
[(p1prev
< leftmargin
3258 ? leftmargin
: p1prev
)
3260 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3268 else if (c
< 0200 && ctl_arrow
)
3270 if (p1
>= leftmargin
)
3272 (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
3273 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp
)))
3274 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
3278 if (p1
>= leftmargin
&& p1
< endp
)
3279 *p1
= MAKE_GLYPH (f
, c
^ 0100, current_face
) | rev_dir_bit
;
3284 /* C is not a multibyte character. */
3285 if (p1
>= leftmargin
)
3287 (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
3288 && GLYPH_CHAR_VALID_P (DISP_ESCAPE_GLYPH (dp
))
3289 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
3293 if (p1
>= leftmargin
&& p1
< endp
)
3294 *p1
= MAKE_GLYPH (f
, (c
>> 6) + '0', current_face
) | rev_dir_bit
;
3296 if (p1
>= leftmargin
&& p1
< endp
)
3297 *p1
= (MAKE_GLYPH (f
, (7 & (c
>> 3)) + '0', current_face
)
3300 if (p1
>= leftmargin
&& p1
< endp
)
3301 *p1
= MAKE_GLYPH (f
, (7 & c
) + '0', current_face
) | rev_dir_bit
;
3306 /* C is a multibyte character. */
3307 int charset
= CHAR_CHARSET (c
);
3308 int columns
= (charset
== CHARSET_COMPOSITION
3309 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
3310 : CHARSET_WIDTH (charset
));
3311 GLYPH g
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3315 if (p1
>= leftmargin
&& p1
< endp
)
3316 *p1
= g
, g
|= GLYPH_MASK_PADDING
;
3324 /* Update charstarts for the character just output. */
3326 /* Do nothing here for a char that's entirely off the left edge. */
3327 if (p1
>= leftmargin
)
3329 /* Store the char's position into charstarts
3330 for the first glyph occupied by this char.
3331 Store -1 for the rest of the glyphs it occupies. */
3334 int *p2x
= &charstart
[(p1prev
< leftmargin
3335 ? leftmargin
: p1prev
)
3337 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3347 val
.hpos
= - XINT (w
->hscroll
);
3355 /* Store 0 in this charstart line for the positions where
3356 there is no character. But do leave what was recorded
3357 for the character that ended the line. */
3358 /* Add 1 in the endtest to compensate for the fact that ENDP was
3359 made from WIDTH, which is 1 less than the window's actual
3361 i
= p1
- p1start
+ 1;
3362 if (p1
< leftmargin
)
3363 i
+= leftmargin
- p1
;
3364 for (; i
< endp
- p1start
+ 1; i
++)
3367 /* Handle continuation in middle of a character */
3368 /* by backing up over it */
3371 /* Don't back up if we never actually displayed any text.
3372 This occurs when the minibuffer prompt takes up the whole line. */
3375 /* Start the next line with that same character whose
3376 character code is C and the length of multi-byte form is
3381 /* C is not a multi-byte character. We can break it and
3382 start from the middle column in the next line. So,
3383 adjust VAL.HPOS to skip the columns output on this
3385 val
.hpos
+= p1prev
- endp
;
3388 /* C is a multibyte character. Since we can't broke it
3389 in the middle, the whole character should be driven
3390 into the next line. */
3391 /* As the result, the actual columns occupied by the
3392 text on this line is less than WIDTH. VAL.TAB_OFFSET
3393 must be adjusted. */
3394 taboffset
= taboffset
+ (p1prev
- endp
);
3395 /* Let's fill unused columns with TRUNCATOR or CONTINUER. */
3397 GLYPH g
= fix_glyph (f
, truncate
? truncator
: continuer
, 0);
3398 while (p1prev
< endp
)
3401 /* If POINT is at POS, cursor should not on this line. */
3408 /* Keep in this line everything up to the continuation column. */
3412 /* Finish deciding which character to start the next line on,
3413 and what hpos to start it at.
3414 Also set `lastpos' to the last position which counts as "on this line"
3415 for cursor-positioning. */
3419 if (FETCH_BYTE (pos
) == '\n')
3421 /* If stopped due to a newline, start next line after it */
3424 /* Check again for hidden lines, in case the newline occurred exactly
3425 at the right margin. */
3426 while (pos
< ZV
&& selective
> 0
3427 && indented_beyond_p (pos
, selective
))
3428 pos
= find_next_newline (pos
, 1);
3431 /* Stopped due to right margin of window */
3435 *p1
++ = fix_glyph (f
, truncator
, 0);
3436 /* Truncating => start next line after next newline,
3437 and point is on this line if it is before the newline,
3438 and skip none of first char of next line */
3440 pos
= find_next_newline (pos
, 1);
3441 while (pos
< ZV
&& selective
> 0
3442 && indented_beyond_p (pos
, selective
));
3443 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
3445 lastpos
= pos
- (FETCH_BYTE (pos
- 1) == '\n');
3450 *p1
++ = fix_glyph (f
, continuer
, 0);
3453 val
.tab_offset
= taboffset
+ width
;
3460 /* If point is at eol or in invisible text at eol,
3461 record its frame location now. */
3463 if (start
<= PT
&& PT
<= lastpos
&& cursor_vpos
< 0)
3466 cursor_hpos
= p1
- leftmargin
;
3469 if (cursor_vpos
== vpos
)
3471 if (cursor_hpos
< 0) cursor_hpos
= 0;
3472 if (cursor_hpos
> width
) cursor_hpos
= width
;
3473 cursor_hpos
+= WINDOW_LEFT_MARGIN (w
);
3474 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
3476 if (!(cursor_in_echo_area
&& FRAME_HAS_MINIBUF_P (f
)
3477 && EQ (FRAME_MINIBUF_WINDOW (f
), minibuf_window
)))
3479 FRAME_CURSOR_Y (f
) = cursor_vpos
;
3480 FRAME_CURSOR_X (f
) = cursor_hpos
;
3483 if (w
== XWINDOW (selected_window
))
3485 /* Line is not continued and did not start
3486 in middle of character */
3487 if ((hpos
- WINDOW_LEFT_MARGIN (w
)
3488 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
3491 this_line_bufpos
= start
;
3492 this_line_buffer
= current_buffer
;
3493 this_line_vpos
= cursor_vpos
;
3494 this_line_start_hpos
= hpos
;
3495 this_line_endpos
= Z
- lastpos
;
3498 this_line_bufpos
= 0;
3503 /* If hscroll and line not empty, insert truncation-at-left marker */
3504 if (hscroll
&& lastpos
!= start
)
3506 GLYPH g
= fix_glyph (f
, truncator
, 0);
3508 if (p1
<= leftmargin
)
3509 p1
= leftmargin
+ 1;
3510 else /* MULE: it may be a wide-column character */
3512 p1prev
= leftmargin
+ 1;
3513 while (p1prev
< p1
&& *p1prev
& GLYPH_MASK_PADDING
)
3518 if (!WINDOW_RIGHTMOST_P (w
))
3521 if (p1
< leftmargin
) p1
= leftmargin
;
3522 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
3524 /* Don't draw vertical bars if we're using scroll bars. They're
3525 covered up by the scroll bars, and it's distracting to see
3526 them when the scroll bar windows are flickering around to be
3528 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
3531 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
3534 else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3535 *p1
++ = (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
3536 ? DISP_BORDER_GLYPH (dp
)
3539 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
3540 p1
- desired_glyphs
->glyphs
[vpos
]);
3541 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
3543 /* If the start of this line is the overlay arrow-position,
3544 then put the arrow string into the display-line. */
3546 if (MARKERP (Voverlay_arrow_position
)
3547 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
3548 && start
== marker_position (Voverlay_arrow_position
)
3549 && STRINGP (Voverlay_arrow_string
)
3550 && ! overlay_arrow_seen
)
3552 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
3554 int len
= XSTRING (Voverlay_arrow_string
)->size
;
3560 if (!NULL_INTERVAL_P (XSTRING (Voverlay_arrow_string
)->intervals
))
3562 /* If the arrow string has text props, obey them when displaying. */
3563 for (i
= 0; i
< len
; i
++)
3566 Lisp_Object face
, ilisp
;
3569 XSETFASTINT (ilisp
, i
);
3570 face
= Fget_text_property (ilisp
, Qface
, Voverlay_arrow_string
);
3571 newface
= compute_glyph_face_1 (f
, face
, 0);
3572 leftmargin
[i
] = FAST_MAKE_GLYPH (c
, newface
);
3576 #endif /* HAVE_FACES */
3578 for (i
= 0; i
< len
; i
++)
3579 leftmargin
[i
] = p
[i
];
3582 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
3583 arrow_end
= (leftmargin
- desired_glyphs
->glyphs
[vpos
]) + len
;
3584 if (desired_glyphs
->used
[vpos
] < arrow_end
)
3585 desired_glyphs
->used
[vpos
] = arrow_end
;
3587 overlay_arrow_seen
= 1;
3591 val
.ovstring_chars_done
= ovstr_done
;
3592 val_display_text_line
= val
;
3593 return &val_display_text_line
;
3596 /* Redisplay the menu bar in the frame for window W. */
3599 display_menu_bar (w
)
3602 Lisp_Object items
, tail
;
3603 register int vpos
= 0;
3604 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3605 int maxendcol
= FRAME_WIDTH (f
);
3610 if (!NILP (Vwindow_system
))
3614 #ifdef USE_X_TOOLKIT
3617 #endif /* USE_X_TOOLKIT */
3619 get_display_line (f
, vpos
, 0);
3621 items
= FRAME_MENU_BAR_ITEMS (f
);
3622 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
3624 Lisp_Object pos
, string
;
3625 string
= XVECTOR (items
)->contents
[i
+ 1];
3629 XSETFASTINT (XVECTOR (items
)->contents
[i
+ 3], hpos
);
3631 if (hpos
< maxendcol
)
3632 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
3633 XSTRING (string
)->data
,
3634 XSTRING (string
)->size
,
3635 hpos
, 0, 0, hpos
, maxendcol
);
3636 /* Put a space between items. */
3637 if (hpos
< maxendcol
)
3639 int hpos1
= hpos
+ 1;
3640 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0,
3641 min (hpos1
, maxendcol
), maxendcol
);
3645 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
3646 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
3648 /* Fill out the line with spaces. */
3649 if (maxendcol
> hpos
)
3650 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0, maxendcol
, maxendcol
);
3652 /* Clear the rest of the lines allocated to the menu bar. */
3654 while (vpos
< FRAME_MENU_BAR_LINES (f
))
3655 get_display_line (f
, vpos
++, 0);
3658 /* Display the mode line for window w */
3661 display_mode_line (w
)
3664 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
3665 register int left
= WINDOW_LEFT_MARGIN (w
);
3666 register int right
= WINDOW_RIGHT_MARGIN (w
);
3667 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3669 line_number_displayed
= 0;
3670 w
->column_number_displayed
= Qnil
;
3672 get_display_line (f
, vpos
, left
);
3674 /* Temporarily make frame F's kboard the current kboard
3675 so that kboard-local variables in the mode_line_format
3676 will get the right values. */
3677 push_frame_kboard (f
);
3679 display_mode_element (w
, vpos
, left
, 0, right
, right
,
3680 current_buffer
->mode_line_format
);
3682 pop_frame_kboard ();
3684 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
3686 /* Put the mode line in inverse video.
3687 Use faces if possible, since that lets us handle
3688 partial-width windows and avoid inverting the scroll bar columns. */
3690 if (! FRAME_TERMCAP_P (f
) && mode_line_inverse_video
)
3692 /* For a partial width window, explicitly set face of each glyph. */
3694 unsigned int padding
;
3695 GLYPH
*ptr
= FRAME_DESIRED_GLYPHS (f
)->glyphs
[vpos
];
3696 for (i
= left
; i
< right
; ++i
)
3698 padding
= ptr
[i
] & GLYPH_MASK_PADDING
;
3699 ptr
[i
] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr
[i
]), 1) | padding
;
3705 /* Make the mode line inverse video if the entire line
3706 is made of mode lines.
3707 I.e. if this window is full width,
3708 or if it is the child of a full width window
3709 (which implies that that window is split side-by-side
3710 and the rest of this line is mode lines of the sibling windows). */
3711 if (WINDOW_FULL_WIDTH_P (w
)
3712 || WINDOW_FULL_WIDTH_P (XWINDOW (w
->parent
)))
3713 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
3716 /* Contribute ELT to the mode line for window W.
3717 How it translates into text depends on its data type.
3719 VPOS is the position of the mode line being displayed.
3721 HPOS is the position (absolute on frame) where this element's text
3722 should start. The output is truncated automatically at the right
3725 DEPTH is the depth in recursion. It is used to prevent
3726 infinite recursion here.
3728 MINENDCOL is the hpos before which the element may not end.
3729 The element is padded at the right with spaces if nec
3730 to reach this column.
3732 MAXENDCOL is the hpos past which this element may not extend.
3733 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
3734 (This is necessary to make nested padding and truncation work.)
3736 Returns the hpos of the end of the text generated by ELT.
3737 The next element will receive that value as its HPOS arg,
3738 so as to concatenate the elements. */
3741 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
3743 register int vpos
, hpos
;
3746 register int maxendcol
;
3747 register Lisp_Object elt
;
3755 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
3759 /* A string: output it and check for %-constructs within it. */
3760 register unsigned char c
;
3761 register unsigned char *this = XSTRING (elt
)->data
;
3763 while (hpos
< maxendcol
&& *this)
3765 unsigned char *last
= this;
3766 while ((c
= *this++) != '\0' && c
!= '%')
3768 if (this - 1 != last
)
3770 register int lim
= --this - last
+ hpos
;
3771 if (frame_title_ptr
)
3772 hpos
= store_frame_title (last
, hpos
, min (lim
, maxendcol
));
3774 hpos
= display_string (w
, vpos
, last
, -1, hpos
, 0, 1,
3775 hpos
, min (lim
, maxendcol
));
3779 register int minendcol
;
3780 register int spec_width
= 0;
3782 /* We can't allow -ve args due to the "%-" construct */
3783 /* Argument specifies minwidth but not maxwidth
3784 (maxwidth can be specified by
3785 (<negative-number> . <stuff>) mode-line elements) */
3787 while ((c
= *this++) >= '0' && c
<= '9')
3789 spec_width
= spec_width
* 10 + (c
- '0');
3792 minendcol
= hpos
+ spec_width
;
3793 if (minendcol
> maxendcol
)
3795 spec_width
= maxendcol
- hpos
;
3796 minendcol
= maxendcol
;
3800 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
3801 spec_width
, maxendcol
,
3802 Vglobal_mode_string
);
3805 char *spec
= decode_mode_spec (w
, c
, spec_width
,
3807 if (frame_title_ptr
)
3808 hpos
= store_frame_title (spec
, minendcol
, maxendcol
);
3810 hpos
= display_string (w
, vpos
, spec
, -1,
3812 minendcol
, maxendcol
);
3820 /* A symbol: process the value of the symbol recursively
3821 as if it appeared here directly. Avoid error if symbol void.
3822 Special case: if value of symbol is a string, output the string
3825 register Lisp_Object tem
;
3826 tem
= Fboundp (elt
);
3829 tem
= Fsymbol_value (elt
);
3830 /* If value is a string, output that string literally:
3831 don't check for % within it. */
3834 if (frame_title_ptr
)
3835 hpos
= store_frame_title (XSTRING (tem
)->data
,
3836 minendcol
, maxendcol
);
3838 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
3839 XSTRING (tem
)->size
,
3840 hpos
, 0, 1, minendcol
, maxendcol
);
3842 /* Give up right away for nil or t. */
3843 else if (!EQ (tem
, elt
))
3844 { elt
= tem
; goto tail_recurse
; }
3851 register Lisp_Object car
, tem
;
3853 /* A cons cell: three distinct cases.
3854 If first element is a string or a cons, process all the elements
3855 and effectively concatenate them.
3856 If first element is a negative number, truncate displaying cdr to
3857 at most that many characters. If positive, pad (with spaces)
3858 to at least that many characters.
3859 If first element is a symbol, process the cadr or caddr recursively
3860 according to whether the symbol's value is non-nil or nil. */
3861 car
= XCONS (elt
)->car
;
3864 tem
= Fboundp (car
);
3865 elt
= XCONS (elt
)->cdr
;
3868 /* elt is now the cdr, and we know it is a cons cell.
3869 Use its car if CAR has a non-nil value. */
3872 tem
= Fsymbol_value (car
);
3874 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
3876 /* Symbol's value is nil (or symbol is unbound)
3877 Get the cddr of the original list
3878 and if possible find the caddr and use that. */
3879 elt
= XCONS (elt
)->cdr
;
3882 else if (!CONSP (elt
))
3884 elt
= XCONS (elt
)->car
;
3887 else if (INTEGERP (car
))
3889 register int lim
= XINT (car
);
3890 elt
= XCONS (elt
)->cdr
;
3892 /* Negative int means reduce maximum width.
3893 DO NOT change MINENDCOL here!
3894 (20 -10 . foo) should truncate foo to 10 col
3895 and then pad to 20. */
3896 maxendcol
= min (maxendcol
, hpos
- lim
);
3899 /* Padding specified. Don't let it be more than
3902 if (lim
> maxendcol
)
3904 /* If that's more padding than already wanted, queue it.
3905 But don't reduce padding already specified even if
3906 that is beyond the current truncation point. */
3907 if (lim
> minendcol
)
3912 else if (STRINGP (car
) || CONSP (car
))
3914 register int limit
= 50;
3915 /* LIMIT is to protect against circular lists. */
3916 while (CONSP (elt
) && --limit
> 0
3917 && hpos
< maxendcol
)
3919 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
3922 elt
= XCONS (elt
)->cdr
;
3930 if (frame_title_ptr
)
3931 hpos
= store_frame_title ("*invalid*", minendcol
, maxendcol
);
3933 hpos
= display_string (w
, vpos
, "*invalid*", -1, hpos
, 0, 1,
3934 minendcol
, maxendcol
);
3938 if (minendcol
> hpos
)
3939 if (frame_title_ptr
)
3940 hpos
= store_frame_title ("", minendcol
, maxendcol
);
3942 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 1, minendcol
, maxendcol
);
3946 /* Write a null-terminated, right justified decimal representation of
3947 the positive integer D to BUF using a minimal field width WIDTH. */
3950 pint2str (buf
, width
, d
)
3955 register char *p
= buf
;
3962 *p
++ = d
% 10 + '0';
3965 for (width
-= (int) (p
- buf
); width
> 0; --width
) *p
++ = ' ';
3975 /* Set a mnemonic character for CODING_SYSTEM (Lisp symbol) in BUF.
3976 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
3977 type of CODING_SYSTEM. Return updated pointer into BUF. */
3980 decode_mode_spec_coding (coding_system
, buf
, eol_flag
)
3981 Lisp_Object coding_system
;
3985 register Lisp_Object val
= coding_system
;
3987 if (NILP (val
)) /* Not yet decided. */
3990 if (eol_flag
) *buf
++ = eol_mnemonic_undecided
;
3994 while (!NILP (val
) && SYMBOLP (val
))
3995 val
= Fget (val
, Qcoding_system
);
3996 *buf
++ = XFASTINT (XVECTOR (val
)->contents
[1]);
3999 val
= Fget (coding_system
, Qeol_type
);
4001 if (NILP (val
)) /* Not yet decided. */
4002 *buf
++ = eol_mnemonic_undecided
;
4003 else if (VECTORP (val
)) /* Not yet decided. */
4004 *buf
++ = eol_mnemonic_undecided
;
4005 else /* INTEGERP (val) -- 1:LF, 2:CRLF, 3:CR */
4006 *buf
++ = (XFASTINT (val
) == 1
4008 : (XFASTINT (val
) == 2
4009 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
4015 /* Return a string for the output of a mode line %-spec for window W,
4016 generated by character C. SPEC_WIDTH is the field width when
4017 padding to the left (%c, %l). The value returned from this
4018 function will later be truncated to width MAXWIDTH. */
4020 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
4023 decode_mode_spec (w
, c
, spec_width
, maxwidth
)
4026 register int spec_width
;
4027 register int maxwidth
;
4030 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4031 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
4032 struct buffer
*b
= XBUFFER (w
->buffer
);
4035 if (maxwidth
> FRAME_WIDTH (f
))
4036 maxwidth
= FRAME_WIDTH (f
);
4041 if (!NILP (b
->read_only
))
4043 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4048 /* This differs from %* only for a modified read-only buffer. */
4049 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4051 if (!NILP (b
->read_only
))
4056 /* This differs from %* in ignoring read-only-ness. */
4057 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4069 if (command_loop_level
> 5)
4071 p
= decode_mode_spec_buf
;
4072 for (i
= 0; i
< command_loop_level
; i
++)
4075 return decode_mode_spec_buf
;
4083 if (command_loop_level
> 5)
4085 p
= decode_mode_spec_buf
;
4086 for (i
= 0; i
< command_loop_level
; i
++)
4089 return decode_mode_spec_buf
;
4097 if (maxwidth
< sizeof (lots_of_dashes
))
4098 return lots_of_dashes
;
4101 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
4105 return decode_mode_spec_buf
;
4111 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
4113 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
4114 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
4115 decode_mode_spec_buf
[maxwidth
] = '\0';
4116 return decode_mode_spec_buf
;
4123 int col
= current_column ();
4124 XSETFASTINT (w
->column_number_displayed
, col
);
4125 pint2str (decode_mode_spec_buf
, spec_width
, col
);
4126 return decode_mode_spec_buf
;
4130 /* %F displays the frame name. */
4131 if (!NILP (f
->title
))
4132 return (char *) XSTRING (f
->title
)->data
;
4133 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
4134 return (char *) XSTRING (f
->name
)->data
;
4142 else if (STRINGP (obj
) && XSTRING (obj
)->size
> maxwidth
)
4144 bcopy ("...", decode_mode_spec_buf
, 3);
4145 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
4146 decode_mode_spec_buf
+ 3, maxwidth
- 3);
4147 return decode_mode_spec_buf
;
4154 int startpos
= marker_position (w
->start
);
4155 int line
, linepos
, topline
;
4158 int height
= XFASTINT (w
->height
);
4160 /* If we decided that this buffer isn't suitable for line numbers,
4161 don't forget that too fast. */
4162 if (EQ (w
->base_line_pos
, w
->buffer
))
4164 /* But do forget it, if the window shows a different buffer now. */
4165 else if (BUFFERP (w
->base_line_pos
))
4166 w
->base_line_pos
= Qnil
;
4168 /* If the buffer is very big, don't waste time. */
4169 if (BUF_ZV (b
) - BUF_BEGV (b
) > line_number_display_limit
)
4171 w
->base_line_pos
= Qnil
;
4172 w
->base_line_number
= Qnil
;
4176 if (!NILP (w
->base_line_number
)
4177 && !NILP (w
->base_line_pos
)
4178 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
4180 line
= XFASTINT (w
->base_line_number
);
4181 linepos
= XFASTINT (w
->base_line_pos
);
4186 linepos
= BUF_BEGV (b
);
4189 /* Count lines from base line to window start position. */
4190 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
4192 topline
= nlines
+ line
;
4194 /* Determine a new base line, if the old one is too close
4195 or too far away, or if we did not have one.
4196 "Too close" means it's plausible a scroll-down would
4198 if (startpos
== BUF_BEGV (b
))
4200 XSETFASTINT (w
->base_line_number
, topline
);
4201 XSETFASTINT (w
->base_line_pos
, BUF_BEGV (b
));
4203 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
4204 || linepos
== BUF_BEGV (b
))
4206 int limit
= BUF_BEGV (b
);
4208 int distance
= (height
* 2 + 30) * 200;
4210 if (startpos
- distance
> limit
)
4211 limit
= startpos
- distance
;
4213 nlines
= display_count_lines (startpos
, limit
,
4216 /* If we couldn't find the lines we wanted within
4218 give up on line numbers for this window. */
4219 if (position
== startpos
- distance
)
4221 w
->base_line_pos
= w
->buffer
;
4222 w
->base_line_number
= Qnil
;
4226 XSETFASTINT (w
->base_line_number
, topline
- nlines
);
4227 XSETFASTINT (w
->base_line_pos
, position
);
4230 /* Now count lines from the start pos to point. */
4231 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
4233 /* Record that we did display the line number. */
4234 line_number_displayed
= 1;
4236 /* Make the string to show. */
4237 pint2str (decode_mode_spec_buf
, spec_width
, topline
+ nlines
);
4238 return decode_mode_spec_buf
;
4241 char* p
= decode_mode_spec_buf
;
4242 for (spec_width
-= 2; spec_width
> 0; --spec_width
) *p
++ = ' ';
4244 return decode_mode_spec_buf
;
4254 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
4260 int pos
= marker_position (w
->start
);
4261 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
4263 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
4265 if (pos
<= BUF_BEGV (b
))
4270 else if (pos
<= BUF_BEGV (b
))
4274 if (total
> 1000000)
4275 /* Do it differently for a large value, to avoid overflow. */
4276 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
4278 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
4279 /* We can't normally display a 3-digit number,
4280 so get us a 2-digit number that is close. */
4283 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
4284 return decode_mode_spec_buf
;
4288 /* Display percentage of size above the bottom of the screen. */
4291 int toppos
= marker_position (w
->start
);
4292 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
4293 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
4295 if (botpos
>= BUF_ZV (b
))
4297 if (toppos
<= BUF_BEGV (b
))
4304 if (total
> 1000000)
4305 /* Do it differently for a large value, to avoid overflow. */
4306 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
4308 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
4309 /* We can't normally display a 3-digit number,
4310 so get us a 2-digit number that is close. */
4313 if (toppos
<= BUF_BEGV (b
))
4314 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
4316 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
4317 return decode_mode_spec_buf
;
4322 /* status of process */
4323 obj
= Fget_buffer_process (w
->buffer
);
4325 return "no process";
4327 obj
= Fsymbol_name (Fprocess_status (obj
));
4331 case 't': /* indicate TEXT or BINARY */
4332 #ifdef MODE_LINE_BINARY_TEXT
4333 return MODE_LINE_BINARY_TEXT (b
);
4339 /* coding-system (not including end-of-line format) */
4341 /* coding-system (including end-of-line type) */
4343 int eol_flag
= (c
== 'Z');
4346 p
= decode_mode_spec_coding
4347 (find_symbol_value (Qbuffer_file_coding_system
),
4348 decode_mode_spec_buf
, eol_flag
);
4349 if (FRAME_TERMCAP_P (f
))
4351 p
= decode_mode_spec_coding (keyboard_coding
.symbol
, p
, eol_flag
);
4352 p
= decode_mode_spec_coding (terminal_coding
.symbol
, p
, eol_flag
);
4355 obj
= Fget_buffer_process (Fcurrent_buffer ());
4358 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
4360 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
4363 #endif /* subprocesses */
4365 return decode_mode_spec_buf
;
4370 return (char *) XSTRING (obj
)->data
;
4375 /* Search for COUNT instances of a line boundary, which means either a
4376 newline or (if selective display enabled) a carriage return.
4377 Start at START. If COUNT is negative, search backwards.
4379 If we find COUNT instances, set *SHORTAGE to zero, and return the
4380 position after the COUNTth match. Note that for reverse motion
4381 this is not the same as the usual convention for Emacs motion commands.
4383 If we don't find COUNT instances before reaching the end of the
4384 buffer (or the beginning, if scanning backwards), set *SHORTAGE to
4385 the number of line boundaries left unfound, and return the end of the
4386 buffer we bumped up against. */
4389 display_scan_buffer (start
, count
, shortage
)
4390 int *shortage
, start
;
4393 int limit
= ((count
> 0) ? ZV
- 1 : BEGV
);
4394 int direction
= ((count
> 0) ? 1 : -1);
4396 register unsigned char *cursor
;
4397 unsigned char *base
;
4399 register int ceiling
;
4400 register unsigned char *ceiling_addr
;
4402 /* If we are not in selective display mode,
4403 check only for newlines. */
4404 if (! (!NILP (current_buffer
->selective_display
)
4405 && !INTEGERP (current_buffer
->selective_display
)))
4406 return scan_buffer ('\n', start
, 0, count
, shortage
, 0);
4408 /* The code that follows is like scan_buffer
4409 but checks for either newline or carriage return. */
4415 while (start
!= limit
+ 1)
4417 ceiling
= BUFFER_CEILING_OF (start
);
4418 ceiling
= min (limit
, ceiling
);
4419 ceiling_addr
= POS_ADDR (ceiling
) + 1;
4420 base
= (cursor
= POS_ADDR (start
));
4423 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
4425 if (cursor
!= ceiling_addr
)
4430 return (start
+ cursor
- base
+ 1);
4433 if (++cursor
== ceiling_addr
)
4439 start
+= cursor
- base
;
4443 start
--; /* first character we scan */
4444 while (start
> limit
- 1)
4445 { /* we WILL scan under start */
4446 ceiling
= BUFFER_FLOOR_OF (start
);
4447 ceiling
= max (limit
, ceiling
);
4448 ceiling_addr
= POS_ADDR (ceiling
) - 1;
4449 base
= (cursor
= POS_ADDR (start
));
4453 while (--cursor
!= ceiling_addr
4454 && *cursor
!= '\n' && *cursor
!= 015)
4456 if (cursor
!= ceiling_addr
)
4461 return (start
+ cursor
- base
+ 1);
4467 start
+= cursor
- base
;
4472 *shortage
= count
* direction
;
4473 return (start
+ ((direction
== 1 ? 0 : 1)));
4476 /* Count up to N lines starting from FROM.
4477 But don't go beyond LIMIT.
4478 Return the number of lines thus found (always positive).
4479 Store the position after what was found into *POS_PTR. */
4482 display_count_lines (from
, limit
, n
, pos_ptr
)
4495 *pos_ptr
= display_scan_buffer (from
, n
, &shortage
);
4501 /* When scanning backwards, scan_buffer stops *after* the last newline
4502 it finds, but does count it. Compensate for that. */
4503 return - n
- shortage
- (*pos_ptr
!= limit
);
4504 return n
- shortage
;
4507 /* Display STRING on one line of window W, starting at HPOS.
4508 Display at position VPOS. Caller should have done get_display_line.
4509 If VPOS == -1, display it as the current frame's title.
4510 LENGTH is the length of STRING, or -1 meaning STRING is null-terminated.
4512 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
4514 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
4515 MAXCOL is the last column ok to end at. Truncate here.
4516 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
4517 Both count from the left edge of the frame, as does HPOS.
4518 The right edge of W is an implicit maximum.
4519 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
4521 OBEY_WINDOW_WIDTH says to put spaces or vertical bars
4522 at the place where the current window ends in this line
4523 and not display anything beyond there. Otherwise, only MAXCOL
4524 controls where to stop output.
4526 Returns ending hpos. */
4529 display_string (w
, vpos
, string
, length
, hpos
, truncate
,
4530 obey_window_width
, mincol
, maxcol
)
4532 unsigned char *string
;
4536 int obey_window_width
;
4542 int hscroll
= XINT (w
->hscroll
);
4543 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
4544 register GLYPH
*start
;
4545 register GLYPH
*end
;
4546 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4547 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
4548 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
4549 int window_width
= XFASTINT (w
->width
);
4550 /* If 1, we must display multibyte characters. */
4551 int multibyte
= !NILP (XBUFFER (w
->buffer
)->enable_multibyte_characters
);
4553 /* Use the standard display table, not the window's display table.
4554 We don't want the mode line in rot13. */
4555 register struct Lisp_Char_Table
*dp
= 0;
4558 if (DISP_TABLE_P (Vstandard_display_table
))
4559 dp
= XCHAR_TABLE (Vstandard_display_table
);
4561 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
4564 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
4566 if (obey_window_width
)
4568 end
= start
+ window_width
- (truncate
!= 0);
4570 if (!WINDOW_RIGHTMOST_P (w
))
4572 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4576 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
4579 else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4584 if (! obey_window_width
4585 || (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
))
4586 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
4588 /* Store 0 in charstart for these columns. */
4589 for (i
= (hpos
>= 0 ? hpos
: 0); i
< end
- p1start
+ hpos
; i
++)
4590 desired_glyphs
->charstarts
[vpos
][i
] = 0;
4592 if (maxcol
>= 0 && mincol
> maxcol
)
4596 /* We need this value for multibyte characters. */
4597 length
= strlen (string
);
4599 /* We set truncated to 1 if we get stopped by trying to pass END
4600 (that is, trying to pass MAXCOL.) */
4609 c
= STRING_CHAR_AND_LENGTH (string
, length
, len
);
4611 c
= *string
, len
= 1;
4613 string
+= len
, length
-= len
;
4621 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
4623 p1
= copy_part_of_rope (f
, p1
, start
,
4624 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
4625 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
4628 else if (c
>= 040 && c
< 0177)
4638 if (p1
>= start
&& p1
< end
)
4642 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
4644 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
4648 (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
4649 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp
)))
4650 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
4653 if (p1
>= start
&& p1
< end
)
4659 /* C is a control character or a binary byte data. */
4662 (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
4663 && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp
)))
4664 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
4667 if (p1
>= start
&& p1
< end
)
4668 *p1
= (c
>> 6) + '0';
4670 if (p1
>= start
&& p1
< end
)
4671 *p1
= (7 & (c
>> 3)) + '0';
4673 if (p1
>= start
&& p1
< end
)
4674 *p1
= (7 & c
) + '0';
4679 /* C is a multibyte character. */
4680 int charset
= CHAR_CHARSET (c
);
4681 int columns
= (charset
== CHARSET_COMPOSITION
4682 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
4683 : CHARSET_WIDTH (charset
));
4687 /* Since we can't show the left part of C, fill all
4688 columns with spaces. */
4689 columns
-= start
- p1
;
4698 else if (p1
+ columns
> end
)
4700 /* Since we can't show the right part of C, fill all
4701 columns with TRUNCATE if TRUNCATE is specified. */
4705 *p1
++ = fix_glyph (f
, truncate
, 0);
4706 /* And tell the line is truncated. */
4713 /* We can show the whole glyph of C. */
4716 *p1
++ = c
| GLYPH_MASK_PADDING
;
4724 if (truncate
) *p1
++ = fix_glyph (f
, truncate
, 0);
4726 else if (mincol
>= 0)
4728 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
4734 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
4736 if (len
> desired_glyphs
->used
[vpos
])
4737 desired_glyphs
->used
[vpos
] = len
;
4738 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
4744 /* This is like a combination of memq and assq.
4745 Return 1 if PROPVAL appears as an element of LIST
4746 or as the car of an element of LIST.
4747 If PROPVAL is a list, compare each element against LIST
4748 in that way, and return 1 if any element of PROPVAL is found in LIST.
4750 This function cannot quit. */
4753 invisible_p (propval
, list
)
4754 register Lisp_Object propval
;
4757 register Lisp_Object tail
, proptail
;
4758 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4760 register Lisp_Object tem
;
4761 tem
= XCONS (tail
)->car
;
4762 if (EQ (propval
, tem
))
4764 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
4767 if (CONSP (propval
))
4768 for (proptail
= propval
; CONSP (proptail
);
4769 proptail
= XCONS (proptail
)->cdr
)
4771 Lisp_Object propelt
;
4772 propelt
= XCONS (proptail
)->car
;
4773 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4775 register Lisp_Object tem
;
4776 tem
= XCONS (tail
)->car
;
4777 if (EQ (propelt
, tem
))
4779 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
4786 /* Return 1 if PROPVAL appears as the car of an element of LIST
4787 and the cdr of that element is non-nil.
4788 If PROPVAL is a list, check each element of PROPVAL in that way,
4789 and the first time some element is found,
4790 return 1 if the cdr of that element is non-nil.
4792 This function cannot quit. */
4795 invisible_ellipsis_p (propval
, list
)
4796 register Lisp_Object propval
;
4799 register Lisp_Object tail
, proptail
;
4800 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4802 register Lisp_Object tem
;
4803 tem
= XCONS (tail
)->car
;
4804 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
4805 return ! NILP (XCONS (tem
)->cdr
);
4807 if (CONSP (propval
))
4808 for (proptail
= propval
; CONSP (proptail
);
4809 proptail
= XCONS (proptail
)->cdr
)
4811 Lisp_Object propelt
;
4812 propelt
= XCONS (proptail
)->car
;
4813 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4815 register Lisp_Object tem
;
4816 tem
= XCONS (tail
)->car
;
4817 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
4818 return ! NILP (XCONS (tem
)->cdr
);
4827 staticpro (&Qmenu_bar_update_hook
);
4828 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
4830 staticpro (&Qoverriding_terminal_local_map
);
4831 Qoverriding_terminal_local_map
= intern ("overriding-terminal-local-map");
4833 staticpro (&Qoverriding_local_map
);
4834 Qoverriding_local_map
= intern ("overriding-local-map");
4836 staticpro (&Qwindow_scroll_functions
);
4837 Qwindow_scroll_functions
= intern ("window-scroll-functions");
4839 staticpro (&Qredisplay_end_trigger_functions
);
4840 Qredisplay_end_trigger_functions
= intern ("redisplay-end-trigger-functions");
4842 staticpro (&last_arrow_position
);
4843 staticpro (&last_arrow_string
);
4844 last_arrow_position
= Qnil
;
4845 last_arrow_string
= Qnil
;
4847 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
4848 "String (or mode line construct) included (normally) in `mode-line-format'.");
4849 Vglobal_mode_string
= Qnil
;
4851 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
4852 "Marker for where to display an arrow on top of the buffer text.\n\
4853 This must be the beginning of a line in order to work.\n\
4854 See also `overlay-arrow-string'.");
4855 Voverlay_arrow_position
= Qnil
;
4857 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
4858 "String to display as an arrow. See also `overlay-arrow-position'.");
4859 Voverlay_arrow_string
= Qnil
;
4861 DEFVAR_INT ("scroll-step", &scroll_step
,
4862 "*The number of lines to try scrolling a window by when point moves out.\n\
4863 If that fails to bring point back on frame, point is centered instead.\n\
4864 If this is zero, point is always centered after it moves off frame.");
4866 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively
,
4867 "*Scroll up to this many lines, to bring point back on screen.");
4868 scroll_conservatively
= 0;
4870 DEFVAR_INT ("scroll-margin", &scroll_margin
,
4871 "*Number of lines of margin at the top and bottom of a window.\n\
4872 Recenter the window whenever point gets within this many lines\n\
4873 of the top or bottom of the window.");
4876 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
4878 DEFVAR_BOOL ("truncate-partial-width-windows",
4879 &truncate_partial_width_windows
,
4880 "*Non-nil means truncate lines in all windows less than full frame wide.");
4881 truncate_partial_width_windows
= 1;
4883 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
4884 "*Non-nil means use inverse video for the mode line.");
4885 mode_line_inverse_video
= 1;
4887 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
4888 "*Maximum buffer size for which line number should be displayed.");
4889 line_number_display_limit
= 1000000;
4891 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
4892 "*Non-nil means highlight region even in nonselected windows.");
4893 highlight_nonselected_windows
= 1;
4895 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
4896 "Non-nil if more than one frame is visible on this display.\n\
4897 Minibuffer-only frames don't count, but iconified frames do.\n\
4898 This variable is not guaranteed to be accurate except while processing\n\
4899 `frame-title-format' and `icon-title-format'.");
4901 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
4902 "Template for displaying the titlebar of visible frames.\n\
4903 \(Assuming the window manager supports this feature.)\n\
4904 This variable has the same structure as `mode-line-format' (which see),\n\
4905 and is used only on frames for which no explicit name has been set\n\
4906 \(see `modify-frame-parameters').");
4907 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
4908 "Template for displaying the titlebar of an iconified frame.\n\
4909 \(Assuming the window manager supports this feature.)\n\
4910 This variable has the same structure as `mode-line-format' (which see),\n\
4911 and is used only on frames for which no explicit name has been set\n\
4912 \(see `modify-frame-parameters').");
4914 = Vframe_title_format
4915 = Fcons (intern ("multiple-frames"),
4916 Fcons (build_string ("%b"),
4917 Fcons (Fcons (build_string (""),
4918 Fcons (intern ("invocation-name"),
4919 Fcons (build_string ("@"),
4920 Fcons (intern ("system-name"),
4924 DEFVAR_LISP ("message-log-max", &Vmessage_log_max
,
4925 "Maximum number of lines to keep in the message log buffer.\n\
4926 If nil, disable message logging. If t, log messages but don't truncate\n\
4927 the buffer when it becomes large.");
4928 XSETFASTINT (Vmessage_log_max
, 50);
4930 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions
,
4931 "Functions called before redisplay, if window sizes have changed.\n\
4932 The value should be a list of functions that take one argument.\n\
4933 Just before redisplay, for each frame, if any of its windows have changed\n\
4934 size since the last redisplay, or have been split or deleted,\n\
4935 all the functions in the list are called, with the frame as argument.");
4936 Vwindow_size_change_functions
= Qnil
;
4938 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions
,
4939 "List of Functions to call before redisplaying a window with scrolling.\n\
4940 Each function is called with two arguments, the window\n\
4941 and its new display-start position. Note that the value of `window-end'\n\
4942 is not valid when these functions are called.");
4943 Vwindow_scroll_functions
= Qnil
;
4946 /* initialize the window system */
4949 Lisp_Object root_window
;
4950 #ifndef COMPILER_REGISTER_BUG
4952 #endif /* COMPILER_REGISTER_BUG */
4953 struct window
*mini_w
;
4955 this_line_bufpos
= 0;
4957 mini_w
= XWINDOW (minibuf_window
);
4958 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
4960 echo_area_glyphs
= 0;
4961 previous_echo_glyphs
= 0;
4963 if (!noninteractive
)
4965 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
4966 XSETFASTINT (XWINDOW (root_window
)->top
, 0);
4967 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
4968 XSETFASTINT (mini_w
->top
, FRAME_HEIGHT (f
) - 1);
4969 set_window_height (minibuf_window
, 1, 0);
4971 XSETFASTINT (XWINDOW (root_window
)->width
, FRAME_WIDTH (f
));
4972 XSETFASTINT (mini_w
->width
, FRAME_WIDTH (f
));