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"
36 #include "termhooks.h"
37 #include "intervals.h"
40 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
41 extern void set_frame_menubar ();
44 extern int interrupt_input
;
45 extern int command_loop_level
;
47 extern Lisp_Object Qface
;
49 extern Lisp_Object Voverriding_local_map
;
50 extern Lisp_Object Voverriding_local_map_menu_flag
;
52 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
53 Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
54 Lisp_Object Qredisplay_end_trigger_functions
;
56 /* Nonzero means print newline to stdout before next minibuffer message. */
58 int noninteractive_need_newline
;
60 /* Nonzero means print newline to message log before next message. */
62 static int message_log_need_newline
;
64 #define min(a, b) ((a) < (b) ? (a) : (b))
65 #define max(a, b) ((a) > (b) ? (a) : (b))
66 #define minmax(floor, val, ceil) \
67 ((val) < (floor) ? (floor) : (val) > (ceil) ? (ceil) : (val))
69 /* The buffer position of the first character appearing
70 entirely or partially on the current frame line.
71 Or zero, which disables the optimization for the current frame line. */
72 static int this_line_bufpos
;
74 /* Number of characters past the end of this line,
75 including the terminating newline */
76 static int this_line_endpos
;
78 /* The vertical position of this frame line. */
79 static int this_line_vpos
;
81 /* Hpos value for start of display on this frame line.
82 Usually zero, but negative if first character really began
84 static int this_line_start_hpos
;
86 /* Buffer that this_line variables are describing. */
87 static struct buffer
*this_line_buffer
;
89 /* Value of echo_area_glyphs when it was last acted on.
90 If this is nonzero, there is a message on the frame
91 in the minibuffer and it should be erased as soon
92 as it is no longer requested to appear. */
93 char *previous_echo_glyphs
;
95 /* Nonzero means truncate lines in all windows less wide than the frame */
96 int truncate_partial_width_windows
;
98 /* Nonzero means we have more than one non-minibuffer-only frame.
99 Not guaranteed to be accurate except while parsing frame-title-format. */
102 Lisp_Object Vglobal_mode_string
;
104 /* Marker for where to display an arrow on top of the buffer text. */
105 Lisp_Object Voverlay_arrow_position
;
107 /* String to display for the arrow. */
108 Lisp_Object Voverlay_arrow_string
;
110 /* Like mode-line-format, but for the titlebar on a visible frame. */
111 Lisp_Object Vframe_title_format
;
113 /* Like mode-line-format, but for the titlebar on an iconified frame. */
114 Lisp_Object Vicon_title_format
;
116 /* List of functions to call when a window's size changes. These
117 functions get one arg, a frame on which one or more windows' sizes
119 static Lisp_Object Vwindow_size_change_functions
;
121 /* Values of those variables at last redisplay. */
122 static Lisp_Object last_arrow_position
, last_arrow_string
;
124 Lisp_Object Qmenu_bar_update_hook
;
126 /* Nonzero if overlay arrow has been displayed once in this window. */
127 static int overlay_arrow_seen
;
129 /* Nonzero if visible end of buffer has already been displayed once
130 in this window. (We need this variable in case there are overlay
131 strings that get displayed there.) */
132 static int zv_strings_seen
;
134 /* Nonzero means highlight the region even in nonselected windows. */
135 static int highlight_nonselected_windows
;
137 /* If cursor motion alone moves point off frame,
138 Try scrolling this many lines up or down if that will bring it back. */
139 static int scroll_step
;
141 /* Nonzero if try_window_id has made blank lines at window bottom
142 since the last redisplay that paused */
143 static int blank_end_of_window
;
145 /* Number of windows showing the buffer of the selected window
146 (or another buffer with the same base buffer).
147 keyboard.c refers to this. */
150 /* display_text_line sets these to the frame position (origin 0) of point,
151 whether the window is selected or not.
152 Set one to -1 first to determine whether point was found afterwards. */
154 static int cursor_vpos
;
155 static int cursor_hpos
;
157 static int debug_end_pos
;
159 /* Nonzero means display mode line highlighted */
160 int mode_line_inverse_video
;
162 static void redisplay_internal ();
163 static int message_log_check_duplicate ();
164 static void echo_area_display ();
165 void mark_window_display_accurate ();
166 static void redisplay_windows ();
167 static void redisplay_window ();
168 static void update_menu_bar ();
169 static void try_window ();
170 static int try_window_id ();
171 static struct position
*display_text_line ();
172 static void display_mode_line ();
173 static int display_mode_element ();
174 static char *decode_mode_spec ();
175 static int display_string ();
176 static void display_menu_bar ();
177 static int display_count_lines ();
179 /* Prompt to display in front of the minibuffer contents */
180 Lisp_Object minibuf_prompt
;
182 /* Width in columns of current minibuffer prompt. */
183 int minibuf_prompt_width
;
185 /* Message to display instead of minibuffer contents
186 This is what the functions error and message make,
187 and command echoing uses it as well.
188 It overrides the minibuf_prompt as well as the buffer. */
189 char *echo_area_glyphs
;
191 /* This is the length of the message in echo_area_glyphs. */
192 int echo_area_glyphs_length
;
194 /* This is the window where the echo area message was displayed.
195 It is always a minibuffer window, but it may not be the
196 same window currently active as a minibuffer. */
197 Lisp_Object echo_area_window
;
199 /* true iff we should redraw the mode lines on the next redisplay */
200 int update_mode_lines
;
202 /* Smallest number of characters before the gap
203 at any time since last redisplay that finished.
204 Valid for current buffer when try_window_id can be called. */
207 /* Smallest number of characters after the gap
208 at any time since last redisplay that finished.
209 Valid for current buffer when try_window_id can be called. */
212 /* MODIFF as of last redisplay that finished;
213 if it matches MODIFF, beg_unchanged and end_unchanged
214 contain no useful information */
215 int unchanged_modified
;
217 /* Nonzero if window sizes or contents have changed
218 since last redisplay that finished */
219 int windows_or_buffers_changed
;
221 /* Nonzero after display_mode_line if %l was used
222 and it displayed a line number. */
223 int line_number_displayed
;
225 /* Maximum buffer size for which to display line numbers. */
226 static int line_number_display_limit
;
228 /* Number of lines to keep in the message log buffer.
229 t means infinite. nil means don't log at all. */
230 Lisp_Object Vmessage_log_max
;
232 /* Output a newline in the *Messages* buffer if "needs" one. */
235 message_log_maybe_newline ()
237 if (message_log_need_newline
)
238 message_dolog ("", 0, 1);
242 /* Add a string to the message log, optionally terminated with a newline.
243 This function calls low-level routines in order to bypass text property
244 hooks, etc. which might not be safe to run. */
247 message_dolog (m
, len
, nlflag
)
251 if (!NILP (Vmessage_log_max
))
253 struct buffer
*oldbuf
;
254 int oldpoint
, oldbegv
, oldzv
;
255 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
257 oldbuf
= current_buffer
;
258 Fset_buffer (Fget_buffer_create (build_string ("*Messages*")));
259 current_buffer
->undo_list
= Qt
;
266 oldpoint
+= len
+ nlflag
;
268 oldzv
+= len
+ nlflag
;
271 insert_1 (m
, len
, 1, 0);
274 int this_bol
, prev_bol
, dup
;
275 insert_1 ("\n", 1, 1, 0);
277 this_bol
= scan_buffer ('\n', Z
, 0, -2, 0, 0);
280 prev_bol
= scan_buffer ('\n', this_bol
, 0, -2, 0, 0);
281 dup
= message_log_check_duplicate (prev_bol
, this_bol
);
284 if (oldpoint
> prev_bol
)
285 oldpoint
-= min (this_bol
, oldpoint
) - prev_bol
;
286 if (oldbegv
> prev_bol
)
287 oldbegv
-= min (this_bol
, oldbegv
) - prev_bol
;
288 if (oldzv
> prev_bol
)
289 oldzv
-= min (this_bol
, oldzv
) - prev_bol
;
290 del_range_1 (prev_bol
, this_bol
, 0);
296 /* If you change this format, don't forget to also
297 change message_log_check_duplicate. */
298 sprintf (dupstr
, " [%d times]", dup
);
299 duplen
= strlen (dupstr
);
305 insert_1 (dupstr
, duplen
, 1, 0);
310 if (NATNUMP (Vmessage_log_max
))
312 int pos
= scan_buffer ('\n', Z
, 0,
313 -XFASTINT (Vmessage_log_max
) - 1, 0, 0);
314 oldpoint
-= min (pos
, oldpoint
) - BEG
;
315 oldbegv
-= min (pos
, oldbegv
) - BEG
;
316 oldzv
-= min (pos
, oldzv
) - BEG
;
317 del_range_1 (BEG
, pos
, 0);
322 TEMP_SET_PT (oldpoint
);
323 set_buffer_internal (oldbuf
);
324 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
325 message_log_need_newline
= !nlflag
;
329 /* We are at the end of the buffer after just having inserted a newline.
330 (Note: We depend on the fact we won't be crossing the gap.)
331 Check to see if the most recent message looks a lot like the previous one.
332 Return 0 if different, 1 if the new one should just replace it, or a
333 value N > 1 if we should also append " [N times]". */
336 message_log_check_duplicate (prev_bol
, this_bol
)
337 int prev_bol
, this_bol
;
340 int len
= Z
- 1 - this_bol
;
342 unsigned char *p1
= BUF_CHAR_ADDRESS (current_buffer
, prev_bol
);
343 unsigned char *p2
= BUF_CHAR_ADDRESS (current_buffer
, this_bol
);
345 for (i
= 0; i
< len
; i
++)
347 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.'
356 if (*p1
++ == ' ' && *p1
++ == '[')
359 while (*p1
>= '0' && *p1
<= '9')
360 n
= n
* 10 + *p1
++ - '0';
361 if (strncmp (p1
, " times]\n", 8) == 0)
367 /* Display an echo area message M with a specified length of LEN chars.
368 The string may include null characters. If M is 0, clear out any
369 existing message, and let the minibuffer text show through.
371 The buffer M must continue to exist until after the echo area
372 gets cleared or some other message gets displayed there.
374 Do not pass text that is stored in a Lisp string.
375 Do not pass text in a buffer that was alloca'd. */
382 /* First flush out any partial line written with print. */
383 message_log_maybe_newline ();
385 message_dolog (m
, len
, 1);
386 message2_nolog (m
, len
);
390 /* The non-logging counterpart of message2. */
393 message2_nolog (m
, len
)
399 if (noninteractive_need_newline
)
401 noninteractive_need_newline
= 0;
402 fwrite (m
, len
, 1, stderr
);
403 if (cursor_in_echo_area
== 0)
404 fprintf (stderr
, "\n");
407 /* A null message buffer means that the frame hasn't really been
408 initialized yet. Error messages get reported properly by
409 cmd_error, so this must be just an informative message; toss it. */
410 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
412 Lisp_Object mini_window
;
415 /* Get the frame containing the minibuffer
416 that the selected frame is using. */
417 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
418 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
421 FRAME_SAMPLE_VISIBILITY (f
);
422 if (FRAME_VISIBLE_P (selected_frame
)
423 && ! FRAME_VISIBLE_P (f
))
424 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
429 echo_area_glyphs
= m
;
430 echo_area_glyphs_length
= len
;
433 echo_area_glyphs
= previous_echo_glyphs
= 0;
435 do_pending_window_change ();
436 echo_area_display ();
437 update_frame (f
, 1, 1);
438 do_pending_window_change ();
439 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
440 (*frame_up_to_date_hook
) (f
);
444 /* Display a null-terminated echo area message M. If M is 0, clear out any
445 existing message, and let the minibuffer text show through.
447 The buffer M must continue to exist until after the echo area
448 gets cleared or some other message gets displayed there.
450 Do not pass text that is stored in a Lisp string.
451 Do not pass text in a buffer that was alloca'd. */
457 message2 (m
, (m
? strlen (m
) : 0));
464 message2_nolog (m
, (m
? strlen (m
) : 0));
467 /* Truncate what will be displayed in the echo area
468 the next time we display it--but don't redisplay it now. */
471 truncate_echo_area (len
)
474 /* A null message buffer means that the frame hasn't really been
475 initialized yet. Error messages get reported properly by
476 cmd_error, so this must be just an informative message; toss it. */
477 if (!noninteractive
&& INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
478 echo_area_glyphs_length
= len
;
481 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
482 zero if being used by message. */
483 int message_buf_print
;
485 /* Dump an informative message to the minibuf. If M is 0, clear out
486 any existing message, and let the minibuffer text show through. */
490 message (m
, a1
, a2
, a3
)
492 EMACS_INT a1
, a2
, a3
;
498 if (noninteractive_need_newline
)
500 noninteractive_need_newline
= 0;
501 fprintf (stderr
, m
, a1
, a2
, a3
);
502 if (cursor_in_echo_area
== 0)
503 fprintf (stderr
, "\n");
507 else if (INTERACTIVE
)
509 /* The frame whose minibuffer we're going to display the message on.
510 It may be larger than the selected frame, so we need
511 to use its buffer, not the selected frame's buffer. */
512 Lisp_Object mini_window
;
515 /* Get the frame containing the minibuffer
516 that the selected frame is using. */
517 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
518 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
520 /* A null message buffer means that the frame hasn't really been
521 initialized yet. Error messages get reported properly by
522 cmd_error, so this must be just an informative message; toss it. */
523 if (FRAME_MESSAGE_BUF (f
))
534 len
= doprnt (FRAME_MESSAGE_BUF (f
),
535 FRAME_WIDTH (f
), m
, (char *)0, 3, a
);
537 len
= doprnt (FRAME_MESSAGE_BUF (f
),
538 FRAME_WIDTH (f
), m
, (char *)0, 3, &a1
);
539 #endif /* NO_ARG_ARRAY */
541 message2 (FRAME_MESSAGE_BUF (f
), len
);
546 /* Print should start at the beginning of the message
548 message_buf_print
= 0;
553 /* The non-logging version of message. */
555 message_nolog (m
, a1
, a2
, a3
)
557 EMACS_INT a1
, a2
, a3
;
559 Lisp_Object old_log_max
;
560 old_log_max
= Vmessage_log_max
;
561 Vmessage_log_max
= Qnil
;
562 message (m
, a1
, a2
, a3
);
563 Vmessage_log_max
= old_log_max
;
569 message2 (echo_area_glyphs
, echo_area_glyphs_length
);
577 Lisp_Object mini_window
;
579 /* Choose the minibuffer window for this display.
580 It is the minibuffer window used by the selected frame. */
581 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
582 /* This is the frame that window is in. */
583 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
585 if (! FRAME_VISIBLE_P (f
))
590 redraw_garbaged_frames ();
594 if (echo_area_glyphs
|| minibuf_level
== 0)
596 echo_area_window
= mini_window
;
598 vpos
= XFASTINT (XWINDOW (mini_window
)->top
);
599 get_display_line (f
, vpos
, 0);
600 display_string (XWINDOW (mini_window
), vpos
,
601 echo_area_glyphs
? echo_area_glyphs
: "",
602 echo_area_glyphs
? echo_area_glyphs_length
: -1,
603 0, 0, 0, 0, FRAME_WIDTH (f
));
605 #if 0 /* This just gets in the way. update_frame does the job. */
606 /* If desired cursor location is on this line, put it at end of text */
607 if (cursor_in_echo_area
)
608 FRAME_CURSOR_Y (f
) = vpos
;
609 if (FRAME_CURSOR_Y (f
) == vpos
)
610 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
613 /* Fill the rest of the minibuffer window with blank lines. */
618 i
< vpos
+ XFASTINT (XWINDOW (mini_window
)->height
); i
++)
620 get_display_line (f
, i
, 0);
621 display_string (XWINDOW (mini_window
), vpos
,
622 "", 0, 0, 0, 0, 0, FRAME_WIDTH (f
));
626 else if (!EQ (mini_window
, selected_window
))
627 windows_or_buffers_changed
++;
629 if (EQ (mini_window
, selected_window
))
630 this_line_bufpos
= 0;
632 previous_echo_glyphs
= echo_area_glyphs
;
635 /* Update frame titles. */
637 #ifdef HAVE_WINDOW_SYSTEM
638 static char frame_title_buf
[512];
639 static char *frame_title_ptr
;
642 store_frame_title (str
, mincol
, maxcol
)
647 if (maxcol
< 0 || maxcol
>= sizeof(frame_title_buf
))
648 maxcol
= sizeof (frame_title_buf
);
649 limit
= &frame_title_buf
[maxcol
];
650 while (*str
!= '\0' && frame_title_ptr
< limit
)
651 *frame_title_ptr
++ = *str
++;
652 while (frame_title_ptr
< &frame_title_buf
[mincol
])
653 *frame_title_ptr
++ = ' ';
654 return frame_title_ptr
- frame_title_buf
;
658 x_consider_frame_title (frame
)
664 FRAME_PTR f
= XFRAME (frame
);
666 if (!(FRAME_WINDOW_P (f
) || FRAME_MINIBUF_ONLY_P (f
) || f
->explicit_name
))
669 /* Do we have more than one visible frame on this X display? */
673 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
675 FRAME_PTR tf
= XFRAME (XCONS (tail
)->car
);
677 if (tf
!= f
&& FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
678 && !FRAME_MINIBUF_ONLY_P (tf
)
679 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
683 multiple_frames
= CONSP (tail
);
686 obuf
= current_buffer
;
687 Fset_buffer (XWINDOW (f
->selected_window
)->buffer
);
688 fmt
= (FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
);
689 frame_title_ptr
= frame_title_buf
;
690 len
= display_mode_element (XWINDOW (f
->selected_window
), 0, 0, 0,
691 0, sizeof (frame_title_buf
), fmt
);
693 set_buffer_internal (obuf
);
694 /* Set the name only if it's changed. This avoids consing
695 in the common case where it hasn't. (If it turns out that we've
696 already wasted too much time by walking through the list with
697 display_mode_element, then we might need to optimize at a higher
699 if (! STRINGP (f
->name
) || XSTRING (f
->name
)->size
!= len
700 || bcmp (frame_title_buf
, XSTRING (f
->name
)->data
, len
) != 0)
701 x_implicitly_set_name (f
, make_string (frame_title_buf
, len
), Qnil
);
704 #define frame_title_ptr ((char *)0)
705 #define store_frame_title(str, mincol, maxcol) 0
708 /* Prepare for redisplay by updating menu-bar item lists when appropriate.
709 This can call eval. */
714 register struct window
*w
= XWINDOW (selected_window
);
716 struct gcpro gcpro1
, gcpro2
;
718 all_windows
= (update_mode_lines
|| buffer_shared
> 1
719 || windows_or_buffers_changed
);
721 /* Update all frame titles based on their buffer names, etc.
722 We do this before the menu bars so that the buffer-menu
723 will show the up-to-date frame titles.
725 This used to be done after the menu bars, for a reason that
726 was stated as follows but which I do not understand:
727 "We do this after the menu bars so that the frame will first
728 create its menu bar using the name `emacs' if no other name
729 has yet been specified."
730 I think that is no longer a concern. */
731 #ifdef HAVE_WINDOW_SYSTEM
732 if (windows_or_buffers_changed
|| update_mode_lines
)
734 Lisp_Object tail
, frame
;
736 FOR_EACH_FRAME (tail
, frame
)
737 if (FRAME_VISIBLE_P (XFRAME (frame
))
738 || FRAME_ICONIFIED_P (XFRAME (frame
)))
739 x_consider_frame_title (frame
);
743 /* Update the menu bar item lists, if appropriate.
744 This has to be done before any actual redisplay
745 or generation of display lines. */
748 Lisp_Object tail
, frame
;
749 int count
= specpdl_ptr
- specpdl
;
751 record_unwind_protect (Fstore_match_data
, Fmatch_data ());
753 FOR_EACH_FRAME (tail
, frame
)
755 /* If a window on this frame changed size,
756 report that to the user and clear the size-change flag. */
757 if (FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)))
759 Lisp_Object functions
;
760 /* Clear flag first in case we get error below. */
761 FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)) = 0;
762 functions
= Vwindow_size_change_functions
;
763 GCPRO2 (tail
, functions
);
764 while (CONSP (functions
))
766 call1 (XCONS (functions
)->car
, frame
);
767 functions
= XCONS (functions
)->cdr
;
772 update_menu_bar (XFRAME (frame
), 0);
776 unbind_to (count
, Qnil
);
779 update_menu_bar (selected_frame
, 1);
782 /* Do a frame update, taking possible shortcuts into account.
783 This is the main external entry point for redisplay.
785 If the last redisplay displayed an echo area message and that
786 message is no longer requested, we clear the echo area
787 or bring back the minibuffer if that is in use.
789 Do not call eval from within this function.
790 Calls to eval after the call to echo_area_display would confuse
791 the display_line mechanism and would cause a crash.
792 Calls to eval before that point will work most of the time,
793 but can still lose, because this function
794 can be called from signal handlers; with alarms set up;
795 or with synchronous processes running.
797 See Fcall_process; if you called it from here, it could be
798 entered recursively. */
800 static int do_verify_charstarts
;
802 /* Counter is used to clear the face cache
803 no more than once ever 1000 redisplays. */
804 static int clear_face_cache_count
;
806 /* Record the previous terminal frame we displayed. */
807 static FRAME_PTR previous_terminal_frame
;
812 redisplay_internal (0);
815 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay
816 is not in response to any user action; therefore, we should
817 preserve the echo area. (Actually, our caller does that job.)
818 Perhaps in the future avoid recentering windows
819 if it is not necessary; currently that causes some problems. */
822 redisplay_internal (preserve_echo_area
)
823 int preserve_echo_area
;
825 register struct window
*w
= XWINDOW (selected_window
);
829 register int tlbufpos
, tlendpos
;
836 if (popup_activated ())
841 if (FRAME_TERMCAP_P (selected_frame
)
842 && previous_terminal_frame
!= selected_frame
)
844 /* Since frames on an ASCII terminal share the same display area,
845 displaying a different frame means redisplay the whole thing. */
846 windows_or_buffers_changed
++;
847 SET_FRAME_GARBAGED (selected_frame
);
848 XSETFRAME (Vterminal_frame
, selected_frame
);
850 previous_terminal_frame
= selected_frame
;
853 /* Set the visible flags for all frames.
854 Do this before checking for resized or garbaged frames; they want
855 to know if their frames are visible.
856 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
858 Lisp_Object tail
, frame
;
860 FOR_EACH_FRAME (tail
, frame
)
862 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
864 /* Clear out all the display lines in which we will generate the
865 glyphs to display. */
866 init_desired_glyphs (XFRAME (frame
));
870 /* Notice any pending interrupt request to change frame size. */
871 do_pending_window_change ();
875 redraw_garbaged_frames ();
879 prepare_menu_bars ();
881 if (windows_or_buffers_changed
)
884 /* Detect case that we need to write a star in the mode line. */
885 if (XFASTINT (w
->last_modified
) < MODIFF
886 && XFASTINT (w
->last_modified
) <= SAVE_MODIFF
)
888 w
->update_mode_line
= Qt
;
889 if (buffer_shared
> 1)
893 /* If %c is in use, update it if needed. */
894 if (!NILP (w
->column_number_displayed
)
895 /* This alternative quickly identifies a common case
896 where no change is needed. */
897 && !(PT
== XFASTINT (w
->last_point
)
898 && XFASTINT (w
->last_modified
) >= MODIFF
)
899 && XFASTINT (w
->column_number_displayed
) != current_column ())
900 w
->update_mode_line
= Qt
;
902 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
904 all_windows
= update_mode_lines
|| buffer_shared
> 1;
906 /* If specs for an arrow have changed, do thorough redisplay
907 to ensure we remove any arrow that should no longer exist. */
908 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
909 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
912 /* Normally the message* functions will have already displayed and
913 updated the echo area, but the frame may have been trashed, or
914 the update may have been preempted, so display the echo area
916 if (echo_area_glyphs
|| previous_echo_glyphs
)
918 echo_area_display ();
922 /* If showing region, and mark has changed, must redisplay whole window. */
923 if (((!NILP (Vtransient_mark_mode
)
924 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
925 != !NILP (w
->region_showing
))
926 || (!NILP (w
->region_showing
)
927 && !EQ (w
->region_showing
,
928 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
929 this_line_bufpos
= -1;
931 tlbufpos
= this_line_bufpos
;
932 tlendpos
= this_line_endpos
;
933 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
934 && !current_buffer
->clip_changed
935 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
936 /* Make sure recorded data applies to current buffer, etc */
937 && this_line_buffer
== current_buffer
938 && current_buffer
== XBUFFER (w
->buffer
)
939 && NILP (w
->force_start
)
940 /* Point must be on the line that we have info recorded about */
942 && PT
<= Z
- tlendpos
943 /* All text outside that line, including its final newline,
945 && (XFASTINT (w
->last_modified
) >= MODIFF
946 || (beg_unchanged
>= tlbufpos
- 1
948 /* If selective display, can't optimize
949 if the changes start at the beginning of the line. */
950 && ((INTEGERP (current_buffer
->selective_display
)
951 && XINT (current_buffer
->selective_display
) > 0
952 ? (beg_unchanged
>= tlbufpos
955 && end_unchanged
>= tlendpos
956 && Z
- GPT
>= tlendpos
)))
958 if (tlbufpos
> BEGV
&& FETCH_CHAR (tlbufpos
- 1) != '\n'
960 || FETCH_CHAR (tlbufpos
) == '\n'))
961 /* Former continuation line has disappeared by becoming empty */
963 else if (XFASTINT (w
->last_modified
) < MODIFF
964 || MINI_WINDOW_P (w
))
967 overlay_arrow_seen
= 0;
969 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
970 pos_tab_offset (w
, tlbufpos
));
971 /* If line contains point, is not continued,
972 and ends at same distance from eob as before, we win */
973 if (cursor_vpos
>= 0 && this_line_bufpos
974 && this_line_endpos
== tlendpos
)
976 /* If this is not the window's last line,
977 we must adjust the charstarts of the lines below. */
978 if (this_line_vpos
+ 1
979 < XFASTINT (w
->top
) + window_internal_height (w
))
981 int left
= XFASTINT (w
->left
);
982 int *charstart_next_line
983 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[this_line_vpos
+ 1];
986 if (Z
- tlendpos
== ZV
)
987 /* This line ends at end of (accessible part of) buffer.
988 There is no newline to count. */
989 adjust
= Z
- tlendpos
- charstart_next_line
[left
];
991 /* This line ends in a newline.
992 Must take account of the newline and the rest of the
993 text that follows. */
994 adjust
= Z
- tlendpos
+ 1 - charstart_next_line
[left
];
996 adjust_window_charstarts (w
, this_line_vpos
, adjust
);
999 if (XFASTINT (w
->width
) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w
))))
1000 preserve_other_columns (w
);
1006 else if (PT
== XFASTINT (w
->last_point
)
1007 /* Make sure the cursor was last displayed
1008 in this window. Otherwise we have to reposition it. */
1009 && XINT (w
->top
) <= FRAME_CURSOR_Y (selected_frame
)
1010 && (XINT (w
->top
) + XINT (w
->height
)
1011 > FRAME_CURSOR_Y (selected_frame
)))
1015 do_pending_window_change ();
1020 /* If highlighting the region, or if the cursor is in the echo area,
1021 then we can't just move the cursor. */
1022 else if (! (!NILP (Vtransient_mark_mode
)
1023 && !NILP (current_buffer
->mark_active
))
1024 && NILP (w
->region_showing
)
1025 && !cursor_in_echo_area
)
1027 pos
= *compute_motion (tlbufpos
, 0,
1028 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1030 PT
, 2, - (1 << (BITS_PER_SHORT
- 1)),
1031 window_internal_width (w
) - 1,
1033 pos_tab_offset (w
, tlbufpos
), w
);
1036 int width
= window_internal_width (w
) - 1;
1037 FRAME_CURSOR_X (selected_frame
)
1038 = XFASTINT (w
->left
) + minmax (0, pos
.hpos
, width
);
1039 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
1046 /* Text changed drastically or point moved off of line */
1047 cancel_line (this_line_vpos
, selected_frame
);
1050 this_line_bufpos
= 0;
1051 all_windows
|= buffer_shared
> 1;
1053 clear_face_cache_count
++;
1057 Lisp_Object tail
, frame
;
1060 /* Clear the face cache, only when we do a full redisplay
1061 and not too often either. */
1062 if (clear_face_cache_count
> 1000)
1064 clear_face_cache ();
1065 clear_face_cache_count
= 0;
1069 /* Recompute # windows showing selected buffer.
1070 This will be incremented each time such a window is displayed. */
1073 FOR_EACH_FRAME (tail
, frame
)
1075 FRAME_PTR f
= XFRAME (frame
);
1076 if (! FRAME_TERMCAP_P (f
) || f
== selected_frame
)
1079 /* Mark all the scroll bars to be removed; we'll redeem the ones
1080 we want when we redisplay their windows. */
1081 if (condemn_scroll_bars_hook
)
1082 (*condemn_scroll_bars_hook
) (f
);
1084 if (FRAME_VISIBLE_P (f
))
1085 redisplay_windows (FRAME_ROOT_WINDOW (f
), preserve_echo_area
);
1087 /* Any scroll bars which redisplay_windows should have nuked
1088 should now go away. */
1089 if (judge_scroll_bars_hook
)
1090 (*judge_scroll_bars_hook
) (f
);
1094 else if (FRAME_VISIBLE_P (selected_frame
))
1096 redisplay_window (selected_window
, 1, preserve_echo_area
);
1097 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
1098 preserve_other_columns (w
);
1102 /* Prevent various kinds of signals during display update.
1103 stdio is not robust about handling signals,
1104 which can cause an apparent I/O error. */
1105 if (interrupt_input
)
1116 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1120 if (!FRAMEP (XCONS (tail
)->car
))
1123 f
= XFRAME (XCONS (tail
)->car
);
1125 if ((! FRAME_TERMCAP_P (f
) || f
== selected_frame
)
1126 && FRAME_VISIBLE_P (f
))
1128 pause
|= update_frame (f
, 0, 0);
1131 mark_window_display_accurate (f
->root_window
, 1);
1132 if (frame_up_to_date_hook
!= 0)
1133 (*frame_up_to_date_hook
) (f
);
1139 #endif /* MULTI_FRAME */
1141 if (FRAME_VISIBLE_P (selected_frame
))
1142 pause
= update_frame (selected_frame
, 0, 0);
1146 /* We may have called echo_area_display at the top of this
1147 function. If the echo area is on another frame, that may
1148 have put text on a frame other than the selected one, so the
1149 above call to update_frame would not have caught it. Catch
1152 Lisp_Object mini_window
;
1153 FRAME_PTR mini_frame
;
1155 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
1156 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
1158 if (mini_frame
!= selected_frame
1159 && ! FRAME_TERMCAP_P (mini_frame
))
1160 pause
|= update_frame (mini_frame
, 0, 0);
1164 /* If frame does not match, prevent doing single-line-update next time.
1165 Also, don't forget to check every line to update the arrow. */
1168 this_line_bufpos
= 0;
1169 if (!NILP (last_arrow_position
))
1171 last_arrow_position
= Qt
;
1172 last_arrow_string
= Qt
;
1174 /* If we pause after scrolling, some lines in current_frame
1175 may be null, so preserve_other_columns won't be able to
1176 preserve all the vertical-bar separators. So, avoid using it
1178 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
1179 update_mode_lines
= 1;
1182 /* Now text on frame agrees with windows, so
1183 put info into the windows for partial redisplay to follow */
1187 register struct buffer
*b
= XBUFFER (w
->buffer
);
1189 blank_end_of_window
= 0;
1190 unchanged_modified
= BUF_MODIFF (b
);
1191 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
1192 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
1194 XSETFASTINT (w
->last_point
, BUF_PT (b
));
1195 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (selected_frame
));
1196 XSETFASTINT (w
->last_point_y
, FRAME_CURSOR_Y (selected_frame
));
1199 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
1202 b
->clip_changed
= 0;
1203 w
->update_mode_line
= Qnil
;
1204 XSETFASTINT (w
->last_modified
, BUF_MODIFF (b
));
1205 w
->window_end_valid
= w
->buffer
;
1206 last_arrow_position
= Voverlay_arrow_position
;
1207 last_arrow_string
= Voverlay_arrow_string
;
1208 if (do_verify_charstarts
)
1209 verify_charstarts (w
);
1210 if (frame_up_to_date_hook
!= 0)
1211 (*frame_up_to_date_hook
) (selected_frame
);
1213 update_mode_lines
= 0;
1214 windows_or_buffers_changed
= 0;
1217 /* Start SIGIO interrupts coming again.
1218 Having them off during the code above
1219 makes it less likely one will discard output,
1220 but not impossible, since there might be stuff
1221 in the system buffer here.
1222 But it is much hairier to try to do anything about that. */
1224 if (interrupt_input
)
1228 /* Change frame size now if a change is pending. */
1229 do_pending_window_change ();
1231 /* If we just did a pending size change, redisplay again
1232 for the new size. */
1233 if (windows_or_buffers_changed
&& !pause
)
1237 /* Redisplay, but leave alone any recent echo area message
1238 unless another message has been requested in its place.
1240 This is useful in situations where you need to redisplay but no
1241 user action has occurred, making it inappropriate for the message
1242 area to be cleared. See tracking_off and
1243 wait_reading_process_input for examples of these situations. */
1245 redisplay_preserve_echo_area ()
1247 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
1249 echo_area_glyphs
= previous_echo_glyphs
;
1250 redisplay_internal (1);
1251 echo_area_glyphs
= 0;
1254 redisplay_internal (1);
1258 mark_window_display_accurate (window
, flag
)
1262 register struct window
*w
;
1264 for (;!NILP (window
); window
= w
->next
)
1266 if (!WINDOWP (window
)) abort ();
1267 w
= XWINDOW (window
);
1269 if (!NILP (w
->buffer
))
1271 XSETFASTINT (w
->last_modified
,
1272 !flag
? 0 : BUF_MODIFF (XBUFFER (w
->buffer
)));
1274 /* Record if we are showing a region, so can make sure to
1275 update it fully at next redisplay. */
1276 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
1277 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
1278 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
1282 w
->window_end_valid
= w
->buffer
;
1283 w
->update_mode_line
= Qnil
;
1284 if (!NILP (w
->buffer
) && flag
)
1285 XBUFFER (w
->buffer
)->clip_changed
= 0;
1287 if (!NILP (w
->vchild
))
1288 mark_window_display_accurate (w
->vchild
, flag
);
1289 if (!NILP (w
->hchild
))
1290 mark_window_display_accurate (w
->hchild
, flag
);
1295 last_arrow_position
= Voverlay_arrow_position
;
1296 last_arrow_string
= Voverlay_arrow_string
;
1300 /* t is unequal to any useful value of Voverlay_arrow_... */
1301 last_arrow_position
= Qt
;
1302 last_arrow_string
= Qt
;
1306 /* Update the menu bar item list for frame F.
1307 This has to be done before we start to fill in any display lines,
1308 because it can call eval.
1310 If SAVE_MATCH_DATA is 1, we must save and restore it here. */
1313 update_menu_bar (f
, save_match_data
)
1315 int save_match_data
;
1317 struct buffer
*old
= current_buffer
;
1319 register struct window
*w
;
1321 window
= FRAME_SELECTED_WINDOW (f
);
1322 w
= XWINDOW (window
);
1324 if (update_mode_lines
)
1325 w
->update_mode_line
= Qt
;
1327 if (FRAME_WINDOW_P (f
)
1329 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1330 FRAME_EXTERNAL_MENU_BAR (f
)
1332 FRAME_MENU_BAR_LINES (f
) > 0
1334 : FRAME_MENU_BAR_LINES (f
) > 0)
1336 /* If the user has switched buffers or windows, we need to
1337 recompute to reflect the new bindings. But we'll
1338 recompute when update_mode_lines is set too; that means
1339 that people can use force-mode-line-update to request
1340 that the menu bar be recomputed. The adverse effect on
1341 the rest of the redisplay algorithm is about the same as
1342 windows_or_buffers_changed anyway. */
1343 if (windows_or_buffers_changed
1344 || !NILP (w
->update_mode_line
)
1345 || (XFASTINT (w
->last_modified
) < MODIFF
1346 && (XFASTINT (w
->last_modified
)
1347 <= BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))))
1348 || ((!NILP (Vtransient_mark_mode
)
1349 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
1350 != !NILP (w
->region_showing
)))
1352 struct buffer
*prev
= current_buffer
;
1353 int count
= specpdl_ptr
- specpdl
;
1355 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1356 if (save_match_data
)
1357 record_unwind_protect (Fstore_match_data
, Fmatch_data ());
1358 if (NILP (Voverriding_local_map_menu_flag
))
1360 specbind (Qoverriding_terminal_local_map
, Qnil
);
1361 specbind (Qoverriding_local_map
, Qnil
);
1364 /* Run the Lucid hook. */
1365 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1366 /* If it has changed current-menubar from previous value,
1367 really recompute the menubar from the value. */
1368 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1369 call0 (Qrecompute_lucid_menubar
);
1370 safe_run_hooks (Qmenu_bar_update_hook
);
1371 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1372 /* Make sure to redisplay the menu bar in case we change it. */
1373 w
->update_mode_line
= Qt
;
1374 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1375 if (FRAME_WINDOW_P (f
))
1376 set_frame_menubar (f
, 0, 0);
1377 #endif /* USE_X_TOOLKIT || HAVE_NTGUI */
1379 unbind_to (count
, Qnil
);
1380 set_buffer_internal_1 (prev
);
1387 /* Redisplay WINDOW and its subwindows and siblings. */
1390 redisplay_windows (window
, preserve_echo_area
)
1392 int preserve_echo_area
;
1394 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
1395 redisplay_window (window
, 0, preserve_echo_area
);
1398 /* Redisplay window WINDOW and its subwindows. */
1401 redisplay_window (window
, just_this_one
, preserve_echo_area
)
1403 int just_this_one
, preserve_echo_area
;
1405 register struct window
*w
= XWINDOW (window
);
1406 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1408 register int lpoint
= PT
;
1409 struct buffer
*old
= current_buffer
;
1410 register int width
= window_internal_width (w
) - 1;
1411 register int startp
;
1412 register int hscroll
= XINT (w
->hscroll
);
1413 struct position pos
;
1416 int update_mode_line
;
1417 struct Lisp_Char_Table
*dp
= window_display_table (w
);
1419 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1421 /* If this is a combination window, do its children; that's all. */
1423 if (!NILP (w
->vchild
))
1425 redisplay_windows (w
->vchild
, preserve_echo_area
);
1428 if (!NILP (w
->hchild
))
1430 redisplay_windows (w
->hchild
, preserve_echo_area
);
1433 if (NILP (w
->buffer
))
1436 height
= window_internal_height (w
);
1437 update_mode_line
= (!NILP (w
->update_mode_line
) || update_mode_lines
);
1438 if (XBUFFER (w
->buffer
)->clip_changed
)
1439 update_mode_line
= 1;
1441 if (MINI_WINDOW_P (w
))
1443 if (w
== XWINDOW (echo_area_window
) && echo_area_glyphs
)
1444 /* We've already displayed the echo area glyphs in this window. */
1445 goto finish_scroll_bars
;
1446 else if (w
!= XWINDOW (minibuf_window
))
1448 /* This is a minibuffer, but it's not the currently active one,
1450 int vpos
= XFASTINT (w
->top
);
1453 for (i
= 0; i
< height
; i
++)
1455 get_display_line (f
, vpos
+ i
, 0);
1456 display_string (w
, vpos
+ i
, "", 0, 0, 0, 1, 0, width
);
1459 goto finish_scroll_bars
;
1463 /* Otherwise set up data on this window; select its buffer and point value */
1465 if (update_mode_line
)
1466 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1468 set_buffer_temp (XBUFFER (w
->buffer
));
1472 /* If %c is in mode line, update it if needed. */
1473 if (!NILP (w
->column_number_displayed
)
1474 /* This alternative quickly identifies a common case
1475 where no change is needed. */
1476 && !(PT
== XFASTINT (w
->last_point
)
1477 && XFASTINT (w
->last_modified
) >= MODIFF
)
1478 && XFASTINT (w
->column_number_displayed
) != current_column ())
1479 update_mode_line
= 1;
1481 /* Count number of windows showing the selected buffer.
1482 An indirect buffer counts as its base buffer. */
1486 struct buffer
*current_base
, *window_base
;
1487 current_base
= current_buffer
;
1488 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1489 if (current_base
->base_buffer
)
1490 current_base
= current_base
->base_buffer
;
1491 if (window_base
->base_buffer
)
1492 window_base
= window_base
->base_buffer
;
1493 if (current_base
== window_base
)
1497 /* POINT refers normally to the selected window.
1498 For any other window, set up appropriate value. */
1500 if (!EQ (window
, selected_window
))
1502 int new_pt
= marker_position (w
->pointm
);
1506 Fset_marker (w
->pointm
, make_number (new_pt
), Qnil
);
1508 else if (new_pt
> (ZV
- 1))
1511 Fset_marker (w
->pointm
, make_number (new_pt
), Qnil
);
1513 /* We don't use SET_PT so that the point-motion hooks don't run. */
1514 BUF_PT (current_buffer
) = new_pt
;
1517 /* If any of the character widths specified in the display table
1518 have changed, invalidate the width run cache. It's true that this
1519 may be a bit late to catch such changes, but the rest of
1520 redisplay goes (non-fatally) haywire when the display table is
1521 changed, so why should we worry about doing any better? */
1522 if (current_buffer
->width_run_cache
)
1524 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
1526 if (! disptab_matches_widthtab (disptab
,
1527 XVECTOR (current_buffer
->width_table
)))
1529 invalidate_region_cache (current_buffer
,
1530 current_buffer
->width_run_cache
,
1532 recompute_width_table (current_buffer
, disptab
);
1536 /* If window-start is screwed up, choose a new one. */
1537 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
1540 startp
= marker_position (w
->start
);
1542 /* Handle case where place to start displaying has been specified,
1543 unless the specified location is outside the accessible range. */
1544 if (!NILP (w
->force_start
))
1546 w
->force_start
= Qnil
;
1547 /* Forget any recorded base line for line number display. */
1548 w
->base_line_number
= Qnil
;
1549 /* Redisplay the mode line. Select the buffer properly for that.
1550 Also, run the hook window-scroll-functions
1551 because we have scrolled. */
1552 /* Note, we do this after clearing force_start because
1553 if there's an error, it is better to forget about force_start
1554 than to get into an infinite loop calling the hook functions
1555 and having them get more errors. */
1556 if (!update_mode_line
1557 || ! NILP (Vwindow_scroll_functions
))
1559 Lisp_Object temp
[3];
1561 set_buffer_temp (old
);
1562 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1563 update_mode_line
= 1;
1564 w
->update_mode_line
= Qt
;
1565 if (! NILP (Vwindow_scroll_functions
))
1567 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1568 make_number (startp
));
1569 startp
= marker_position (w
->start
);
1572 XSETFASTINT (w
->last_modified
, 0);
1573 if (startp
< BEGV
) startp
= BEGV
;
1574 if (startp
> ZV
) startp
= ZV
;
1575 try_window (window
, startp
);
1576 if (cursor_vpos
< 0)
1578 /* If point does not appear, move point so it does appear */
1579 pos
= *compute_motion (startp
, 0,
1580 (((EQ (window
, minibuf_window
)
1582 ? minibuf_prompt_width
: 0)
1583 + (hscroll
? 1 - hscroll
: 0)),
1586 - (1 << (BITS_PER_SHORT
- 1)),
1587 width
, hscroll
, pos_tab_offset (w
, startp
), w
);
1588 BUF_PT (current_buffer
) = pos
.bufpos
;
1589 if (w
!= XWINDOW (selected_window
))
1590 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
1593 if (current_buffer
== old
)
1595 FRAME_CURSOR_X (f
) = (XFASTINT (w
->left
)
1596 + minmax (0, pos
.hpos
, width
));
1597 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1599 /* If we are highlighting the region,
1600 then we just changed the region, so redisplay to show it. */
1601 if (!NILP (Vtransient_mark_mode
)
1602 && !NILP (current_buffer
->mark_active
))
1604 cancel_my_columns (XWINDOW (window
));
1605 try_window (window
, startp
);
1611 /* Handle case where text has not changed, only point,
1612 and it has not moved off the frame. */
1614 /* This code is not used for minibuffer for the sake of
1615 the case of redisplaying to replace an echo area message;
1616 since in that case the minibuffer contents per se are usually unchanged.
1617 This code is of no real use in the minibuffer since
1618 the handling of this_line_bufpos, etc.,
1619 in redisplay handles the same cases. */
1621 if (XFASTINT (w
->last_modified
) >= MODIFF
1622 && PT
>= startp
&& !current_buffer
->clip_changed
1623 && (just_this_one
|| XFASTINT (w
->width
) == FRAME_WIDTH (f
))
1624 /* If force-mode-line-update was called, really redisplay;
1625 that's how redisplay is forced after e.g. changing
1626 buffer-invisibility-spec. */
1627 && NILP (w
->update_mode_line
)
1628 /* Can't use this case if highlighting a region. */
1629 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1630 && NILP (w
->region_showing
)
1631 /* If end pos is out of date, scroll bar and percentage will be wrong */
1632 && INTEGERP (w
->window_end_vpos
)
1633 && XFASTINT (w
->window_end_vpos
) < XFASTINT (w
->height
)
1634 && !EQ (window
, minibuf_window
))
1636 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0), 0,
1637 PT
, height
, 0, width
, hscroll
,
1638 pos_tab_offset (w
, startp
), w
);
1640 if (pos
.vpos
< height
)
1642 /* Ok, point is still on frame */
1643 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
1645 /* These variables are supposed to be origin 1 */
1646 FRAME_CURSOR_X (f
) = (XFASTINT (w
->left
)
1647 + minmax (0, pos
.hpos
, width
));
1648 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1650 /* This doesn't do the trick, because if a window to the right of
1651 this one must be redisplayed, this does nothing because there
1652 is nothing in DesiredFrame yet, and then the other window is
1653 redisplayed, making likes that are empty in this window's columns.
1654 if (XFASTINT (w->width) != FRAME_WIDTH (f))
1655 preserve_my_columns (w);
1659 /* Don't bother trying redisplay with same start;
1660 we already know it will lose */
1662 /* If current starting point was originally the beginning of a line
1663 but no longer is, find a new starting point. */
1664 else if (!NILP (w
->start_at_line_beg
)
1666 || FETCH_CHAR (startp
- 1) == '\n'))
1670 else if (just_this_one
&& !MINI_WINDOW_P (w
)
1672 && XFASTINT (w
->last_modified
)
1673 /* or else vmotion on first line won't work. */
1674 && ! NILP (w
->start_at_line_beg
)
1675 && ! EQ (w
->window_end_valid
, Qnil
)
1676 && do_id
&& !current_buffer
->clip_changed
1677 && !blank_end_of_window
1678 && XFASTINT (w
->width
) == FRAME_WIDTH (f
)
1679 /* Can't use this case if highlighting a region. */
1680 && !(!NILP (Vtransient_mark_mode
)
1681 && !NILP (current_buffer
->mark_active
))
1682 /* Don't use try_window_id if newline
1683 doesn't display as the end of a line. */
1684 && !(dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, '\n')))
1685 && NILP (w
->region_showing
)
1686 && EQ (last_arrow_position
, Voverlay_arrow_position
)
1687 && EQ (last_arrow_string
, Voverlay_arrow_string
)
1688 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
1691 /* tem > 0 means success. tem == -1 means choose new start.
1692 tem == -2 means try again with same start,
1693 and nothing but whitespace follows the changed stuff.
1694 tem == 0 means try again with same start. */
1698 else if (startp
>= BEGV
&& startp
<= ZV
1700 /* Avoid starting at end of buffer. */
1701 #if 0 /* This change causes trouble for M-! finger & RET.
1702 It will have to be considered later. */
1703 || ! EQ (window
, selected_window
)
1704 /* Don't do the recentering if redisplay
1705 is not for no user action. */
1706 || preserve_echo_area
1709 || (XFASTINT (w
->last_modified
) >= MODIFF
)))
1711 /* Try to redisplay starting at same place as before */
1712 /* If point has not moved off frame, accept the results */
1713 try_window (window
, startp
);
1714 if (cursor_vpos
>= 0)
1716 if (!just_this_one
|| current_buffer
->clip_changed
1717 || beg_unchanged
< startp
)
1718 /* Forget any recorded base line for line number display. */
1719 w
->base_line_number
= Qnil
;
1723 cancel_my_columns (w
);
1726 XSETFASTINT (w
->last_modified
, 0);
1727 /* Redisplay the mode line. Select the buffer properly for that. */
1728 if (!update_mode_line
)
1730 set_buffer_temp (old
);
1731 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1732 update_mode_line
= 1;
1733 w
->update_mode_line
= Qt
;
1736 /* Try to scroll by specified few lines */
1738 if (scroll_step
&& !current_buffer
->clip_changed
1739 && startp
>= BEGV
&& startp
<= ZV
)
1743 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), scroll_step
, w
);
1744 if (pos
.vpos
>= height
)
1748 pos
= *vmotion (startp
, (PT
< startp
? - scroll_step
: scroll_step
), w
);
1750 if (PT
>= pos
.bufpos
)
1752 if (! NILP (Vwindow_scroll_functions
))
1754 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
1755 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1756 make_number (pos
.bufpos
));
1757 pos
.bufpos
= marker_position (w
->start
);
1759 try_window (window
, pos
.bufpos
);
1760 if (cursor_vpos
>= 0)
1762 if (!just_this_one
|| current_buffer
->clip_changed
1763 || beg_unchanged
< startp
)
1764 /* Forget any recorded base line for line number display. */
1765 w
->base_line_number
= Qnil
;
1769 cancel_my_columns (w
);
1774 /* Finally, just choose place to start which centers point */
1777 /* Forget any previously recorded base line for line number display. */
1778 w
->base_line_number
= Qnil
;
1780 pos
= *vmotion (PT
, - (height
/ 2), w
);
1781 /* Set startp here explicitly in case that helps avoid an infinite loop
1782 in case the window-scroll-functions functions get errors. */
1783 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
1784 if (! NILP (Vwindow_scroll_functions
))
1786 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1787 make_number (pos
.bufpos
));
1788 pos
.bufpos
= marker_position (w
->start
);
1790 try_window (window
, pos
.bufpos
);
1792 startp
= marker_position (w
->start
);
1793 w
->start_at_line_beg
1794 = (startp
== BEGV
|| FETCH_CHAR (startp
- 1) == '\n') ? Qt
: Qnil
;
1797 if ((update_mode_line
1798 /* If window not full width, must redo its mode line
1799 if the window to its side is being redone */
1800 || (!just_this_one
&& width
< FRAME_WIDTH (f
) - 1)
1801 || INTEGERP (w
->base_line_pos
)
1802 || (!NILP (w
->column_number_displayed
)
1803 && XFASTINT (w
->column_number_displayed
) != current_column ()))
1804 && height
!= XFASTINT (w
->height
))
1805 display_mode_line (w
);
1806 if (! line_number_displayed
1807 && ! BUFFERP (w
->base_line_pos
))
1809 w
->base_line_pos
= Qnil
;
1810 w
->base_line_number
= Qnil
;
1813 /* When we reach a frame's selected window, redo the frame's menu bar. */
1814 if (update_mode_line
1815 && (FRAME_WINDOW_P (f
)
1817 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1818 FRAME_EXTERNAL_MENU_BAR (f
)
1820 FRAME_MENU_BAR_LINES (f
) > 0
1822 : FRAME_MENU_BAR_LINES (f
) > 0)
1823 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
1824 display_menu_bar (w
);
1827 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1829 int start
, end
, whole
;
1831 /* Calculate the start and end positions for the current window.
1832 At some point, it would be nice to choose between scrollbars
1833 which reflect the whole buffer size, with special markers
1834 indicating narrowing, and scrollbars which reflect only the
1837 Note that minibuffers sometimes aren't displaying any text. */
1838 if (! MINI_WINDOW_P (w
)
1839 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
1842 start
= marker_position (w
->start
) - BEGV
;
1843 /* I don't think this is guaranteed to be right. For the
1844 moment, we'll pretend it is. */
1845 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
1847 if (end
< start
) end
= start
;
1848 if (whole
< (end
- start
)) whole
= end
- start
;
1851 start
= end
= whole
= 0;
1853 /* Indicate what this scroll bar ought to be displaying now. */
1854 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
1856 /* Note that we actually used the scroll bar attached to this window,
1857 so it shouldn't be deleted at the end of redisplay. */
1858 (*redeem_scroll_bar_hook
) (w
);
1861 BUF_PT (current_buffer
) = opoint
;
1862 if (update_mode_line
)
1863 set_buffer_internal_1 (old
);
1865 set_buffer_temp (old
);
1866 BUF_PT (current_buffer
) = lpoint
;
1869 /* Do full redisplay on one window, starting at position `pos'. */
1872 try_window (window
, pos
)
1876 register struct window
*w
= XWINDOW (window
);
1877 register int height
= window_internal_height (w
);
1878 register int vpos
= XFASTINT (w
->top
);
1879 register int last_text_vpos
= vpos
;
1880 int tab_offset
= pos_tab_offset (w
, pos
);
1881 FRAME_PTR f
= XFRAME (w
->frame
);
1882 int width
= window_internal_width (w
) - 1;
1883 struct position val
;
1885 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1887 overlay_arrow_seen
= 0;
1888 zv_strings_seen
= 0;
1889 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1891 while (--height
>= 0)
1893 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, tab_offset
);
1894 tab_offset
+= width
;
1895 /* For the first line displayed, display_text_line
1896 subtracts the prompt width from the tab offset.
1897 But it does not affect the value of our variable tab_offset.
1898 So we do the subtraction again,
1899 for the sake of continuation lines of that first line. */
1900 if (MINI_WINDOW_P (w
) && vpos
== XFASTINT (w
->top
))
1901 tab_offset
-= minibuf_prompt_width
;
1903 if (val
.vpos
) tab_offset
= 0;
1905 if (pos
!= val
.bufpos
)
1908 #ifdef USE_TEXT_PROPERTIES
1909 Lisp_Object invis_prop
;
1910 invis_prop
= Fget_char_property (val
.bufpos
-1, Qinvisible
, window
);
1911 invis
= TEXT_PROP_MEANS_INVISIBLE (invis_prop
);
1915 /* Next line, unless prev line ended in end of buffer with no cr */
1917 && (FETCH_CHAR (val
.bufpos
- 1) != '\n' || invis
));
1922 /* If last line is continued in middle of character,
1923 include the split character in the text considered on the frame */
1924 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
1927 /* If bottom just moved off end of frame, change mode line percentage. */
1928 if (XFASTINT (w
->window_end_pos
) == 0
1930 w
->update_mode_line
= Qt
;
1932 /* Say where last char on frame will be, once redisplay is finished. */
1933 XSETFASTINT (w
->window_end_pos
, Z
- pos
);
1934 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
- XFASTINT (w
->top
));
1935 /* But that is not valid info until redisplay finishes. */
1936 w
->window_end_valid
= Qnil
;
1939 /* Try to redisplay when buffer is modified locally,
1940 computing insert/delete line to preserve text outside
1941 the bounds of the changes.
1942 Return 1 if successful, 0 if if cannot tell what to do,
1943 or -1 to tell caller to find a new window start,
1944 or -2 to tell caller to do normal redisplay with same window start. */
1947 try_window_id (window
)
1951 register struct window
*w
= XWINDOW (window
);
1952 register int height
= window_internal_height (w
);
1953 FRAME_PTR f
= XFRAME (w
->frame
);
1954 int top
= XFASTINT (w
->top
);
1955 int start
= marker_position (w
->start
);
1956 int width
= window_internal_width (w
) - 1;
1957 int hscroll
= XINT (w
->hscroll
);
1958 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1961 register int i
, tem
;
1962 int last_text_vpos
= 0;
1964 int selective
= (INTEGERP (current_buffer
->selective_display
)
1965 ? XINT (current_buffer
->selective_display
)
1966 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1968 struct position val
, bp
, ep
, xp
, pp
;
1969 int scroll_amount
= 0;
1971 int tab_offset
, epto
, old_tick
;
1973 if (GPT
- BEG
< beg_unchanged
)
1974 beg_unchanged
= GPT
- BEG
;
1975 if (Z
- GPT
< end_unchanged
)
1976 end_unchanged
= Z
- GPT
;
1978 if (beg_unchanged
+ BEG
< start
)
1979 return 0; /* Give up if changes go above top of window */
1981 /* Find position before which nothing is changed. */
1982 bp
= *compute_motion (start
, 0, lmargin
, 0,
1983 min (ZV
, beg_unchanged
+ BEG
), height
, 0,
1984 width
, hscroll
, pos_tab_offset (w
, start
), w
);
1985 if (bp
.vpos
>= height
)
1989 /* All changes are beyond the window end, and point is on the screen.
1990 We don't need to change the text at all.
1991 But we need to update window_end_pos to account for
1992 any change in buffer size. */
1993 bp
= *compute_motion (start
, 0, lmargin
, 0,
1995 width
, hscroll
, pos_tab_offset (w
, start
), w
);
1996 XSETFASTINT (w
->window_end_vpos
, height
);
1997 XSETFASTINT (w
->window_end_pos
, Z
- bp
.bufpos
);
2005 /* Find beginning of that frame line. Must display from there. */
2006 bp
= *vmotion (bp
.bufpos
, 0, w
);
2014 /* If about to start displaying at the beginning of a continuation line,
2015 really start with previous frame line, in case it was not
2016 continued when last redisplayed */
2017 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
2019 /* Likewise if we have to worry about selective display. */
2020 (selective
> 0 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
2022 bp
= *vmotion (bp
.bufpos
, -1, w
);
2027 if (bp
.contin
&& bp
.hpos
!= lmargin
)
2029 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
2036 /* Find first visible newline after which no more is changed. */
2037 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
2039 while (tem
< ZV
- 1 && (indented_beyond_p (tem
, selective
)))
2040 tem
= find_next_newline (tem
, 1);
2042 /* Compute the cursor position after that newline. */
2043 ep
= *compute_motion (pos
, vpos
, val
.hpos
, did_motion
, tem
,
2044 height
, - (1 << (BITS_PER_SHORT
- 1)),
2045 width
, hscroll
, pos_tab_offset (w
, bp
.bufpos
), w
);
2047 /* If changes reach past the text available on the frame,
2048 just display rest of frame. */
2049 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
2052 stop_vpos
= ep
.vpos
;
2054 /* If no newline before ep, the line ep is on includes some changes
2055 that must be displayed. Make sure we don't stop before it. */
2056 /* Also, if changes reach all the way until ep.bufpos,
2057 it is possible that something was deleted after the
2058 newline before it, so the following line must be redrawn. */
2059 if (stop_vpos
== ep
.vpos
2060 && (ep
.bufpos
== BEGV
2061 || FETCH_CHAR (ep
.bufpos
- 1) != '\n'
2062 || ep
.bufpos
== Z
- end_unchanged
))
2063 stop_vpos
= ep
.vpos
+ 1;
2066 overlay_arrow_seen
= 0;
2067 zv_strings_seen
= 0;
2069 /* If changes do not reach to bottom of window,
2070 figure out how much to scroll the rest of the window */
2071 if (stop_vpos
< height
)
2073 /* Now determine how far up or down the rest of the window has moved */
2074 epto
= pos_tab_offset (w
, ep
.bufpos
);
2075 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2076 Z
- XFASTINT (w
->window_end_pos
),
2077 10000, 0, width
, hscroll
, epto
, w
);
2078 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
2080 /* Is everything on frame below the changes whitespace?
2081 If so, no scrolling is really necessary. */
2082 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
2084 tem
= FETCH_CHAR (i
);
2085 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
2091 XSETFASTINT (w
->window_end_vpos
,
2092 XFASTINT (w
->window_end_vpos
) + scroll_amount
);
2094 /* Before doing any scrolling, verify that point will be on frame. */
2095 if (PT
> ep
.bufpos
&& !(PT
<= xp
.bufpos
&& xp
.bufpos
< height
))
2097 if (PT
<= xp
.bufpos
)
2099 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2100 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2101 width
, hscroll
, epto
, w
);
2105 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
, 1,
2106 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2108 pos_tab_offset (w
, xp
.bufpos
), w
);
2110 if (pp
.bufpos
< PT
|| pp
.vpos
== height
)
2112 cursor_vpos
= pp
.vpos
+ top
;
2113 cursor_hpos
= XFASTINT (w
->left
) + minmax (0, pp
.hpos
, width
);
2116 if (stop_vpos
- scroll_amount
>= height
2117 || ep
.bufpos
== xp
.bufpos
)
2119 if (scroll_amount
< 0)
2120 stop_vpos
-= scroll_amount
;
2122 /* In this path, we have altered window_end_vpos
2123 and not left it negative.
2124 We must make sure that, in case display is preempted
2125 before the frame changes to reflect what we do here,
2126 further updates will not come to try_window_id
2127 and assume the frame and window_end_vpos match. */
2128 blank_end_of_window
= 1;
2130 else if (!scroll_amount
)
2132 /* Even if we don't need to scroll, we must adjust the
2133 charstarts of subsequent lines (that we won't redisplay)
2134 according to the amount of text inserted or deleted. */
2135 int oldpos
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2136 int adjust
= ep
.bufpos
- oldpos
;
2137 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1, adjust
);
2139 else if (bp
.bufpos
== Z
- end_unchanged
)
2141 /* If reprinting everything is nearly as fast as scrolling,
2142 don't bother scrolling. Can happen if lines are short. */
2143 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
2144 top
+ height
- max (0, scroll_amount
),
2146 > xp
.bufpos
- bp
.bufpos
- 20)
2147 /* Return "try normal display with same window-start."
2148 Too bad we can't prevent further scroll-thinking. */
2150 /* If pure deletion, scroll up as many lines as possible.
2151 In common case of killing a line, this can save the
2152 following line from being overwritten by scrolling
2153 and therefore having to be redrawn. */
2154 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
2155 top
+ height
- max (0, scroll_amount
),
2156 scroll_amount
, bp
.bufpos
);
2161 /* scroll_frame_lines did not properly adjust subsequent
2162 lines' charstarts in the case where the text of the
2163 screen line at bp.vpos has changed.
2164 (This can happen in a deletion that ends in mid-line.)
2165 To adjust properly, we need to make things consistent
2167 So do a second adjust to make that happen.
2168 Note that stop_vpos >= ep.vpos, so it is sufficient
2169 to update the charstarts for lines at ep.vpos and below. */
2171 = FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2172 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1,
2173 ep
.bufpos
- oldstart
);
2176 else if (scroll_amount
)
2178 /* If reprinting everything is nearly as fast as scrolling,
2179 don't bother scrolling. Can happen if lines are short. */
2180 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
2181 overestimate of cost of reprinting, since xp.bufpos
2182 would end up below the bottom of the window. */
2183 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
2184 top
+ height
- max (0, scroll_amount
),
2186 > xp
.bufpos
- ep
.bufpos
- 20)
2187 /* Return "try normal display with same window-start."
2188 Too bad we can't prevent further scroll-thinking. */
2190 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
2191 top
+ height
- max (0, scroll_amount
),
2192 scroll_amount
, ep
.bufpos
);
2193 if (!tem
) stop_vpos
= height
;
2197 /* In any case, do not display past bottom of window */
2198 if (stop_vpos
>= height
)
2204 /* Handle case where pos is before w->start --
2205 can happen if part of line had been clipped and is not clipped now */
2206 if (vpos
== 0 && pos
< marker_position (w
->start
))
2207 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2209 /* Redisplay the lines where the text was changed */
2210 last_text_vpos
= vpos
;
2211 tab_offset
= pos_tab_offset (w
, pos
);
2212 /* If we are starting display in mid-character, correct tab_offset
2213 to account for passing the line that that character really starts in. */
2214 if (val
.hpos
< lmargin
)
2215 tab_offset
+= width
;
2217 while (vpos
< stop_vpos
)
2219 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
2220 /* If display_text_line ran a hook and changed some text,
2221 redisplay all the way to bottom of buffer
2222 So that we show the changes. */
2223 if (old_tick
!= MODIFF
)
2225 tab_offset
+= width
;
2226 if (val
.vpos
) tab_offset
= 0;
2227 if (pos
!= val
.bufpos
)
2229 /* Next line, unless prev line ended in end of buffer with no cr */
2230 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
2234 /* There are two cases:
2235 1) we have displayed down to the bottom of the window
2236 2) we have scrolled lines below stop_vpos by scroll_amount */
2240 /* If last line is continued in middle of character,
2241 include the split character in the text considered on the frame */
2242 if (val
.hpos
< lmargin
)
2244 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
);
2245 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2248 /* If scrolling made blank lines at window bottom,
2249 redisplay to fill those lines */
2250 if (scroll_amount
< 0)
2252 /* Don't consider these lines for general-purpose scrolling.
2253 That will save time in the scrolling computation. */
2254 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
2259 vpos
= height
+ scroll_amount
;
2260 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
2262 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
2266 blank_end_of_window
= 1;
2267 tab_offset
= pos_tab_offset (w
, pos
);
2268 /* If we are starting display in mid-character, correct tab_offset
2269 to account for passing the line that that character starts in. */
2270 if (val
.hpos
< lmargin
)
2271 tab_offset
+= width
;
2273 while (vpos
< height
)
2275 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
2276 tab_offset
+= width
;
2277 if (val
.vpos
) tab_offset
= 0;
2281 /* Here is a case where display_text_line sets cursor_vpos wrong.
2282 Make it be fixed up, below. */
2288 /* If bottom just moved off end of frame, change mode line percentage. */
2289 if (XFASTINT (w
->window_end_pos
) == 0
2291 w
->update_mode_line
= Qt
;
2293 /* Attempt to adjust end-of-text positions to new bottom line */
2296 delta
= height
- xp
.vpos
;
2298 || (delta
> 0 && xp
.bufpos
<= ZV
)
2299 || (delta
== 0 && xp
.hpos
))
2301 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), delta
, w
);
2302 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2303 XSETFASTINT (w
->window_end_vpos
,
2304 XFASTINT (w
->window_end_vpos
) + val
.vpos
);
2308 w
->window_end_valid
= Qnil
;
2310 /* If point was not in a line that was displayed, find it */
2311 if (cursor_vpos
< 0)
2314 val
= *compute_motion (start
, 0, lmargin
, 0, PT
, 10000, 10000,
2315 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2316 /* Admit failure if point is off frame now */
2317 if (val
.vpos
>= height
)
2319 for (vpos
= 0; vpos
< height
; vpos
++)
2320 cancel_line (vpos
+ top
, f
);
2323 cursor_vpos
= val
.vpos
+ top
;
2324 cursor_hpos
= XFASTINT (w
->left
) + minmax (0, val
.hpos
, width
);
2327 FRAME_CURSOR_X (f
) = cursor_hpos
;
2328 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2332 val
= *compute_motion (start
, 0, lmargin
, 0, ZV
,
2333 height
, - (1 << (BITS_PER_SHORT
- 1)),
2334 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2335 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
2337 if (XFASTINT (w
->window_end_pos
)
2345 /* Mark a section of BUF as modified, but only for the sake of redisplay.
2346 This is useful for recording changes to overlays.
2348 We increment the buffer's modification timestamp and set the
2349 redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
2350 as if the region of text between START and END had been modified;
2351 the redisplay code will check this against the windows' timestamps,
2352 and redraw the appropriate area of the buffer.
2354 However, if the buffer is unmodified, we bump the last-save
2355 timestamp as well, so that incrementing the timestamp doesn't fool
2356 Emacs into thinking that the buffer's text has been modified.
2358 Tweaking the timestamps shouldn't hurt the first-modification
2359 timestamps recorded in the undo records; those values aren't
2360 written until just before a real text modification is made, so they
2361 will never catch the timestamp value just before this function gets
2365 redisplay_region (buf
, start
, end
)
2375 start
= end
; end
= temp
;
2378 /* If this is a buffer not in the selected window,
2379 we must do other windows. */
2380 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
2381 windows_or_buffers_changed
= 1;
2382 /* If it's not current, we can't use beg_unchanged, end_unchanged for it. */
2383 else if (buf
!= current_buffer
)
2384 windows_or_buffers_changed
= 1;
2385 /* If multiple windows show this buffer, we must do other windows. */
2386 else if (buffer_shared
> 1)
2387 windows_or_buffers_changed
= 1;
2390 if (unchanged_modified
== MODIFF
)
2392 beg_unchanged
= start
- BEG
;
2393 end_unchanged
= Z
- end
;
2397 if (Z
- end
< end_unchanged
)
2398 end_unchanged
= Z
- end
;
2399 if (start
- BEG
< beg_unchanged
)
2400 beg_unchanged
= start
- BEG
;
2404 /* Increment the buffer's time stamp, but also increment the save
2405 and autosave timestamps, so as not to screw up that timekeeping. */
2406 if (BUF_MODIFF (buf
) == BUF_SAVE_MODIFF (buf
))
2407 BUF_SAVE_MODIFF (buf
)++;
2408 if (BUF_MODIFF (buf
) == buf
->auto_save_modified
)
2409 buf
->auto_save_modified
++;
2411 BUF_MODIFF (buf
) ++;
2415 /* Copy LEN glyphs starting address FROM to the rope TO.
2416 But don't actually copy the parts that would come in before S.
2417 Value is TO, advanced past the copied data.
2418 F is the frame we are displaying in. */
2421 copy_part_of_rope (f
, to
, s
, from
, len
, face
)
2423 register GLYPH
*to
; /* Copy to here. */
2424 register GLYPH
*s
; /* Starting point. */
2425 Lisp_Object
*from
; /* Data to copy. */
2427 int face
; /* Face to apply to glyphs which don't specify one. */
2430 register Lisp_Object
*fp
= from
;
2431 /* These cache the results of the last call to compute_glyph_face. */
2433 int last_merged
= 0;
2436 if (! FRAME_TERMCAP_P (f
))
2439 int glyph
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
2442 if (FAST_GLYPH_FACE (glyph
) == 0)
2443 /* If GLYPH has no face code, use FACE. */
2445 else if (FAST_GLYPH_FACE (glyph
) == last_code
)
2446 /* If it's same as previous glyph, use same result. */
2447 facecode
= last_merged
;
2450 /* Merge this glyph's face and remember the result. */
2451 last_code
= FAST_GLYPH_FACE (glyph
);
2452 last_merged
= facecode
= compute_glyph_face (f
, last_code
, face
);
2456 *to
= FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph
), facecode
);
2464 if (to
>= s
) *to
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
2471 /* Correct a glyph by replacing its specified user-level face code
2472 with a displayable computed face code. */
2475 fix_glyph (f
, glyph
, cface
)
2481 if (! FRAME_TERMCAP_P (f
))
2483 if (FAST_GLYPH_FACE (glyph
) != 0)
2484 cface
= compute_glyph_face (f
, FAST_GLYPH_FACE (glyph
), cface
);
2485 glyph
= FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph
), cface
);
2491 /* Display one line of window W, starting at position START in W's buffer.
2493 Display starting at horizontal position HPOS, expressed relative to
2494 W's left edge. In situations where the text at START shouldn't
2495 start at the left margin (i.e. when the window is hscrolled, or
2496 we're continuing a line which left off in the midst of a
2497 multi-column character), HPOS should be negative; we throw away
2498 characters up 'til hpos = 0. So, HPOS must take hscrolling into
2501 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
2503 Display on position VPOS on the frame. It is origin 0, relative to
2504 the top of the frame, not W.
2506 Returns a STRUCT POSITION giving character to start next line with
2507 and where to display it, including a zero or negative hpos.
2508 The vpos field is not really a vpos; it is 1 unless the line is continued */
2510 struct position val_display_text_line
;
2512 static struct position
*
2513 display_text_line (w
, start
, vpos
, hpos
, taboffset
)
2520 register int pos
= start
;
2524 register unsigned char *p
;
2526 register GLYPH
*leftmargin
;
2527 register GLYPH
*p1prev
;
2528 register GLYPH
*p1start
;
2531 FRAME_PTR f
= XFRAME (w
->frame
);
2532 int tab_width
= XINT (current_buffer
->tab_width
);
2533 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
2534 int width
= window_internal_width (w
) - 1;
2535 struct position val
;
2538 int last_invis_skip
= 0;
2539 Lisp_Object last_invis_prop
;
2540 int hscroll
= XINT (w
->hscroll
);
2541 int truncate
= (hscroll
2542 || (truncate_partial_width_windows
2543 && XFASTINT (w
->width
) < FRAME_WIDTH (f
))
2544 || !NILP (current_buffer
->truncate_lines
));
2546 /* 1 if we should highlight the region. */
2547 int highlight_region
2548 = !NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
);
2549 int region_beg
, region_end
;
2551 int selective
= (INTEGERP (current_buffer
->selective_display
)
2552 ? XINT (current_buffer
->selective_display
)
2553 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
2554 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
2555 register struct Lisp_Char_Table
*dp
= window_display_table (w
);
2557 Lisp_Object default_invis_vector
[3];
2558 /* Number of characters of ellipsis to display after an invisible line
2559 if it calls for an ellipsis.
2560 Note that this value can be nonzero regardless of whether
2561 selective display is enabled--you must check that separately. */
2563 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
2564 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
2565 : !NILP (current_buffer
->selective_display_ellipses
) ? 3 : 0);
2566 /* This is the sequence of Lisp objects to display
2567 when there are invisible lines. */
2568 Lisp_Object
*invis_vector_contents
2569 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
2570 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
2571 : default_invis_vector
);
2573 GLYPH truncator
= (dp
== 0 || !INTEGERP (DISP_TRUNC_GLYPH (dp
))
2574 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
2575 GLYPH continuer
= (dp
== 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp
))
2576 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
2578 /* The next buffer location at which the face should change, due
2579 to overlays or text property changes. */
2580 int next_face_change
;
2582 /* The next location where the `invisible' property changes, or an
2583 overlay starts or ends. */
2586 /* The face we're currently using. */
2587 int current_face
= 0;
2590 XSETFASTINT (default_invis_vector
[2], '.');
2591 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
2593 hpos
+= XFASTINT (w
->left
);
2594 get_display_line (f
, vpos
, XFASTINT (w
->left
));
2595 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
2597 /* Show where to highlight the region. */
2598 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
2599 /* Maybe highlight only in selected window. */
2600 && (highlight_nonselected_windows
2601 || w
== XWINDOW (selected_window
)))
2603 region_beg
= marker_position (current_buffer
->mark
);
2604 if (PT
< region_beg
)
2606 region_end
= region_beg
;
2611 w
->region_showing
= Qt
;
2614 region_beg
= region_end
= -1;
2616 if (MINI_WINDOW_P (w
)
2618 && vpos
== XFASTINT (w
->top
))
2620 if (! NILP (minibuf_prompt
))
2622 minibuf_prompt_width
2623 = (display_string (w
, vpos
, XSTRING (minibuf_prompt
)->data
,
2624 XSTRING (minibuf_prompt
)->size
, hpos
,
2625 /* Display a space if we truncate. */
2628 /* Truncate the prompt a little before the
2629 margin, so user input can at least start
2630 on the first line. */
2631 w
->width
> 10 ? w
->width
- 4 : -1)
2633 hpos
+= minibuf_prompt_width
;
2634 taboffset
-= minibuf_prompt_width
;
2637 minibuf_prompt_width
= 0;
2640 /* If we're hscrolled at all, use compute_motion to skip over any
2641 text off the left edge of the window. compute_motion may know
2642 tricks to do this faster than we can. */
2645 struct position
*left_edge
2646 = compute_motion (pos
, vpos
, hpos
, 0,
2648 width
, hscroll
, taboffset
, w
);
2650 /* Retrieve the buffer position and column provided by
2651 compute_motion. We can't assume that the column will be
2652 zero, because you may have multi-column characters crossing
2655 compute_motion may have moved us past the screen position we
2656 requested, if we hit a multi-column character, or the end of
2657 the line. If so, back up. */
2658 if (left_edge
->vpos
> vpos
2659 || left_edge
->hpos
> 0)
2661 pos
= left_edge
->bufpos
- 1;
2662 hpos
= left_edge
->prevhpos
;
2666 pos
= left_edge
->bufpos
;
2667 hpos
= left_edge
->hpos
;
2671 desired_glyphs
->bufp
[vpos
] = start
;
2672 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2674 charstart
= desired_glyphs
->charstarts
[vpos
] + hpos
;
2675 /* In case we don't ever write anything into it... */
2676 desired_glyphs
->charstarts
[vpos
][XFASTINT (w
->left
)] = -1;
2677 leftmargin
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
2678 endp
= leftmargin
+ width
;
2680 /* Arrange the overlays nicely for our purposes. Usually, we call
2681 display_text_line on only one line at a time, in which case this
2682 can't really hurt too much, or we call it on lines which appear
2683 one after another in the buffer, in which case all calls to
2684 recenter_overlay_lists but the first will be pretty cheap. */
2685 recenter_overlay_lists (current_buffer
, pos
);
2687 /* Loop generating characters.
2688 Stop at end of buffer, before newline,
2689 if reach or pass continuation column,
2690 or at face change. */
2692 next_face_change
= pos
;
2693 next_boundary
= pos
;
2702 while (pos
== next_boundary
)
2704 Lisp_Object position
, limit
, prop
, ww
;
2706 /* Display the overlay strings here, unless we're at ZV
2707 and have already displayed the appropriate strings
2708 on an earlier line. */
2709 if (pos
< ZV
|| !zv_strings_seen
++)
2713 ovlen
= overlay_strings (pos
, w
, &ovstr
);
2714 for (; ovlen
; ovlen
--, ovstr
++)
2716 if (p1
>= leftmargin
&& p1
< endp
)
2717 *p1
= MAKE_GLYPH (f
, *ovstr
, current_face
);
2722 /* Did we reach point? Record the cursor location. */
2723 if (pos
== PT
&& cursor_vpos
< 0)
2726 cursor_hpos
= p1
- leftmargin
;
2732 XSETFASTINT (position
, pos
);
2733 limit
= Fnext_overlay_change (position
);
2734 #ifdef USE_TEXT_PROPERTIES
2735 /* This is just an estimate to give reasonable
2736 performance; nothing should go wrong if it is too small. */
2737 if (XFASTINT (limit
) > pos
+ 50)
2738 XSETFASTINT (limit
, pos
+ 50);
2739 limit
= Fnext_single_property_change (position
, Qinvisible
,
2740 Fcurrent_buffer (), limit
);
2742 next_boundary
= XFASTINT (limit
);
2743 /* if the `invisible' property is set, we can skip to
2744 the next property change. */
2746 prop
= Fget_char_property (position
, Qinvisible
, ww
);
2747 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
2749 if (pos
< PT
&& next_boundary
>= PT
)
2752 cursor_hpos
= p1
- leftmargin
;
2754 pos
= next_boundary
;
2755 last_invis_skip
= pos
;
2756 last_invis_prop
= prop
;
2760 /* Did we reach point? Record the cursor location. */
2761 if (pos
== PT
&& cursor_vpos
< 0)
2764 cursor_hpos
= p1
- leftmargin
;
2767 /* Did we hit the end of the visible region of the buffer?
2771 /* Update charstarts for the end of this line. */
2772 /* Do nothing if off the left edge or at the right edge. */
2773 if (p1
>= leftmargin
&& p1
+ 1 != endp
)
2775 int *p2x
= &charstart
[(p1
< leftmargin
2783 /* Figure out where (if at all) the
2784 redisplay_end_trigger-hook should run. */
2785 if (MARKERP (w
->redisplay_end_trigger
)
2786 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
2787 e_t_h
= marker_position (w
->redisplay_end_trigger
);
2788 else if (INTEGERP (w
->redisplay_end_trigger
))
2789 e_t_h
= XINT (w
->redisplay_end_trigger
);
2793 /* If we've gone past the place to run a hook,
2795 if (pos
>= e_t_h
&& e_t_h
!= ZV
)
2797 Lisp_Object args
[3];
2799 args
[0] = Qredisplay_end_trigger_functions
;
2800 XSETWINDOW (args
[1], w
);
2801 XSETINT (args
[2], e_t_h
);
2803 /* Since we are *trying* to run these functions,
2804 don't try to run them again, even if they get an error. */
2805 w
->redisplay_end_trigger
= Qnil
;
2806 Frun_hook_with_args (3, args
);
2809 /* Notice if it changed the face of this character. */
2810 next_face_change
= pos
;
2814 /* Did we hit a face change? Figure out what face we should
2815 use now. We also hit this the first time through the
2816 loop, to see what face we should start with. */
2817 if (pos
>= next_face_change
&& (FRAME_WINDOW_P (f
)))
2818 current_face
= compute_char_face (f
, w
, pos
,
2819 region_beg
, region_end
,
2820 &next_face_change
, pos
+ 50, 0);
2823 /* Compute the next place we need to stop
2824 and do something special; set PAUSE. */
2828 if (pos
< next_boundary
&& next_boundary
< pause
)
2829 pause
= next_boundary
;
2830 if (pos
< next_face_change
&& next_face_change
< pause
)
2831 pause
= next_face_change
;
2836 /* Wouldn't you hate to read the next line to someone over
2838 if (pos
< PT
&& PT
< pause
)
2840 if (pos
< GPT
&& GPT
< pause
)
2843 p
= &FETCH_CHAR (pos
);
2852 /* Let a display table override all standard display methods. */
2853 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
2855 p1
= copy_part_of_rope (f
, p1
, leftmargin
,
2856 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
2857 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
2860 else if (c
>= 040 && c
< 0177)
2862 if (p1
>= leftmargin
)
2863 *p1
= MAKE_GLYPH (f
, c
, current_face
);
2869 if (last_invis_skip
== pos
2870 && TEXT_PROP_MEANS_INVISIBLE_WITH_ELLIPSIS (last_invis_prop
))
2874 && indented_beyond_p (pos
+ 1, selective
))
2877 pos
= find_next_newline (pos
+ 1, 1);
2878 if (FETCH_CHAR (pos
- 1) == '\n')
2881 if (invis
&& selective_rlen
> 0 && p1
>= leftmargin
)
2883 p1
+= selective_rlen
;
2884 if (p1
- leftmargin
> width
)
2886 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
2887 (p1
- p1prev
), current_face
);
2890 /* Draw the face of the newline character as extending all the
2891 way to the end of the frame line. */
2894 if (p1
< leftmargin
)
2897 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
);
2901 /* Update charstarts for the newline that ended this line. */
2902 /* Do nothing here for a char that's entirely off the left edge
2903 or if it starts at the right edge. */
2904 if (p1
>= leftmargin
&& p1prev
!= endp
)
2906 /* Store the newline's position into charstarts
2907 for the column where the newline starts.
2908 Store -1 for the rest of the glyphs it occupies. */
2909 int *p2x
= &charstart
[(p1prev
< leftmargin
2910 ? leftmargin
: p1prev
)
2912 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
2925 if (p1
>= leftmargin
&& p1
< endp
)
2926 *p1
= MAKE_GLYPH (f
, ' ', current_face
);
2929 while ((p1
- leftmargin
+ taboffset
+ hscroll
- (hscroll
> 0))
2932 else if (c
== Ctl ('M') && selective
== -1)
2934 pos
= find_next_newline (pos
, 1);
2935 if (FETCH_CHAR (pos
- 1) == '\n')
2937 if (selective_rlen
> 0)
2939 p1
+= selective_rlen
;
2940 if (p1
- leftmargin
> width
)
2942 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
2943 (p1
- p1prev
), current_face
);
2946 /* Draw the face of the newline character as extending all the
2947 way to the end of the frame line. */
2950 if (p1
< leftmargin
)
2953 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
);
2957 /* Update charstarts for the ^M that ended this line. */
2958 /* Do nothing here for a char that's entirely off the left edge
2959 or if it starts at the right edge. */
2960 if (p1
>= leftmargin
&& p1prev
!= endp
)
2962 /* Store the newline's position into charstarts
2963 for the column where the newline starts.
2964 Store -1 for the rest of the glyphs it occupies. */
2965 int *p2x
= &charstart
[(p1prev
< leftmargin
2966 ? leftmargin
: p1prev
)
2968 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
2976 else if (c
< 0200 && ctl_arrow
)
2978 if (p1
>= leftmargin
)
2979 *p1
= fix_glyph (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
2980 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
2983 if (p1
>= leftmargin
&& p1
< endp
)
2984 *p1
= MAKE_GLYPH (f
, c
^ 0100, current_face
);
2989 if (p1
>= leftmargin
)
2990 *p1
= fix_glyph (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
2991 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
2994 if (p1
>= leftmargin
&& p1
< endp
)
2995 *p1
= MAKE_GLYPH (f
, (c
>> 6) + '0', current_face
);
2997 if (p1
>= leftmargin
&& p1
< endp
)
2998 *p1
= MAKE_GLYPH (f
, (7 & (c
>> 3)) + '0', current_face
);
3000 if (p1
>= leftmargin
&& p1
< endp
)
3001 *p1
= MAKE_GLYPH (f
, (7 & c
) + '0', current_face
);
3008 /* Update charstarts for the character just output. */
3010 /* Do nothing here for a char that's entirely off the left edge. */
3011 if (p1
>= leftmargin
)
3013 /* Store the char's position into charstarts
3014 for the first glyph occupied by this char.
3015 Store -1 for the rest of the glyphs it occupies. */
3018 int *p2x
= &charstart
[(p1prev
< leftmargin
3019 ? leftmargin
: p1prev
)
3021 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3031 val
.hpos
= - XINT (w
->hscroll
);
3039 /* Store 0 in this charstart line for the positions where
3040 there is no character. But do leave what was recorded
3041 for the character that ended the line. */
3042 /* Add 1 in the endtest to compensate for the fact that ENDP was
3043 made from WIDTH, which is 1 less than the window's actual
3045 i
= p1
- p1start
+ 1;
3046 if (p1
< leftmargin
)
3047 i
+= leftmargin
- p1
;
3048 for (; i
< endp
- p1start
+ 1; i
++)
3051 /* Handle continuation in middle of a character */
3052 /* by backing up over it */
3055 /* Don't back up if we never actually displayed any text.
3056 This occurs when the minibuffer prompt takes up the whole line. */
3059 /* Start the next line with that same character */
3061 /* but at negative hpos, to skip the columns output on this line. */
3062 val
.hpos
+= p1prev
- endp
;
3065 /* Keep in this line everything up to the continuation column. */
3069 /* Finish deciding which character to start the next line on,
3070 and what hpos to start it at.
3071 Also set `lastpos' to the last position which counts as "on this line"
3072 for cursor-positioning. */
3076 if (FETCH_CHAR (pos
) == '\n')
3078 /* If stopped due to a newline, start next line after it */
3080 /* Check again for hidden lines, in case the newline occurred exactly
3081 at the right margin. */
3082 while (pos
< ZV
&& selective
> 0
3083 && indented_beyond_p (pos
, selective
))
3084 pos
= find_next_newline (pos
, 1);
3087 /* Stopped due to right margin of window */
3091 *p1
++ = fix_glyph (f
, truncator
, 0);
3092 /* Truncating => start next line after next newline,
3093 and point is on this line if it is before the newline,
3094 and skip none of first char of next line */
3096 pos
= find_next_newline (pos
, 1);
3097 while (pos
< ZV
&& selective
> 0
3098 && indented_beyond_p (pos
, selective
));
3099 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
3101 lastpos
= pos
- (FETCH_CHAR (pos
- 1) == '\n');
3105 *p1
++ = fix_glyph (f
, continuer
, 0);
3112 /* If point is at eol or in invisible text at eol,
3113 record its frame location now. */
3115 if (start
<= PT
&& PT
<= lastpos
&& cursor_vpos
< 0)
3118 cursor_hpos
= p1
- leftmargin
;
3121 if (cursor_vpos
== vpos
)
3123 if (cursor_hpos
< 0) cursor_hpos
= 0;
3124 if (cursor_hpos
> width
) cursor_hpos
= width
;
3125 cursor_hpos
+= XFASTINT (w
->left
);
3126 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
3128 if (!(cursor_in_echo_area
&& FRAME_HAS_MINIBUF_P (f
)
3129 && EQ (FRAME_MINIBUF_WINDOW (f
), minibuf_window
)))
3131 FRAME_CURSOR_Y (f
) = cursor_vpos
;
3132 FRAME_CURSOR_X (f
) = cursor_hpos
;
3135 if (w
== XWINDOW (selected_window
))
3137 /* Line is not continued and did not start
3138 in middle of character */
3139 if ((hpos
- XFASTINT (w
->left
)
3140 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
3143 this_line_bufpos
= start
;
3144 this_line_buffer
= current_buffer
;
3145 this_line_vpos
= cursor_vpos
;
3146 this_line_start_hpos
= hpos
;
3147 this_line_endpos
= Z
- lastpos
;
3150 this_line_bufpos
= 0;
3155 /* If hscroll and line not empty, insert truncation-at-left marker */
3156 if (hscroll
&& lastpos
!= start
)
3158 *leftmargin
= fix_glyph (f
, truncator
, 0);
3159 if (p1
<= leftmargin
)
3160 p1
= leftmargin
+ 1;
3163 if (XFASTINT (w
->width
) + XFASTINT (w
->left
) != FRAME_WIDTH (f
))
3166 if (p1
< leftmargin
) p1
= leftmargin
;
3167 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
3169 /* Don't draw vertical bars if we're using scroll bars. They're
3170 covered up by the scroll bars, and it's distracting to see
3171 them when the scroll bar windows are flickering around to be
3173 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3176 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
3180 *p1
++ = (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
3181 ? DISP_BORDER_GLYPH (dp
)
3184 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
3185 p1
- desired_glyphs
->glyphs
[vpos
]);
3186 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
3188 /* If the start of this line is the overlay arrow-position,
3189 then put the arrow string into the display-line. */
3191 if (MARKERP (Voverlay_arrow_position
)
3192 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
3193 && start
== marker_position (Voverlay_arrow_position
)
3194 && STRINGP (Voverlay_arrow_string
)
3195 && ! overlay_arrow_seen
)
3197 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
3199 int len
= XSTRING (Voverlay_arrow_string
)->size
;
3205 if (!NULL_INTERVAL_P (XSTRING (Voverlay_arrow_string
)->intervals
))
3207 /* If the arrow string has text props, obey them when displaying. */
3208 for (i
= 0; i
< len
; i
++)
3211 Lisp_Object face
, ilisp
;
3214 XSETFASTINT (ilisp
, i
);
3215 face
= Fget_text_property (ilisp
, Qface
, Voverlay_arrow_string
);
3216 newface
= compute_glyph_face_1 (f
, face
, 0);
3217 leftmargin
[i
] = FAST_MAKE_GLYPH (c
, newface
);
3221 #endif /* HAVE_FACES */
3223 for (i
= 0; i
< len
; i
++)
3224 leftmargin
[i
] = p
[i
];
3227 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
3228 arrow_end
= (leftmargin
- desired_glyphs
->glyphs
[vpos
]) + len
;
3229 if (desired_glyphs
->used
[vpos
] < arrow_end
)
3230 desired_glyphs
->used
[vpos
] = arrow_end
;
3232 overlay_arrow_seen
= 1;
3236 val_display_text_line
= val
;
3237 return &val_display_text_line
;
3240 /* Redisplay the menu bar in the frame for window W. */
3243 display_menu_bar (w
)
3246 Lisp_Object items
, tail
;
3247 register int vpos
= 0;
3248 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3249 int maxendcol
= FRAME_WIDTH (f
);
3254 if (!NILP (Vwindow_system
))
3258 #ifdef USE_X_TOOLKIT
3261 #endif /* USE_X_TOOLKIT */
3263 get_display_line (f
, vpos
, 0);
3265 items
= FRAME_MENU_BAR_ITEMS (f
);
3266 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
3268 Lisp_Object pos
, string
;
3269 string
= XVECTOR (items
)->contents
[i
+ 1];
3273 XSETFASTINT (XVECTOR (items
)->contents
[i
+ 3], hpos
);
3275 if (hpos
< maxendcol
)
3276 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
3277 XSTRING (string
)->data
,
3278 XSTRING (string
)->size
,
3279 hpos
, 0, 0, hpos
, maxendcol
);
3280 /* Put a space between items. */
3281 if (hpos
< maxendcol
)
3283 int hpos1
= hpos
+ 1;
3284 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0,
3285 min (hpos1
, maxendcol
), maxendcol
);
3289 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
3290 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
3292 /* Fill out the line with spaces. */
3293 if (maxendcol
> hpos
)
3294 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0, maxendcol
, maxendcol
);
3296 /* Clear the rest of the lines allocated to the menu bar. */
3298 while (vpos
< FRAME_MENU_BAR_LINES (f
))
3299 get_display_line (f
, vpos
++, 0);
3302 /* Display the mode line for window w */
3305 display_mode_line (w
)
3308 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
3309 register int left
= XFASTINT (w
->left
);
3310 register int right
= XFASTINT (w
->width
) + left
;
3311 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3313 line_number_displayed
= 0;
3314 w
->column_number_displayed
= Qnil
;
3316 get_display_line (f
, vpos
, left
);
3318 /* Temporarily make frame F's kboard the current kboard
3319 so that kboard-local variables in the mode_line_format
3320 will get the right values. */
3321 push_frame_kboard (f
);
3323 display_mode_element (w
, vpos
, left
, 0, right
, right
,
3324 current_buffer
->mode_line_format
);
3326 pop_frame_kboard ();
3328 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
3330 /* Make the mode line inverse video if the entire line
3331 is made of mode lines.
3332 I.e. if this window is full width,
3333 or if it is the child of a full width window
3334 (which implies that that window is split side-by-side
3335 and the rest of this line is mode lines of the sibling windows). */
3336 if (XFASTINT (w
->width
) == FRAME_WIDTH (f
)
3337 || XFASTINT (XWINDOW (w
->parent
)->width
) == FRAME_WIDTH (f
))
3338 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
3340 else if (! FRAME_TERMCAP_P (f
) && mode_line_inverse_video
)
3342 /* For a partial width window, explicitly set face of each glyph. */
3344 GLYPH
*ptr
= FRAME_DESIRED_GLYPHS (f
)->glyphs
[vpos
];
3345 for (i
= left
; i
< right
; ++i
)
3346 ptr
[i
] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr
[i
]), 1);
3351 /* Contribute ELT to the mode line for window W.
3352 How it translates into text depends on its data type.
3354 VPOS is the position of the mode line being displayed.
3356 HPOS is the position (absolute on frame) where this element's text
3357 should start. The output is truncated automatically at the right
3360 DEPTH is the depth in recursion. It is used to prevent
3361 infinite recursion here.
3363 MINENDCOL is the hpos before which the element may not end.
3364 The element is padded at the right with spaces if nec
3365 to reach this column.
3367 MAXENDCOL is the hpos past which this element may not extend.
3368 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
3369 (This is necessary to make nested padding and truncation work.)
3371 Returns the hpos of the end of the text generated by ELT.
3372 The next element will receive that value as its HPOS arg,
3373 so as to concatenate the elements. */
3376 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
3378 register int vpos
, hpos
;
3381 register int maxendcol
;
3382 register Lisp_Object elt
;
3390 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
3394 /* A string: output it and check for %-constructs within it. */
3395 register unsigned char c
;
3396 register unsigned char *this = XSTRING (elt
)->data
;
3398 while (hpos
< maxendcol
&& *this)
3400 unsigned char *last
= this;
3401 while ((c
= *this++) != '\0' && c
!= '%')
3403 if (this - 1 != last
)
3405 register int lim
= --this - last
+ hpos
;
3406 if (frame_title_ptr
)
3407 hpos
= store_frame_title (last
, hpos
, min (lim
, maxendcol
));
3409 hpos
= display_string (w
, vpos
, last
, -1, hpos
, 0, 1,
3410 hpos
, min (lim
, maxendcol
));
3414 register int minendcol
;
3415 register int spec_width
= 0;
3417 /* We can't allow -ve args due to the "%-" construct */
3418 /* Argument specifies minwidth but not maxwidth
3419 (maxwidth can be specified by
3420 (<negative-number> . <stuff>) mode-line elements) */
3422 while ((c
= *this++) >= '0' && c
<= '9')
3424 spec_width
= spec_width
* 10 + (c
- '0');
3427 minendcol
= hpos
+ spec_width
;
3428 if (minendcol
> maxendcol
)
3430 spec_width
= maxendcol
- hpos
;
3431 minendcol
= maxendcol
;
3435 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
3436 spec_width
, maxendcol
,
3437 Vglobal_mode_string
);
3440 char *spec
= decode_mode_spec (w
, c
, spec_width
,
3442 if (frame_title_ptr
)
3443 hpos
= store_frame_title (spec
, minendcol
, maxendcol
);
3445 hpos
= display_string (w
, vpos
, spec
, -1,
3447 minendcol
, maxendcol
);
3455 /* A symbol: process the value of the symbol recursively
3456 as if it appeared here directly. Avoid error if symbol void.
3457 Special case: if value of symbol is a string, output the string
3460 register Lisp_Object tem
;
3461 tem
= Fboundp (elt
);
3464 tem
= Fsymbol_value (elt
);
3465 /* If value is a string, output that string literally:
3466 don't check for % within it. */
3469 if (frame_title_ptr
)
3470 hpos
= store_frame_title (XSTRING (tem
)->data
,
3471 minendcol
, maxendcol
);
3473 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
3474 XSTRING (tem
)->size
,
3475 hpos
, 0, 1, minendcol
, maxendcol
);
3477 /* Give up right away for nil or t. */
3478 else if (!EQ (tem
, elt
))
3479 { elt
= tem
; goto tail_recurse
; }
3486 register Lisp_Object car
, tem
;
3488 /* A cons cell: three distinct cases.
3489 If first element is a string or a cons, process all the elements
3490 and effectively concatenate them.
3491 If first element is a negative number, truncate displaying cdr to
3492 at most that many characters. If positive, pad (with spaces)
3493 to at least that many characters.
3494 If first element is a symbol, process the cadr or caddr recursively
3495 according to whether the symbol's value is non-nil or nil. */
3496 car
= XCONS (elt
)->car
;
3499 tem
= Fboundp (car
);
3500 elt
= XCONS (elt
)->cdr
;
3503 /* elt is now the cdr, and we know it is a cons cell.
3504 Use its car if CAR has a non-nil value. */
3507 tem
= Fsymbol_value (car
);
3509 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
3511 /* Symbol's value is nil (or symbol is unbound)
3512 Get the cddr of the original list
3513 and if possible find the caddr and use that. */
3514 elt
= XCONS (elt
)->cdr
;
3517 else if (!CONSP (elt
))
3519 elt
= XCONS (elt
)->car
;
3522 else if (INTEGERP (car
))
3524 register int lim
= XINT (car
);
3525 elt
= XCONS (elt
)->cdr
;
3527 /* Negative int means reduce maximum width.
3528 DO NOT change MINENDCOL here!
3529 (20 -10 . foo) should truncate foo to 10 col
3530 and then pad to 20. */
3531 maxendcol
= min (maxendcol
, hpos
- lim
);
3534 /* Padding specified. Don't let it be more than
3537 if (lim
> maxendcol
)
3539 /* If that's more padding than already wanted, queue it.
3540 But don't reduce padding already specified even if
3541 that is beyond the current truncation point. */
3542 if (lim
> minendcol
)
3547 else if (STRINGP (car
) || CONSP (car
))
3549 register int limit
= 50;
3550 /* LIMIT is to protect against circular lists. */
3551 while (CONSP (elt
) && --limit
> 0
3552 && hpos
< maxendcol
)
3554 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
3557 elt
= XCONS (elt
)->cdr
;
3565 if (frame_title_ptr
)
3566 hpos
= store_frame_title ("*invalid*", minendcol
, maxendcol
);
3568 hpos
= display_string (w
, vpos
, "*invalid*", -1, hpos
, 0, 1,
3569 minendcol
, maxendcol
);
3573 if (minendcol
> hpos
)
3574 if (frame_title_ptr
)
3575 hpos
= store_frame_title ("", minendcol
, maxendcol
);
3577 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 1, minendcol
, maxendcol
);
3581 /* Write a null-terminated, right justified decimal representation of
3582 the positive integer D to BUF using a minimal field width WIDTH. */
3585 pint2str (buf
, width
, d
)
3590 register char *p
= buf
;
3597 *p
++ = d
% 10 + '0';
3600 for (width
-= (int) (p
- buf
); width
> 0; --width
) *p
++ = ' ';
3610 /* Return a string for the output of a mode line %-spec for window W,
3611 generated by character C. SPEC_WIDTH is the field width when
3612 padding to the left (%c, %l). The value returned from this
3613 function will later be truncated to width MAXWIDTH. */
3615 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
3618 decode_mode_spec (w
, c
, spec_width
, maxwidth
)
3621 register int spec_width
;
3622 register int maxwidth
;
3625 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3626 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
3627 struct buffer
*b
= XBUFFER (w
->buffer
);
3630 if (maxwidth
> FRAME_WIDTH (f
))
3631 maxwidth
= FRAME_WIDTH (f
);
3636 if (!NILP (b
->read_only
))
3638 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
3643 /* This differs from %* only for a modified read-only buffer. */
3644 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
3646 if (!NILP (b
->read_only
))
3651 /* This differs from %* in ignoring read-only-ness. */
3652 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
3664 if (command_loop_level
> 5)
3666 p
= decode_mode_spec_buf
;
3667 for (i
= 0; i
< command_loop_level
; i
++)
3670 return decode_mode_spec_buf
;
3678 if (command_loop_level
> 5)
3680 p
= decode_mode_spec_buf
;
3681 for (i
= 0; i
< command_loop_level
; i
++)
3684 return decode_mode_spec_buf
;
3692 if (maxwidth
< sizeof (lots_of_dashes
))
3693 return lots_of_dashes
;
3696 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
3700 return decode_mode_spec_buf
;
3706 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
3708 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
3709 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
3710 decode_mode_spec_buf
[maxwidth
] = '\0';
3711 return decode_mode_spec_buf
;
3718 int col
= current_column ();
3719 XSETFASTINT (w
->column_number_displayed
, col
);
3720 pint2str (decode_mode_spec_buf
, spec_width
, col
);
3721 return decode_mode_spec_buf
;
3725 /* %F displays the frame name. */
3727 if (!NILP (f
->title
))
3728 return (char *) XSTRING (f
->title
)->data
;
3729 if (f
->explicit_name
|| FRAME_TERMCAP_P (f
))
3730 return (char *) XSTRING (f
->name
)->data
;
3739 else if (STRINGP (obj
) && XSTRING (obj
)->size
> maxwidth
)
3741 bcopy ("...", decode_mode_spec_buf
, 3);
3742 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
3743 decode_mode_spec_buf
+ 3, maxwidth
- 3);
3744 return decode_mode_spec_buf
;
3751 int startpos
= marker_position (w
->start
);
3752 int line
, linepos
, topline
;
3755 int height
= XFASTINT (w
->height
);
3757 /* If we decided that this buffer isn't suitable for line numbers,
3758 don't forget that too fast. */
3759 if (EQ (w
->base_line_pos
, w
->buffer
))
3762 /* If the buffer is very big, don't waste time. */
3763 if (BUF_ZV (b
) - BUF_BEGV (b
) > line_number_display_limit
)
3765 w
->base_line_pos
= Qnil
;
3766 w
->base_line_number
= Qnil
;
3770 if (!NILP (w
->base_line_number
)
3771 && !NILP (w
->base_line_pos
)
3772 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
3774 line
= XFASTINT (w
->base_line_number
);
3775 linepos
= XFASTINT (w
->base_line_pos
);
3780 linepos
= BUF_BEGV (b
);
3783 /* Count lines from base line to window start position. */
3784 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
3786 topline
= nlines
+ line
;
3788 /* Determine a new base line, if the old one is too close
3789 or too far away, or if we did not have one.
3790 "Too close" means it's plausible a scroll-down would
3792 if (startpos
== BUF_BEGV (b
))
3794 XSETFASTINT (w
->base_line_number
, topline
);
3795 XSETFASTINT (w
->base_line_pos
, BUF_BEGV (b
));
3797 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
3798 || linepos
== BUF_BEGV (b
))
3800 int limit
= BUF_BEGV (b
);
3802 int distance
= (height
* 2 + 30) * 200;
3804 if (startpos
- distance
> limit
)
3805 limit
= startpos
- distance
;
3807 nlines
= display_count_lines (startpos
, limit
,
3810 /* If we couldn't find the lines we wanted within
3812 give up on line numbers for this window. */
3813 if (position
== startpos
- distance
)
3815 w
->base_line_pos
= w
->buffer
;
3816 w
->base_line_number
= Qnil
;
3820 XSETFASTINT (w
->base_line_number
, topline
- nlines
);
3821 XSETFASTINT (w
->base_line_pos
, position
);
3824 /* Now count lines from the start pos to point. */
3825 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
3827 /* Record that we did display the line number. */
3828 line_number_displayed
= 1;
3830 /* Make the string to show. */
3831 pint2str (decode_mode_spec_buf
, spec_width
, topline
+ nlines
);
3832 return decode_mode_spec_buf
;
3835 char* p
= decode_mode_spec_buf
;
3836 for (spec_width
-= 2; spec_width
> 0; --spec_width
) *p
++ = ' ';
3838 return decode_mode_spec_buf
;
3848 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
3854 int pos
= marker_position (w
->start
);
3855 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
3857 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
3859 if (pos
<= BUF_BEGV (b
))
3864 else if (pos
<= BUF_BEGV (b
))
3868 if (total
> 1000000)
3869 /* Do it differently for a large value, to avoid overflow. */
3870 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
3872 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
3873 /* We can't normally display a 3-digit number,
3874 so get us a 2-digit number that is close. */
3877 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
3878 return decode_mode_spec_buf
;
3882 /* Display percentage of size above the bottom of the screen. */
3885 int toppos
= marker_position (w
->start
);
3886 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
3887 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
3889 if (botpos
>= BUF_ZV (b
))
3891 if (toppos
<= BUF_BEGV (b
))
3898 if (total
> 1000000)
3899 /* Do it differently for a large value, to avoid overflow. */
3900 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
3902 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
3903 /* We can't normally display a 3-digit number,
3904 so get us a 2-digit number that is close. */
3907 if (toppos
<= BUF_BEGV (b
))
3908 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
3910 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
3911 return decode_mode_spec_buf
;
3916 /* status of process */
3917 obj
= Fget_buffer_process (w
->buffer
);
3919 return "no process";
3921 obj
= Fsymbol_name (Fprocess_status (obj
));
3925 case 't': /* indicate TEXT or BINARY */
3926 #ifdef MODE_LINE_BINARY_TEXT
3927 return MODE_LINE_BINARY_TEXT (b
);
3934 return (char *) XSTRING (obj
)->data
;
3939 /* Search for COUNT instances of a line boundary, which means either a
3940 newline or (if selective display enabled) a carriage return.
3941 Start at START. If COUNT is negative, search backwards.
3943 If we find COUNT instances, set *SHORTAGE to zero, and return the
3944 position after the COUNTth match. Note that for reverse motion
3945 this is not the same as the usual convention for Emacs motion commands.
3947 If we don't find COUNT instances before reaching the end of the
3948 buffer (or the beginning, if scanning backwards), set *SHORTAGE to
3949 the number of line boundaries left unfound, and return the end of the
3950 buffer we bumped up against. */
3953 display_scan_buffer (start
, count
, shortage
)
3954 int *shortage
, start
;
3957 int limit
= ((count
> 0) ? ZV
- 1 : BEGV
);
3958 int direction
= ((count
> 0) ? 1 : -1);
3960 register unsigned char *cursor
;
3961 unsigned char *base
;
3963 register int ceiling
;
3964 register unsigned char *ceiling_addr
;
3966 /* If we are not in selective display mode,
3967 check only for newlines. */
3968 if (! (!NILP (current_buffer
->selective_display
)
3969 && !INTEGERP (current_buffer
->selective_display
)))
3970 return scan_buffer ('\n', start
, 0, count
, shortage
, 0);
3972 /* The code that follows is like scan_buffer
3973 but checks for either newline or carriage return. */
3979 while (start
!= limit
+ 1)
3981 ceiling
= BUFFER_CEILING_OF (start
);
3982 ceiling
= min (limit
, ceiling
);
3983 ceiling_addr
= &FETCH_CHAR (ceiling
) + 1;
3984 base
= (cursor
= &FETCH_CHAR (start
));
3987 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
3989 if (cursor
!= ceiling_addr
)
3994 return (start
+ cursor
- base
+ 1);
3997 if (++cursor
== ceiling_addr
)
4003 start
+= cursor
- base
;
4007 start
--; /* first character we scan */
4008 while (start
> limit
- 1)
4009 { /* we WILL scan under start */
4010 ceiling
= BUFFER_FLOOR_OF (start
);
4011 ceiling
= max (limit
, ceiling
);
4012 ceiling_addr
= &FETCH_CHAR (ceiling
) - 1;
4013 base
= (cursor
= &FETCH_CHAR (start
));
4017 while (--cursor
!= ceiling_addr
4018 && *cursor
!= '\n' && *cursor
!= 015)
4020 if (cursor
!= ceiling_addr
)
4025 return (start
+ cursor
- base
+ 1);
4031 start
+= cursor
- base
;
4036 *shortage
= count
* direction
;
4037 return (start
+ ((direction
== 1 ? 0 : 1)));
4040 /* Count up to N lines starting from FROM.
4041 But don't go beyond LIMIT.
4042 Return the number of lines thus found (always positive).
4043 Store the position after what was found into *POS_PTR. */
4046 display_count_lines (from
, limit
, n
, pos_ptr
)
4059 *pos_ptr
= display_scan_buffer (from
, n
, &shortage
);
4065 /* When scanning backwards, scan_buffer stops *after* the last newline
4066 it finds, but does count it. Compensate for that. */
4067 return - n
- shortage
- (*pos_ptr
!= limit
);
4068 return n
- shortage
;
4071 /* Display STRING on one line of window W, starting at HPOS.
4072 Display at position VPOS. Caller should have done get_display_line.
4073 If VPOS == -1, display it as the current frame's title.
4074 LENGTH is the length of STRING, or -1 meaning STRING is null-terminated.
4076 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
4078 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
4079 MAXCOL is the last column ok to end at. Truncate here.
4080 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
4081 Both count from the left edge of the frame, as does HPOS.
4082 The right edge of W is an implicit maximum.
4083 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
4085 OBEY_WINDOW_WIDTH says to put spaces or vertical bars
4086 at the place where the current window ends in this line
4087 and not display anything beyond there. Otherwise, only MAXCOL
4088 controls where to stop output.
4090 Returns ending hpos. */
4093 display_string (w
, vpos
, string
, length
, hpos
, truncate
,
4094 obey_window_width
, mincol
, maxcol
)
4096 unsigned char *string
;
4100 int obey_window_width
;
4106 int hscroll
= XINT (w
->hscroll
);
4107 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
4108 register GLYPH
*start
;
4109 register GLYPH
*end
;
4110 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4111 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
4112 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
4113 int window_width
= XFASTINT (w
->width
);
4115 /* Use the standard display table, not the window's display table.
4116 We don't want the mode line in rot13. */
4117 register struct Lisp_Char_Table
*dp
= 0;
4120 if (DISP_TABLE_P (Vstandard_display_table
))
4121 dp
= XCHAR_TABLE (Vstandard_display_table
);
4123 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
4126 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
4128 if (obey_window_width
)
4130 end
= start
+ window_width
- (truncate
!= 0);
4132 if ((window_width
+ XFASTINT (w
->left
)) != FRAME_WIDTH (f
))
4134 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4138 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
4146 if (! obey_window_width
4147 || (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
))
4148 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
4150 /* Store 0 in charstart for these columns. */
4151 for (i
= (hpos
>= 0 ? hpos
: 0); i
< end
- p1start
+ hpos
; i
++)
4152 desired_glyphs
->charstarts
[vpos
][i
] = 0;
4154 if (maxcol
>= 0 && mincol
> maxcol
)
4157 /* We set truncated to 1 if we get stopped by trying to pass END
4158 (that is, trying to pass MAXCOL.) */
4165 /* Specified length. */
4168 /* Unspecified length (null-terminated string). */
4178 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
4180 p1
= copy_part_of_rope (f
, p1
, start
,
4181 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
4182 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
4185 else if (c
>= 040 && c
< 0177)
4195 if (p1
>= start
&& p1
< end
)
4199 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
4201 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
4204 *p1
= fix_glyph (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
4205 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
4208 if (p1
>= start
&& p1
< end
)
4215 *p1
= fix_glyph (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
4216 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
4219 if (p1
>= start
&& p1
< end
)
4220 *p1
= (c
>> 6) + '0';
4222 if (p1
>= start
&& p1
< end
)
4223 *p1
= (7 & (c
>> 3)) + '0';
4225 if (p1
>= start
&& p1
< end
)
4226 *p1
= (7 & c
) + '0';
4234 if (truncate
) *p1
++ = fix_glyph (f
, truncate
, 0);
4236 else if (mincol
>= 0)
4238 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
4244 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
4246 if (len
> desired_glyphs
->used
[vpos
])
4247 desired_glyphs
->used
[vpos
] = len
;
4248 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
4254 /* This is like a combination of memq and assq.
4255 Return 1 if PROPVAL appears as an element of LIST
4256 or as the car of an element of LIST.
4257 If PROPVAL is a list, compare each element against LIST
4258 in that way, and return 1 if any element of PROPVAL is found in LIST.
4260 This function cannot quit. */
4263 invisible_p (propval
, list
)
4264 register Lisp_Object propval
;
4267 register Lisp_Object tail
, proptail
;
4268 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4270 register Lisp_Object tem
;
4271 tem
= XCONS (tail
)->car
;
4272 if (EQ (propval
, tem
))
4274 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
4277 if (CONSP (propval
))
4278 for (proptail
= propval
; CONSP (proptail
);
4279 proptail
= XCONS (proptail
)->cdr
)
4281 Lisp_Object propelt
;
4282 propelt
= XCONS (proptail
)->car
;
4283 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4285 register Lisp_Object tem
;
4286 tem
= XCONS (tail
)->car
;
4287 if (EQ (propelt
, tem
))
4289 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
4296 /* Return 1 if PROPVAL appears as the car of an element of LIST
4297 and the cdr of that element is non-nil.
4298 If PROPVAL is a list, check each element of PROPVAL in that way,
4299 and the first time some element is found,
4300 return 1 if the cdr of that element is non-nil.
4302 This function cannot quit. */
4305 invisible_ellipsis_p (propval
, list
)
4306 register Lisp_Object propval
;
4309 register Lisp_Object tail
, proptail
;
4310 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4312 register Lisp_Object tem
;
4313 tem
= XCONS (tail
)->car
;
4314 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
4315 return ! NILP (XCONS (tem
)->cdr
);
4317 if (CONSP (propval
))
4318 for (proptail
= propval
; CONSP (proptail
);
4319 proptail
= XCONS (proptail
)->cdr
)
4321 Lisp_Object propelt
;
4322 propelt
= XCONS (proptail
)->car
;
4323 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4325 register Lisp_Object tem
;
4326 tem
= XCONS (tail
)->car
;
4327 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
4328 return ! NILP (XCONS (tem
)->cdr
);
4337 staticpro (&Qmenu_bar_update_hook
);
4338 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
4340 staticpro (&Qoverriding_terminal_local_map
);
4341 Qoverriding_terminal_local_map
= intern ("overriding-terminal-local-map");
4343 staticpro (&Qoverriding_local_map
);
4344 Qoverriding_local_map
= intern ("overriding-local-map");
4346 staticpro (&Qwindow_scroll_functions
);
4347 Qwindow_scroll_functions
= intern ("window-scroll-functions");
4349 staticpro (&Qredisplay_end_trigger_functions
);
4350 Qredisplay_end_trigger_functions
= intern ("redisplay-end-trigger-functions");
4352 staticpro (&last_arrow_position
);
4353 staticpro (&last_arrow_string
);
4354 last_arrow_position
= Qnil
;
4355 last_arrow_string
= Qnil
;
4357 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
4358 "String (or mode line construct) included (normally) in `mode-line-format'.");
4359 Vglobal_mode_string
= Qnil
;
4361 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
4362 "Marker for where to display an arrow on top of the buffer text.\n\
4363 This must be the beginning of a line in order to work.\n\
4364 See also `overlay-arrow-string'.");
4365 Voverlay_arrow_position
= Qnil
;
4367 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
4368 "String to display as an arrow. See also `overlay-arrow-position'.");
4369 Voverlay_arrow_string
= Qnil
;
4371 DEFVAR_INT ("scroll-step", &scroll_step
,
4372 "*The number of lines to try scrolling a window by when point moves out.\n\
4373 If that fails to bring point back on frame, point is centered instead.\n\
4374 If this is zero, point is always centered after it moves off frame.");
4376 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
4378 DEFVAR_BOOL ("truncate-partial-width-windows",
4379 &truncate_partial_width_windows
,
4380 "*Non-nil means truncate lines in all windows less than full frame wide.");
4381 truncate_partial_width_windows
= 1;
4383 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
4384 "*Non-nil means use inverse video for the mode line.");
4385 mode_line_inverse_video
= 1;
4387 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
4388 "*Maximum buffer size for which line number should be displayed.");
4389 line_number_display_limit
= 1000000;
4391 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
4392 "*Non-nil means highlight region even in nonselected windows.");
4393 highlight_nonselected_windows
= 1;
4395 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
4396 "Non-nil if more than one frame is visible on this display.\n\
4397 Minibuffer-only frames don't count, but iconified frames do.\n\
4398 This variable is not guaranteed to be accurate except while processing\n\
4399 `frame-title-format' and `icon-title-format'.");
4401 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
4402 "Template for displaying the titlebar of visible frames.\n\
4403 \(Assuming the window manager supports this feature.)\n\
4404 This variable has the same structure as `mode-line-format' (which see),\n\
4405 and is used only on frames for which no explicit name has been set\n\
4406 \(see `modify-frame-parameters').");
4407 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
4408 "Template for displaying the titlebar of an iconified frame.\n\
4409 \(Assuming the window manager supports this feature.)\n\
4410 This variable has the same structure as `mode-line-format' (which see),\n\
4411 and is used only on frames for which no explicit name has been set\n\
4412 \(see `modify-frame-parameters').");
4414 = Vframe_title_format
4415 = Fcons (intern ("multiple-frames"),
4416 Fcons (build_string ("%b"),
4417 Fcons (Fcons (build_string (""),
4418 Fcons (intern ("invocation-name"),
4419 Fcons (build_string ("@"),
4420 Fcons (intern ("system-name"),
4424 DEFVAR_LISP ("message-log-max", &Vmessage_log_max
,
4425 "Maximum number of lines to keep in the message log buffer.\n\
4426 If nil, disable message logging. If t, log messages but don't truncate\n\
4427 the buffer when it becomes large.");
4428 XSETFASTINT (Vmessage_log_max
, 50);
4430 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions
,
4431 "Functions called before redisplay, if window sizes have changed.\n\
4432 The value should be a list of functions that take one argument.\n\
4433 Just before redisplay, for each frame, if any of its windows have changed\n\
4434 size since the last redisplay, or have been split or deleted,\n\
4435 all the functions in the list are called, with the frame as argument.");
4436 Vwindow_size_change_functions
= Qnil
;
4438 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions
,
4439 "List of Functions to call before redisplaying a window with scrolling.\n\
4440 Each function is called with two arguments, the window\n\
4441 and its new display-start position. Note that the value of `window-end'\n\
4442 is not valid when these functions are called.");
4443 Vwindow_scroll_functions
= Qnil
;
4446 /* initialize the window system */
4449 Lisp_Object root_window
;
4450 #ifndef COMPILER_REGISTER_BUG
4452 #endif /* COMPILER_REGISTER_BUG */
4453 struct window
*mini_w
;
4455 this_line_bufpos
= 0;
4457 mini_w
= XWINDOW (minibuf_window
);
4458 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
4460 echo_area_glyphs
= 0;
4461 previous_echo_glyphs
= 0;
4463 if (!noninteractive
)
4465 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
4466 XSETFASTINT (XWINDOW (root_window
)->top
, 0);
4467 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
4468 XSETFASTINT (mini_w
->top
, FRAME_HEIGHT (f
) - 1);
4469 set_window_height (minibuf_window
, 1, 0);
4471 XSETFASTINT (XWINDOW (root_window
)->width
, FRAME_WIDTH (f
));
4472 XSETFASTINT (mini_w
->width
, FRAME_WIDTH (f
));