1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 /*#include <ctype.h>*/
30 #include "dispextern.h"
37 #include "termhooks.h"
38 #include "intervals.h"
43 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
44 extern void set_frame_menubar ();
45 extern int pending_menu_activation
;
48 extern int interrupt_input
;
49 extern int command_loop_level
;
51 extern int minibuffer_auto_raise
;
53 extern Lisp_Object Qface
;
55 extern Lisp_Object Voverriding_local_map
;
56 extern Lisp_Object Voverriding_local_map_menu_flag
;
58 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
59 Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
60 Lisp_Object Qredisplay_end_trigger_functions
;
62 /* Nonzero means print newline to stdout before next minibuffer message. */
64 int noninteractive_need_newline
;
66 /* Nonzero means print newline to message log before next message. */
68 static int message_log_need_newline
;
70 #define min(a, b) ((a) < (b) ? (a) : (b))
71 #define max(a, b) ((a) > (b) ? (a) : (b))
72 #define minmax(floor, val, ceil) \
73 ((val) < (floor) ? (floor) : (val) > (ceil) ? (ceil) : (val))
75 /* The buffer position of the first character appearing
76 entirely or partially on the current frame line.
77 Or zero, which disables the optimization for the current frame line. */
78 static int this_line_bufpos
;
80 /* Number of characters past the end of this line,
81 including the terminating newline */
82 static int this_line_endpos
;
84 /* The vertical position of this frame line. */
85 static int this_line_vpos
;
87 /* Hpos value for start of display on this frame line.
88 Usually zero, but negative if first character really began
90 static int this_line_start_hpos
;
92 /* Buffer that this_line variables are describing. */
93 static struct buffer
*this_line_buffer
;
95 /* Value of echo_area_glyphs when it was last acted on.
96 If this is nonzero, there is a message on the frame
97 in the minibuffer and it should be erased as soon
98 as it is no longer requested to appear. */
99 char *previous_echo_glyphs
;
101 /* Nonzero means truncate lines in all windows less wide than the frame */
102 int truncate_partial_width_windows
;
104 /* Nonzero means we have more than one non-minibuffer-only frame.
105 Not guaranteed to be accurate except while parsing frame-title-format. */
108 Lisp_Object Vglobal_mode_string
;
110 /* Marker for where to display an arrow on top of the buffer text. */
111 Lisp_Object Voverlay_arrow_position
;
113 /* String to display for the arrow. */
114 Lisp_Object Voverlay_arrow_string
;
116 /* Like mode-line-format, but for the titlebar on a visible frame. */
117 Lisp_Object Vframe_title_format
;
119 /* Like mode-line-format, but for the titlebar on an iconified frame. */
120 Lisp_Object Vicon_title_format
;
122 /* List of functions to call when a window's size changes. These
123 functions get one arg, a frame on which one or more windows' sizes
125 static Lisp_Object Vwindow_size_change_functions
;
127 /* Values of those variables at last redisplay. */
128 static Lisp_Object last_arrow_position
, last_arrow_string
;
130 Lisp_Object Qmenu_bar_update_hook
;
132 /* Nonzero if overlay arrow has been displayed once in this window. */
133 static int overlay_arrow_seen
;
135 /* Nonzero if visible end of buffer has already been displayed once
136 in this window. (We need this variable in case there are overlay
137 strings that get displayed there.) */
138 static int zv_strings_seen
;
140 /* Nonzero means highlight the region even in nonselected windows. */
141 static int highlight_nonselected_windows
;
143 /* If cursor motion alone moves point off frame,
144 Try scrolling this many lines up or down if that will bring it back. */
145 static int scroll_step
;
147 /* Non-0 means scroll just far enough to bring point back on the screen,
149 static int scroll_conservatively
;
151 /* Recenter the window whenever point gets within this many lines
152 of the top or bottom of the window. */
155 /* Nonzero if try_window_id has made blank lines at window bottom
156 since the last redisplay that paused */
157 static int blank_end_of_window
;
159 /* Number of windows showing the buffer of the selected window
160 (or another buffer with the same base buffer).
161 keyboard.c refers to this. */
164 /* display_text_line sets these to the frame position (origin 0) of point,
165 whether the window is selected or not.
166 Set one to -1 first to determine whether point was found afterwards. */
168 static int cursor_vpos
;
169 static int cursor_hpos
;
171 static int debug_end_pos
;
173 /* Nonzero means display mode line highlighted */
174 int mode_line_inverse_video
;
176 static void redisplay_internal ();
177 static int message_log_check_duplicate ();
178 static void echo_area_display ();
179 void mark_window_display_accurate ();
180 static void redisplay_windows ();
181 static void redisplay_window ();
182 static void update_menu_bar ();
183 static void try_window ();
184 static int try_window_id ();
185 static struct position
*display_text_line ();
186 static void display_mode_line ();
187 static int display_mode_element ();
188 static char *decode_mode_spec ();
189 static int display_string ();
190 static void display_menu_bar ();
191 static int display_count_lines ();
193 /* Prompt to display in front of the minibuffer contents */
194 Lisp_Object minibuf_prompt
;
196 /* Width in columns of current minibuffer prompt. */
197 int minibuf_prompt_width
;
199 /* Message to display instead of minibuffer contents
200 This is what the functions error and message make,
201 and command echoing uses it as well.
202 It overrides the minibuf_prompt as well as the buffer. */
203 char *echo_area_glyphs
;
205 /* This is the length of the message in echo_area_glyphs. */
206 int echo_area_glyphs_length
;
208 /* This is the window where the echo area message was displayed.
209 It is always a minibuffer window, but it may not be the
210 same window currently active as a minibuffer. */
211 Lisp_Object echo_area_window
;
213 /* true iff we should redraw the mode lines on the next redisplay */
214 int update_mode_lines
;
216 /* Smallest number of characters before the gap
217 at any time since last redisplay that finished.
218 Valid for current buffer when try_window_id can be called. */
221 /* Smallest number of characters after the gap
222 at any time since last redisplay that finished.
223 Valid for current buffer when try_window_id can be called. */
226 /* MODIFF as of last redisplay that finished;
227 if it matches MODIFF, and overlay_unchanged_modified
228 matches OVERLAY_MODIFF, that means beg_unchanged and end_unchanged
229 contain no useful information */
230 int unchanged_modified
;
232 /* OVERLAY_MODIFF as of last redisplay that finished. */
233 int overlay_unchanged_modified
;
235 /* Nonzero if window sizes or contents have changed
236 since last redisplay that finished */
237 int windows_or_buffers_changed
;
239 /* Nonzero after display_mode_line if %l was used
240 and it displayed a line number. */
241 int line_number_displayed
;
243 /* Maximum buffer size for which to display line numbers. */
244 static int line_number_display_limit
;
246 /* Number of lines to keep in the message log buffer.
247 t means infinite. nil means don't log at all. */
248 Lisp_Object Vmessage_log_max
;
250 /* Output a newline in the *Messages* buffer if "needs" one. */
253 message_log_maybe_newline ()
255 if (message_log_need_newline
)
256 message_dolog ("", 0, 1);
260 /* Add a string to the message log, optionally terminated with a newline.
261 This function calls low-level routines in order to bypass text property
262 hooks, etc. which might not be safe to run. */
265 message_dolog (m
, len
, nlflag
)
269 if (!NILP (Vmessage_log_max
))
271 struct buffer
*oldbuf
;
272 int oldpoint
, oldbegv
, oldzv
;
273 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
275 oldbuf
= current_buffer
;
276 Fset_buffer (Fget_buffer_create (build_string ("*Messages*")));
277 current_buffer
->undo_list
= Qt
;
284 oldpoint
+= len
+ nlflag
;
286 oldzv
+= len
+ nlflag
;
289 insert_1 (m
, len
, 1, 0);
292 int this_bol
, prev_bol
, dup
;
293 insert_1 ("\n", 1, 1, 0);
295 this_bol
= scan_buffer ('\n', Z
, 0, -2, 0, 0);
298 prev_bol
= scan_buffer ('\n', this_bol
, 0, -2, 0, 0);
299 dup
= message_log_check_duplicate (prev_bol
, this_bol
);
302 if (oldpoint
> prev_bol
)
303 oldpoint
-= min (this_bol
, oldpoint
) - prev_bol
;
304 if (oldbegv
> prev_bol
)
305 oldbegv
-= min (this_bol
, oldbegv
) - prev_bol
;
306 if (oldzv
> prev_bol
)
307 oldzv
-= min (this_bol
, oldzv
) - prev_bol
;
308 del_range_1 (prev_bol
, this_bol
, 0);
314 /* If you change this format, don't forget to also
315 change message_log_check_duplicate. */
316 sprintf (dupstr
, " [%d times]", dup
);
317 duplen
= strlen (dupstr
);
323 insert_1 (dupstr
, duplen
, 1, 0);
328 if (NATNUMP (Vmessage_log_max
))
330 int pos
= scan_buffer ('\n', Z
, 0,
331 -XFASTINT (Vmessage_log_max
) - 1, 0, 0);
332 oldpoint
-= min (pos
, oldpoint
) - BEG
;
333 oldbegv
-= min (pos
, oldbegv
) - BEG
;
334 oldzv
-= min (pos
, oldzv
) - BEG
;
335 del_range_1 (BEG
, pos
, 0);
340 TEMP_SET_PT (oldpoint
);
341 set_buffer_internal (oldbuf
);
342 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
343 message_log_need_newline
= !nlflag
;
347 /* We are at the end of the buffer after just having inserted a newline.
348 (Note: We depend on the fact we won't be crossing the gap.)
349 Check to see if the most recent message looks a lot like the previous one.
350 Return 0 if different, 1 if the new one should just replace it, or a
351 value N > 1 if we should also append " [N times]". */
354 message_log_check_duplicate (prev_bol
, this_bol
)
355 int prev_bol
, this_bol
;
358 int len
= Z
- 1 - this_bol
;
360 unsigned char *p1
= BUF_CHAR_ADDRESS (current_buffer
, prev_bol
);
361 unsigned char *p2
= BUF_CHAR_ADDRESS (current_buffer
, this_bol
);
363 for (i
= 0; i
< len
; i
++)
365 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.'
374 if (*p1
++ == ' ' && *p1
++ == '[')
377 while (*p1
>= '0' && *p1
<= '9')
378 n
= n
* 10 + *p1
++ - '0';
379 if (strncmp (p1
, " times]\n", 8) == 0)
385 /* Display an echo area message M with a specified length of LEN chars.
386 The string may include null characters. If M is 0, clear out any
387 existing message, and let the minibuffer text show through.
389 The buffer M must continue to exist until after the echo area
390 gets cleared or some other message gets displayed there.
392 Do not pass text that is stored in a Lisp string.
393 Do not pass text in a buffer that was alloca'd. */
400 /* First flush out any partial line written with print. */
401 message_log_maybe_newline ();
403 message_dolog (m
, len
, 1);
404 message2_nolog (m
, len
);
408 /* The non-logging counterpart of message2. */
411 message2_nolog (m
, len
)
417 if (noninteractive_need_newline
)
419 noninteractive_need_newline
= 0;
420 fwrite (m
, len
, 1, stderr
);
421 if (cursor_in_echo_area
== 0)
422 fprintf (stderr
, "\n");
425 /* A null message buffer means that the frame hasn't really been
426 initialized yet. Error messages get reported properly by
427 cmd_error, so this must be just an informative message; toss it. */
428 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
430 Lisp_Object mini_window
;
433 /* Get the frame containing the minibuffer
434 that the selected frame is using. */
435 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
436 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
438 FRAME_SAMPLE_VISIBILITY (f
);
439 if (FRAME_VISIBLE_P (selected_frame
)
440 && ! FRAME_VISIBLE_P (f
))
441 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
445 echo_area_glyphs
= m
;
446 echo_area_glyphs_length
= len
;
448 if (minibuffer_auto_raise
)
449 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
452 echo_area_glyphs
= previous_echo_glyphs
= 0;
454 do_pending_window_change ();
455 echo_area_display ();
456 update_frame (f
, 1, 1);
457 do_pending_window_change ();
458 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
459 (*frame_up_to_date_hook
) (f
);
463 /* Display a null-terminated echo area message M. If M is 0, clear out any
464 existing message, and let the minibuffer text show through.
466 The buffer M must continue to exist until after the echo area
467 gets cleared or some other message gets displayed there.
469 Do not pass text that is stored in a Lisp string.
470 Do not pass text in a buffer that was alloca'd. */
476 message2 (m
, (m
? strlen (m
) : 0));
483 message2_nolog (m
, (m
? strlen (m
) : 0));
486 /* Truncate what will be displayed in the echo area
487 the next time we display it--but don't redisplay it now. */
490 truncate_echo_area (len
)
493 /* A null message buffer means that the frame hasn't really been
494 initialized yet. Error messages get reported properly by
495 cmd_error, so this must be just an informative message; toss it. */
496 if (!noninteractive
&& INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
497 echo_area_glyphs_length
= len
;
500 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
501 zero if being used by message. */
502 int message_buf_print
;
504 /* Dump an informative message to the minibuf. If M is 0, clear out
505 any existing message, and let the minibuffer text show through. */
509 message (m
, a1
, a2
, a3
)
511 EMACS_INT a1
, a2
, a3
;
517 if (noninteractive_need_newline
)
519 noninteractive_need_newline
= 0;
520 fprintf (stderr
, m
, a1
, a2
, a3
);
521 if (cursor_in_echo_area
== 0)
522 fprintf (stderr
, "\n");
526 else if (INTERACTIVE
)
528 /* The frame whose minibuffer we're going to display the message on.
529 It may be larger than the selected frame, so we need
530 to use its buffer, not the selected frame's buffer. */
531 Lisp_Object mini_window
;
534 /* Get the frame containing the minibuffer
535 that the selected frame is using. */
536 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
537 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
539 /* A null message buffer means that the frame hasn't really been
540 initialized yet. Error messages get reported properly by
541 cmd_error, so this must be just an informative message; toss it. */
542 if (FRAME_MESSAGE_BUF (f
))
553 len
= doprnt (FRAME_MESSAGE_BUF (f
),
554 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
556 len
= doprnt (FRAME_MESSAGE_BUF (f
),
557 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, &a1
);
558 #endif /* NO_ARG_ARRAY */
560 message2 (FRAME_MESSAGE_BUF (f
), len
);
565 /* Print should start at the beginning of the message
567 message_buf_print
= 0;
572 /* The non-logging version of message. */
574 message_nolog (m
, a1
, a2
, a3
)
576 EMACS_INT a1
, a2
, a3
;
578 Lisp_Object old_log_max
;
579 old_log_max
= Vmessage_log_max
;
580 Vmessage_log_max
= Qnil
;
581 message (m
, a1
, a2
, a3
);
582 Vmessage_log_max
= old_log_max
;
588 message2 (echo_area_glyphs
, echo_area_glyphs_length
);
596 Lisp_Object mini_window
;
598 /* Choose the minibuffer window for this display.
599 It is the minibuffer window used by the selected frame. */
600 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
601 /* This is the frame that window is in. */
602 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
604 if (! FRAME_VISIBLE_P (f
))
609 redraw_garbaged_frames ();
613 if (echo_area_glyphs
|| minibuf_level
== 0)
617 echo_area_window
= mini_window
;
619 vpos
= XFASTINT (XWINDOW (mini_window
)->top
);
620 get_display_line (f
, vpos
, 0);
622 /* Make sure the columns that overlap a left-hand scroll bar
624 for (i
= 0; i
< FRAME_LEFT_SCROLL_BAR_WIDTH (f
); i
++)
625 f
->desired_glyphs
->glyphs
[vpos
][i
] = SPACEGLYPH
;
627 display_string (XWINDOW (mini_window
), vpos
,
628 echo_area_glyphs
? echo_area_glyphs
: "",
629 echo_area_glyphs
? echo_area_glyphs_length
: -1,
630 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
631 0, 0, 0, FRAME_WIDTH (f
));
633 #if 0 /* This just gets in the way. update_frame does the job. */
634 /* If desired cursor location is on this line, put it at end of text */
635 if (cursor_in_echo_area
)
636 FRAME_CURSOR_Y (f
) = vpos
;
637 if (FRAME_CURSOR_Y (f
) == vpos
)
638 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
641 /* Fill the rest of the minibuffer window with blank lines. */
646 i
< vpos
+ XFASTINT (XWINDOW (mini_window
)->height
); i
++)
648 get_display_line (f
, i
, 0);
649 display_string (XWINDOW (mini_window
), vpos
,
651 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
652 0, 0, 0, FRAME_WIDTH (f
));
656 else if (!EQ (mini_window
, selected_window
))
657 windows_or_buffers_changed
++;
659 if (EQ (mini_window
, selected_window
))
660 this_line_bufpos
= 0;
662 previous_echo_glyphs
= echo_area_glyphs
;
665 /* Update frame titles. */
667 #ifdef HAVE_WINDOW_SYSTEM
668 static char frame_title_buf
[512];
669 static char *frame_title_ptr
;
672 store_frame_title (str
, mincol
, maxcol
)
677 if (maxcol
< 0 || maxcol
>= sizeof(frame_title_buf
))
678 maxcol
= sizeof (frame_title_buf
);
679 limit
= &frame_title_buf
[maxcol
];
680 while (*str
!= '\0' && frame_title_ptr
< limit
)
681 *frame_title_ptr
++ = *str
++;
682 while (frame_title_ptr
< &frame_title_buf
[mincol
])
683 *frame_title_ptr
++ = ' ';
684 return frame_title_ptr
- frame_title_buf
;
688 x_consider_frame_title (frame
)
694 FRAME_PTR f
= XFRAME (frame
);
696 if (!(FRAME_WINDOW_P (f
) || FRAME_MINIBUF_ONLY_P (f
) || f
->explicit_name
))
699 /* Do we have more than one visible frame on this X display? */
703 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
705 FRAME_PTR tf
= XFRAME (XCONS (tail
)->car
);
707 if (tf
!= f
&& FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
708 && !FRAME_MINIBUF_ONLY_P (tf
)
709 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
713 multiple_frames
= CONSP (tail
);
716 obuf
= current_buffer
;
717 Fset_buffer (XWINDOW (f
->selected_window
)->buffer
);
718 fmt
= (FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
);
719 frame_title_ptr
= frame_title_buf
;
720 len
= display_mode_element (XWINDOW (f
->selected_window
), 0, 0, 0,
721 0, sizeof (frame_title_buf
), fmt
);
723 set_buffer_internal (obuf
);
724 /* Set the name only if it's changed. This avoids consing
725 in the common case where it hasn't. (If it turns out that we've
726 already wasted too much time by walking through the list with
727 display_mode_element, then we might need to optimize at a higher
729 if (! STRINGP (f
->name
) || XSTRING (f
->name
)->size
!= len
730 || bcmp (frame_title_buf
, XSTRING (f
->name
)->data
, len
) != 0)
731 x_implicitly_set_name (f
, make_string (frame_title_buf
, len
), Qnil
);
734 #define frame_title_ptr ((char *)0)
735 #define store_frame_title(str, mincol, maxcol) 0
738 /* Prepare for redisplay by updating menu-bar item lists when appropriate.
739 This can call eval. */
744 register struct window
*w
= XWINDOW (selected_window
);
746 struct gcpro gcpro1
, gcpro2
;
748 all_windows
= (update_mode_lines
|| buffer_shared
> 1
749 || windows_or_buffers_changed
);
751 /* Update all frame titles based on their buffer names, etc.
752 We do this before the menu bars so that the buffer-menu
753 will show the up-to-date frame titles.
755 This used to be done after the menu bars, for a reason that
756 was stated as follows but which I do not understand:
757 "We do this after the menu bars so that the frame will first
758 create its menu bar using the name `emacs' if no other name
759 has yet been specified."
760 I think that is no longer a concern. */
761 #ifdef HAVE_WINDOW_SYSTEM
762 if (windows_or_buffers_changed
|| update_mode_lines
)
764 Lisp_Object tail
, frame
;
766 FOR_EACH_FRAME (tail
, frame
)
767 if (FRAME_VISIBLE_P (XFRAME (frame
))
768 || FRAME_ICONIFIED_P (XFRAME (frame
)))
769 x_consider_frame_title (frame
);
773 /* Update the menu bar item lists, if appropriate.
774 This has to be done before any actual redisplay
775 or generation of display lines. */
778 Lisp_Object tail
, frame
;
779 int count
= specpdl_ptr
- specpdl
;
781 record_unwind_protect (Fstore_match_data
, Fmatch_data (Qnil
, Qnil
));
783 FOR_EACH_FRAME (tail
, frame
)
785 /* If a window on this frame changed size,
786 report that to the user and clear the size-change flag. */
787 if (FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)))
789 Lisp_Object functions
;
790 /* Clear flag first in case we get error below. */
791 FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)) = 0;
792 functions
= Vwindow_size_change_functions
;
793 GCPRO2 (tail
, functions
);
794 while (CONSP (functions
))
796 call1 (XCONS (functions
)->car
, frame
);
797 functions
= XCONS (functions
)->cdr
;
802 update_menu_bar (XFRAME (frame
), 0);
806 unbind_to (count
, Qnil
);
809 update_menu_bar (selected_frame
, 1);
811 /* Motif needs this. See comment in xmenu.c.
812 Turn it off when pending_menu_activation is not defined. */
814 pending_menu_activation
= 0;
818 /* Do a frame update, taking possible shortcuts into account.
819 This is the main external entry point for redisplay.
821 If the last redisplay displayed an echo area message and that
822 message is no longer requested, we clear the echo area
823 or bring back the minibuffer if that is in use.
825 Do not call eval from within this function.
826 Calls to eval after the call to echo_area_display would confuse
827 the display_line mechanism and would cause a crash.
828 Calls to eval before that point will work most of the time,
829 but can still lose, because this function
830 can be called from signal handlers; with alarms set up;
831 or with synchronous processes running.
833 See Fcall_process; if you called it from here, it could be
834 entered recursively. */
836 static int do_verify_charstarts
;
838 /* Counter is used to clear the face cache
839 no more than once ever 1000 redisplays. */
840 static int clear_face_cache_count
;
842 /* Record the previous terminal frame we displayed. */
843 static FRAME_PTR previous_terminal_frame
;
848 redisplay_internal (0);
851 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay
852 is not in response to any user action; therefore, we should
853 preserve the echo area. (Actually, our caller does that job.)
854 Perhaps in the future avoid recentering windows
855 if it is not necessary; currently that causes some problems. */
858 redisplay_internal (preserve_echo_area
)
859 int preserve_echo_area
;
861 register struct window
*w
= XWINDOW (selected_window
);
865 register int tlbufpos
, tlendpos
;
872 if (popup_activated ())
876 if (! FRAME_WINDOW_P (selected_frame
)
877 && previous_terminal_frame
!= selected_frame
)
879 /* Since frames on an ASCII terminal share the same display area,
880 displaying a different frame means redisplay the whole thing. */
881 windows_or_buffers_changed
++;
882 SET_FRAME_GARBAGED (selected_frame
);
883 XSETFRAME (Vterminal_frame
, selected_frame
);
885 previous_terminal_frame
= selected_frame
;
887 /* Set the visible flags for all frames.
888 Do this before checking for resized or garbaged frames; they want
889 to know if their frames are visible.
890 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
892 Lisp_Object tail
, frame
;
894 FOR_EACH_FRAME (tail
, frame
)
896 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
898 /* Clear out all the display lines in which we will generate the
899 glyphs to display. */
900 init_desired_glyphs (XFRAME (frame
));
904 /* Notice any pending interrupt request to change frame size. */
905 do_pending_window_change ();
909 redraw_garbaged_frames ();
913 prepare_menu_bars ();
915 if (windows_or_buffers_changed
)
918 /* Detect case that we need to write or remove a star in the mode line. */
919 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
921 w
->update_mode_line
= Qt
;
922 if (buffer_shared
> 1)
926 /* If %c is in use, update it if needed. */
927 if (!NILP (w
->column_number_displayed
)
928 /* This alternative quickly identifies a common case
929 where no change is needed. */
930 && !(PT
== XFASTINT (w
->last_point
)
931 && XFASTINT (w
->last_modified
) >= MODIFF
932 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
933 && XFASTINT (w
->column_number_displayed
) != current_column ())
934 w
->update_mode_line
= Qt
;
936 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
938 all_windows
= update_mode_lines
|| buffer_shared
> 1;
940 /* If specs for an arrow have changed, do thorough redisplay
941 to ensure we remove any arrow that should no longer exist. */
942 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
943 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
946 /* Normally the message* functions will have already displayed and
947 updated the echo area, but the frame may have been trashed, or
948 the update may have been preempted, so display the echo area
950 if (echo_area_glyphs
|| previous_echo_glyphs
)
952 echo_area_display ();
956 /* If showing region, and mark has changed, must redisplay whole window. */
957 if (((!NILP (Vtransient_mark_mode
)
958 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
959 != !NILP (w
->region_showing
))
960 || (!NILP (w
->region_showing
)
961 && !EQ (w
->region_showing
,
962 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
963 this_line_bufpos
= -1;
965 tlbufpos
= this_line_bufpos
;
966 tlendpos
= this_line_endpos
;
967 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
968 && !current_buffer
->clip_changed
969 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
970 /* Make sure recorded data applies to current buffer, etc */
971 && this_line_buffer
== current_buffer
972 && current_buffer
== XBUFFER (w
->buffer
)
973 && NILP (w
->force_start
)
974 /* Point must be on the line that we have info recorded about */
976 && PT
<= Z
- tlendpos
977 /* All text outside that line, including its final newline,
979 && ((XFASTINT (w
->last_modified
) >= MODIFF
980 && (XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
))
981 || (beg_unchanged
>= tlbufpos
- 1
983 /* If selective display, can't optimize
984 if the changes start at the beginning of the line. */
985 && ((INTEGERP (current_buffer
->selective_display
)
986 && XINT (current_buffer
->selective_display
) > 0
987 ? (beg_unchanged
>= tlbufpos
990 && end_unchanged
>= tlendpos
991 && Z
- GPT
>= tlendpos
)))
993 if (tlbufpos
> BEGV
&& FETCH_BYTE (tlbufpos
- 1) != '\n'
995 || FETCH_BYTE (tlbufpos
) == '\n'))
996 /* Former continuation line has disappeared by becoming empty */
998 else if (XFASTINT (w
->last_modified
) < MODIFF
999 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
1000 || MINI_WINDOW_P (w
))
1002 /* We have to handle the case of continuation around a
1003 wide-column character (See the comment in indent.c around
1006 For instance, in the following case:
1008 -------- Insert --------
1009 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
1010 J_I_ ==> J_I_ `^^' are cursors.
1014 As we have to redraw the line above, we should goto cancel. */
1016 struct position val
;
1019 prevline
= find_next_newline (tlbufpos
, -1);
1020 val
= *compute_motion (prevline
, 0,
1021 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1024 1 << (BITS_PER_SHORT
- 1),
1025 1 << (BITS_PER_SHORT
- 1),
1026 window_internal_width (w
) - 1,
1027 XINT (w
->hscroll
), 0, w
);
1028 if (val
.hpos
!= this_line_start_hpos
)
1032 overlay_arrow_seen
= 0;
1033 zv_strings_seen
= 0;
1034 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
1035 pos_tab_offset (w
, tlbufpos
), 0);
1036 /* If line contains point, is not continued,
1037 and ends at same distance from eob as before, we win */
1038 if (cursor_vpos
>= 0 && this_line_bufpos
1039 && this_line_endpos
== tlendpos
)
1041 /* If this is not the window's last line,
1042 we must adjust the charstarts of the lines below. */
1043 if (this_line_vpos
+ 1
1044 < XFASTINT (w
->top
) + window_internal_height (w
))
1046 int left
= WINDOW_LEFT_MARGIN (w
);
1047 int *charstart_next_line
1048 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[this_line_vpos
+ 1];
1051 if (Z
- tlendpos
== ZV
)
1052 /* This line ends at end of (accessible part of) buffer.
1053 There is no newline to count. */
1054 adjust
= Z
- tlendpos
- charstart_next_line
[left
];
1056 /* This line ends in a newline.
1057 Must take account of the newline and the rest of the
1058 text that follows. */
1059 adjust
= Z
- tlendpos
+ 1 - charstart_next_line
[left
];
1061 adjust_window_charstarts (w
, this_line_vpos
, adjust
);
1064 if (!WINDOW_FULL_WIDTH_P (w
))
1065 preserve_other_columns (w
);
1071 else if (PT
== XFASTINT (w
->last_point
)
1072 /* Make sure the cursor was last displayed
1073 in this window. Otherwise we have to reposition it. */
1074 && XINT (w
->top
) <= FRAME_CURSOR_Y (selected_frame
)
1075 && (XINT (w
->top
) + XINT (w
->height
)
1076 > FRAME_CURSOR_Y (selected_frame
)))
1080 do_pending_window_change ();
1085 /* If highlighting the region, or if the cursor is in the echo area,
1086 then we can't just move the cursor. */
1087 else if (! (!NILP (Vtransient_mark_mode
)
1088 && !NILP (current_buffer
->mark_active
))
1089 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1090 || highlight_nonselected_windows
)
1091 && NILP (w
->region_showing
)
1092 && !cursor_in_echo_area
)
1094 pos
= *compute_motion (tlbufpos
, 0,
1095 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1097 PT
, 2, - (1 << (BITS_PER_SHORT
- 1)),
1098 window_internal_width (w
) - 1,
1100 pos_tab_offset (w
, tlbufpos
), w
);
1103 int width
= window_internal_width (w
) - 1;
1104 FRAME_CURSOR_X (selected_frame
)
1105 = WINDOW_LEFT_MARGIN (w
) + minmax (0, pos
.hpos
, width
);
1106 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
1113 /* Text changed drastically or point moved off of line */
1114 cancel_line (this_line_vpos
, selected_frame
);
1117 this_line_bufpos
= 0;
1118 all_windows
|= buffer_shared
> 1;
1120 clear_face_cache_count
++;
1124 Lisp_Object tail
, frame
;
1127 /* Clear the face cache, only when we do a full redisplay
1128 and not too often either. */
1129 if (clear_face_cache_count
> 1000)
1131 clear_face_cache ();
1132 clear_face_cache_count
= 0;
1136 /* Recompute # windows showing selected buffer.
1137 This will be incremented each time such a window is displayed. */
1140 FOR_EACH_FRAME (tail
, frame
)
1142 FRAME_PTR f
= XFRAME (frame
);
1143 if (FRAME_WINDOW_P (f
) || f
== selected_frame
)
1146 /* Mark all the scroll bars to be removed; we'll redeem the ones
1147 we want when we redisplay their windows. */
1148 if (condemn_scroll_bars_hook
)
1149 (*condemn_scroll_bars_hook
) (f
);
1151 if (FRAME_VISIBLE_P (f
))
1152 redisplay_windows (FRAME_ROOT_WINDOW (f
), preserve_echo_area
);
1154 /* Any scroll bars which redisplay_windows should have nuked
1155 should now go away. */
1156 if (judge_scroll_bars_hook
)
1157 (*judge_scroll_bars_hook
) (f
);
1161 else if (FRAME_VISIBLE_P (selected_frame
))
1163 redisplay_window (selected_window
, 1, preserve_echo_area
);
1164 if (!WINDOW_FULL_WIDTH_P (w
))
1165 preserve_other_columns (w
);
1169 /* Prevent various kinds of signals during display update.
1170 stdio is not robust about handling signals,
1171 which can cause an apparent I/O error. */
1172 if (interrupt_input
)
1182 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1186 if (!FRAMEP (XCONS (tail
)->car
))
1189 f
= XFRAME (XCONS (tail
)->car
);
1191 if ((FRAME_WINDOW_P (f
) || f
== selected_frame
)
1192 && FRAME_VISIBLE_P (f
))
1194 pause
|= update_frame (f
, 0, 0);
1197 mark_window_display_accurate (f
->root_window
, 1);
1198 if (frame_up_to_date_hook
!= 0)
1199 (*frame_up_to_date_hook
) (f
);
1206 if (FRAME_VISIBLE_P (selected_frame
))
1207 pause
= update_frame (selected_frame
, 0, 0);
1211 /* We may have called echo_area_display at the top of this
1212 function. If the echo area is on another frame, that may
1213 have put text on a frame other than the selected one, so the
1214 above call to update_frame would not have caught it. Catch
1217 Lisp_Object mini_window
;
1218 FRAME_PTR mini_frame
;
1220 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
1221 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
1223 if (mini_frame
!= selected_frame
&& FRAME_WINDOW_P (mini_frame
))
1224 pause
|= update_frame (mini_frame
, 0, 0);
1228 /* If frame does not match, prevent doing single-line-update next time.
1229 Also, don't forget to check every line to update the arrow. */
1232 this_line_bufpos
= 0;
1233 if (!NILP (last_arrow_position
))
1235 last_arrow_position
= Qt
;
1236 last_arrow_string
= Qt
;
1238 /* If we pause after scrolling, some lines in current_frame
1239 may be null, so preserve_other_columns won't be able to
1240 preserve all the vertical-bar separators. So, avoid using it
1242 if (!WINDOW_FULL_WIDTH_P (w
))
1243 update_mode_lines
= 1;
1246 /* Now text on frame agrees with windows, so
1247 put info into the windows for partial redisplay to follow */
1251 register struct buffer
*b
= XBUFFER (w
->buffer
);
1253 blank_end_of_window
= 0;
1254 unchanged_modified
= BUF_MODIFF (b
);
1255 overlay_unchanged_modified
= BUF_OVERLAY_MODIFF (b
);
1256 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
1257 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
1259 XSETFASTINT (w
->last_point
, BUF_PT (b
));
1260 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (selected_frame
));
1261 XSETFASTINT (w
->last_point_y
, FRAME_CURSOR_Y (selected_frame
));
1264 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
1267 b
->clip_changed
= 0;
1268 w
->update_mode_line
= Qnil
;
1269 XSETFASTINT (w
->last_modified
, BUF_MODIFF (b
));
1270 XSETFASTINT (w
->last_overlay_modified
, BUF_OVERLAY_MODIFF (b
));
1272 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1275 /* Record if we are showing a region, so can make sure to
1276 update it fully at next redisplay. */
1277 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
1278 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1279 || highlight_nonselected_windows
)
1280 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
1281 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
1284 w
->window_end_valid
= w
->buffer
;
1285 last_arrow_position
= Voverlay_arrow_position
;
1286 last_arrow_string
= Voverlay_arrow_string
;
1287 if (do_verify_charstarts
)
1288 verify_charstarts (w
);
1289 if (frame_up_to_date_hook
!= 0)
1290 (*frame_up_to_date_hook
) (selected_frame
);
1292 update_mode_lines
= 0;
1293 windows_or_buffers_changed
= 0;
1296 /* Start SIGIO interrupts coming again.
1297 Having them off during the code above
1298 makes it less likely one will discard output,
1299 but not impossible, since there might be stuff
1300 in the system buffer here.
1301 But it is much hairier to try to do anything about that. */
1303 if (interrupt_input
)
1307 /* Change frame size now if a change is pending. */
1308 do_pending_window_change ();
1310 /* If we just did a pending size change, redisplay again
1311 for the new size. */
1312 if (windows_or_buffers_changed
&& !pause
)
1316 /* Redisplay, but leave alone any recent echo area message
1317 unless another message has been requested in its place.
1319 This is useful in situations where you need to redisplay but no
1320 user action has occurred, making it inappropriate for the message
1321 area to be cleared. See tracking_off and
1322 wait_reading_process_input for examples of these situations. */
1324 redisplay_preserve_echo_area ()
1326 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
1328 echo_area_glyphs
= previous_echo_glyphs
;
1329 redisplay_internal (1);
1330 echo_area_glyphs
= 0;
1333 redisplay_internal (1);
1337 mark_window_display_accurate (window
, flag
)
1341 register struct window
*w
;
1343 for (;!NILP (window
); window
= w
->next
)
1345 if (!WINDOWP (window
)) abort ();
1346 w
= XWINDOW (window
);
1348 if (!NILP (w
->buffer
))
1350 XSETFASTINT (w
->last_modified
,
1351 !flag
? 0 : BUF_MODIFF (XBUFFER (w
->buffer
)));
1352 XSETFASTINT (w
->last_overlay_modified
,
1353 !flag
? 0 : BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
)));
1355 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1358 /* Record if we are showing a region, so can make sure to
1359 update it fully at next redisplay. */
1360 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
1361 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1362 || highlight_nonselected_windows
)
1363 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
1364 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
1368 w
->window_end_valid
= w
->buffer
;
1369 w
->update_mode_line
= Qnil
;
1370 if (!NILP (w
->buffer
) && flag
)
1371 XBUFFER (w
->buffer
)->clip_changed
= 0;
1373 if (!NILP (w
->vchild
))
1374 mark_window_display_accurate (w
->vchild
, flag
);
1375 if (!NILP (w
->hchild
))
1376 mark_window_display_accurate (w
->hchild
, flag
);
1381 last_arrow_position
= Voverlay_arrow_position
;
1382 last_arrow_string
= Voverlay_arrow_string
;
1386 /* t is unequal to any useful value of Voverlay_arrow_... */
1387 last_arrow_position
= Qt
;
1388 last_arrow_string
= Qt
;
1392 /* Update the menu bar item list for frame F.
1393 This has to be done before we start to fill in any display lines,
1394 because it can call eval.
1396 If SAVE_MATCH_DATA is 1, we must save and restore it here. */
1399 update_menu_bar (f
, save_match_data
)
1401 int save_match_data
;
1403 struct buffer
*old
= current_buffer
;
1405 register struct window
*w
;
1407 window
= FRAME_SELECTED_WINDOW (f
);
1408 w
= XWINDOW (window
);
1410 if (update_mode_lines
)
1411 w
->update_mode_line
= Qt
;
1413 if (FRAME_WINDOW_P (f
)
1415 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1416 FRAME_EXTERNAL_MENU_BAR (f
)
1418 FRAME_MENU_BAR_LINES (f
) > 0
1420 : FRAME_MENU_BAR_LINES (f
) > 0)
1422 /* If the user has switched buffers or windows, we need to
1423 recompute to reflect the new bindings. But we'll
1424 recompute when update_mode_lines is set too; that means
1425 that people can use force-mode-line-update to request
1426 that the menu bar be recomputed. The adverse effect on
1427 the rest of the redisplay algorithm is about the same as
1428 windows_or_buffers_changed anyway. */
1429 if (windows_or_buffers_changed
1430 || !NILP (w
->update_mode_line
)
1431 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1432 < BUF_MODIFF (XBUFFER (w
->buffer
)))
1433 != !NILP (w
->last_had_star
))
1434 || ((!NILP (Vtransient_mark_mode
)
1435 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
1436 != !NILP (w
->region_showing
)))
1438 struct buffer
*prev
= current_buffer
;
1439 int count
= specpdl_ptr
- specpdl
;
1441 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1442 if (save_match_data
)
1443 record_unwind_protect (Fstore_match_data
, Fmatch_data (Qnil
, Qnil
));
1444 if (NILP (Voverriding_local_map_menu_flag
))
1446 specbind (Qoverriding_terminal_local_map
, Qnil
);
1447 specbind (Qoverriding_local_map
, Qnil
);
1450 /* Run the Lucid hook. */
1451 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1452 /* If it has changed current-menubar from previous value,
1453 really recompute the menubar from the value. */
1454 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1455 call0 (Qrecompute_lucid_menubar
);
1456 safe_run_hooks (Qmenu_bar_update_hook
);
1457 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1458 /* Redisplay the menu bar in case we changed it. */
1459 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1460 if (FRAME_WINDOW_P (f
))
1461 set_frame_menubar (f
, 0, 0);
1463 /* On a terminal screen, the menu bar is an ordinary screen
1464 line, and this makes it get updated. */
1465 w
->update_mode_line
= Qt
;
1466 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
1467 /* In the non-toolkit version, the menu bar is an ordinary screen
1468 line, and this makes it get updated. */
1469 w
->update_mode_line
= Qt
;
1470 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
1472 unbind_to (count
, Qnil
);
1473 set_buffer_internal_1 (prev
);
1480 /* Redisplay WINDOW and its subwindows and siblings. */
1483 redisplay_windows (window
, preserve_echo_area
)
1485 int preserve_echo_area
;
1487 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
1488 redisplay_window (window
, 0, preserve_echo_area
);
1491 /* Return value in display table DP (Lisp_Char_Table *) for character
1492 C. Since a display table doesn't have any parent, we don't have to
1493 follow parent. Do not call this function directly but use the
1494 macro DISP_CHAR_VECTOR. */
1496 disp_char_vector (dp
, c
)
1497 struct Lisp_Char_Table
*dp
;
1503 if (SINGLE_BYTE_CHAR_P (c
)) return (dp
->contents
[c
]);
1505 SPLIT_NON_ASCII_CHAR (c
, code
[0], code
[1], code
[2]);
1506 if (code
[0] != CHARSET_COMPOSITION
)
1508 if (code
[1] < 32) code
[1] = -1;
1509 else if (code
[2] < 32) code
[2] = -1;
1511 /* Here, the possible range of CODE[0] (== charset ID) is
1512 128..MAX_CHARSET. Since the top level char table contains data
1513 for multibyte characters after 256th element, we must increment
1514 CODE[0] by 128 to get a correct index. */
1516 code
[3] = -1; /* anchor */
1518 for (i
= 0; code
[i
] >= 0; i
++, dp
= XCHAR_TABLE (val
))
1520 val
= dp
->contents
[code
[i
]];
1521 if (!SUB_CHAR_TABLE_P (val
))
1522 return (NILP (val
) ? dp
->defalt
: val
);
1524 /* Here, VAL is a sub char table. We return the default value of it. */
1525 return (dp
->defalt
);
1528 /* Redisplay window WINDOW and its subwindows. */
1531 redisplay_window (window
, just_this_one
, preserve_echo_area
)
1533 int just_this_one
, preserve_echo_area
;
1535 register struct window
*w
= XWINDOW (window
);
1536 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1538 register int lpoint
= PT
;
1539 struct buffer
*old
= current_buffer
;
1540 register int width
= window_internal_width (w
) - 1;
1541 register int startp
;
1542 register int hscroll
= XINT (w
->hscroll
);
1543 struct position pos
;
1546 int update_mode_line
;
1547 struct Lisp_Char_Table
*dp
= window_display_table (w
);
1549 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1551 /* If this is a combination window, do its children; that's all. */
1553 if (!NILP (w
->vchild
))
1555 redisplay_windows (w
->vchild
, preserve_echo_area
);
1558 if (!NILP (w
->hchild
))
1560 redisplay_windows (w
->hchild
, preserve_echo_area
);
1563 if (NILP (w
->buffer
))
1566 height
= window_internal_height (w
);
1567 update_mode_line
= (!NILP (w
->update_mode_line
) || update_mode_lines
);
1568 if (XBUFFER (w
->buffer
)->clip_changed
)
1569 update_mode_line
= 1;
1571 if (MINI_WINDOW_P (w
))
1573 if (w
== XWINDOW (echo_area_window
) && echo_area_glyphs
)
1574 /* We've already displayed the echo area glyphs in this window. */
1575 goto finish_scroll_bars
;
1576 else if (w
!= XWINDOW (minibuf_window
))
1578 /* This is a minibuffer, but it's not the currently active one,
1580 int vpos
= XFASTINT (w
->top
);
1583 for (i
= 0; i
< height
; i
++)
1585 get_display_line (f
, vpos
+ i
, 0);
1586 display_string (w
, vpos
+ i
, "", 0,
1587 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
1591 goto finish_scroll_bars
;
1595 /* Otherwise set up data on this window; select its buffer and point value */
1597 if (update_mode_line
)
1598 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1600 set_buffer_temp (XBUFFER (w
->buffer
));
1604 /* If %c is in mode line, update it if needed. */
1605 if (!NILP (w
->column_number_displayed
)
1606 /* This alternative quickly identifies a common case
1607 where no change is needed. */
1608 && !(PT
== XFASTINT (w
->last_point
)
1609 && XFASTINT (w
->last_modified
) >= MODIFF
1610 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
1611 && XFASTINT (w
->column_number_displayed
) != current_column ())
1612 update_mode_line
= 1;
1614 /* Count number of windows showing the selected buffer.
1615 An indirect buffer counts as its base buffer. */
1619 struct buffer
*current_base
, *window_base
;
1620 current_base
= current_buffer
;
1621 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1622 if (current_base
->base_buffer
)
1623 current_base
= current_base
->base_buffer
;
1624 if (window_base
->base_buffer
)
1625 window_base
= window_base
->base_buffer
;
1626 if (current_base
== window_base
)
1630 /* POINT refers normally to the selected window.
1631 For any other window, set up appropriate value. */
1633 if (!EQ (window
, selected_window
))
1635 int new_pt
= marker_position (w
->pointm
);
1639 Fset_marker (w
->pointm
, make_number (new_pt
), Qnil
);
1641 else if (new_pt
> (ZV
- 1))
1644 Fset_marker (w
->pointm
, make_number (new_pt
), Qnil
);
1646 /* We don't use SET_PT so that the point-motion hooks don't run. */
1647 BUF_PT (current_buffer
) = new_pt
;
1650 /* If any of the character widths specified in the display table
1651 have changed, invalidate the width run cache. It's true that this
1652 may be a bit late to catch such changes, but the rest of
1653 redisplay goes (non-fatally) haywire when the display table is
1654 changed, so why should we worry about doing any better? */
1655 if (current_buffer
->width_run_cache
)
1657 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
1659 if (! disptab_matches_widthtab (disptab
,
1660 XVECTOR (current_buffer
->width_table
)))
1662 invalidate_region_cache (current_buffer
,
1663 current_buffer
->width_run_cache
,
1665 recompute_width_table (current_buffer
, disptab
);
1669 /* If window-start is screwed up, choose a new one. */
1670 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
1673 startp
= marker_position (w
->start
);
1675 /* If someone specified a new starting point but did not insist,
1676 check whether it can be used. */
1677 if (!NILP (w
->optional_new_start
))
1679 w
->optional_new_start
= Qnil
;
1680 /* Check whether this start pos is usable given where point is. */
1682 pos
= *compute_motion (startp
, 0,
1683 (((EQ (window
, minibuf_window
)
1685 ? minibuf_prompt_width
: 0)
1686 + (hscroll
? 1 - hscroll
: 0)),
1689 /* BUG FIX: See the comment of
1690 Fpos_visible_in_window_p (window.c). */
1691 - (1 << (BITS_PER_SHORT
- 1)),
1692 width
, hscroll
, pos_tab_offset (w
, startp
), w
);
1693 /* If PT does fit on the screen, we will use this start pos,
1694 so do so by setting force_start. */
1695 if (pos
.bufpos
== PT
)
1696 w
->force_start
= Qt
;
1699 /* Handle case where place to start displaying has been specified,
1700 unless the specified location is outside the accessible range. */
1701 if (!NILP (w
->force_start
))
1703 w
->force_start
= Qnil
;
1704 /* Forget any recorded base line for line number display. */
1705 w
->base_line_number
= Qnil
;
1706 /* Redisplay the mode line. Select the buffer properly for that.
1707 Also, run the hook window-scroll-functions
1708 because we have scrolled. */
1709 /* Note, we do this after clearing force_start because
1710 if there's an error, it is better to forget about force_start
1711 than to get into an infinite loop calling the hook functions
1712 and having them get more errors. */
1713 if (!update_mode_line
1714 || ! NILP (Vwindow_scroll_functions
))
1716 Lisp_Object temp
[3];
1718 set_buffer_temp (old
);
1719 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1720 update_mode_line
= 1;
1721 w
->update_mode_line
= Qt
;
1722 if (! NILP (Vwindow_scroll_functions
))
1724 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1725 make_number (startp
));
1726 startp
= marker_position (w
->start
);
1729 XSETFASTINT (w
->last_modified
, 0);
1730 XSETFASTINT (w
->last_overlay_modified
, 0);
1731 if (startp
< BEGV
) startp
= BEGV
;
1732 if (startp
> ZV
) startp
= ZV
;
1733 try_window (window
, startp
);
1734 if (cursor_vpos
< 0)
1736 /* If point does not appear, move point so it does appear */
1737 pos
= *compute_motion (startp
, 0,
1738 (((EQ (window
, minibuf_window
)
1740 ? minibuf_prompt_width
: 0)
1741 + (hscroll
? 1 - hscroll
: 0)),
1744 - (1 << (BITS_PER_SHORT
- 1)),
1745 width
, hscroll
, pos_tab_offset (w
, startp
), w
);
1746 BUF_PT (current_buffer
) = pos
.bufpos
;
1747 if (w
!= XWINDOW (selected_window
))
1748 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
1751 if (current_buffer
== old
)
1753 FRAME_CURSOR_X (f
) = (WINDOW_LEFT_MARGIN (w
)
1754 + minmax (0, pos
.hpos
, width
));
1755 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1757 /* If we are highlighting the region,
1758 then we just changed the region, so redisplay to show it. */
1759 if (!NILP (Vtransient_mark_mode
)
1760 && !NILP (current_buffer
->mark_active
))
1762 cancel_my_columns (XWINDOW (window
));
1763 try_window (window
, startp
);
1769 /* Handle case where text has not changed, only point,
1770 and it has not moved off the frame. */
1772 /* This code is not used for minibuffer for the sake of
1773 the case of redisplaying to replace an echo area message;
1774 since in that case the minibuffer contents per se are usually unchanged.
1775 This code is of no real use in the minibuffer since
1776 the handling of this_line_bufpos, etc.,
1777 in redisplay handles the same cases. */
1779 if (XFASTINT (w
->last_modified
) >= MODIFF
1780 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
1781 && PT
>= startp
&& !current_buffer
->clip_changed
1782 && (just_this_one
|| WINDOW_FULL_WIDTH_P (w
))
1783 /* If force-mode-line-update was called, really redisplay;
1784 that's how redisplay is forced after e.g. changing
1785 buffer-invisibility-spec. */
1786 && NILP (w
->update_mode_line
)
1787 /* Can't use this case if highlighting a region. */
1788 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1789 && NILP (w
->region_showing
)
1790 /* If end pos is out of date, scroll bar and percentage will be wrong */
1791 && INTEGERP (w
->window_end_vpos
)
1792 && XFASTINT (w
->window_end_vpos
) < XFASTINT (w
->height
)
1793 && !EQ (window
, minibuf_window
))
1795 int this_scroll_margin
= scroll_margin
;
1797 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0), 0,
1799 /* BUG FIX: See the comment of
1800 Fpos_visible_in_window_p (window.c). */
1801 - (1 << (BITS_PER_SHORT
- 1)),
1803 pos_tab_offset (w
, startp
), w
);
1805 /* Don't use a scroll margin that is negative or too large. */
1806 if (this_scroll_margin
< 0)
1807 this_scroll_margin
= 0;
1809 if (XINT (w
->height
) < 4 * scroll_margin
)
1810 this_scroll_margin
= XINT (w
->height
) / 4;
1812 /* If point fits on the screen, and not within the scroll margin,
1814 if (pos
.vpos
< height
- this_scroll_margin
1815 && (pos
.vpos
>= this_scroll_margin
|| startp
== BEGV
))
1817 /* Ok, point is still on frame */
1818 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
1820 /* These variables are supposed to be origin 1 */
1821 FRAME_CURSOR_X (f
) = (WINDOW_LEFT_MARGIN (w
)
1822 + minmax (0, pos
.hpos
, width
));
1823 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1825 /* This doesn't do the trick, because if a window to the right of
1826 this one must be redisplayed, this does nothing because there
1827 is nothing in DesiredFrame yet, and then the other window is
1828 redisplayed, making likes that are empty in this window's columns.
1829 if (WINDOW_FULL_WIDTH_P (w))
1830 preserve_my_columns (w);
1834 /* Don't bother trying redisplay with same start;
1835 we already know it will lose */
1837 /* If current starting point was originally the beginning of a line
1838 but no longer is, find a new starting point. */
1839 else if (!NILP (w
->start_at_line_beg
)
1841 || FETCH_BYTE (startp
- 1) == '\n'))
1845 else if (just_this_one
&& !MINI_WINDOW_P (w
)
1847 && XFASTINT (w
->last_modified
)
1848 /* or else vmotion on first line won't work. */
1849 && ! NILP (w
->start_at_line_beg
)
1850 && ! EQ (w
->window_end_valid
, Qnil
)
1851 && do_id
&& !current_buffer
->clip_changed
1852 && !blank_end_of_window
1853 && WINDOW_FULL_WIDTH_P (w
)
1854 /* Can't use this case if highlighting a region. */
1855 && !(!NILP (Vtransient_mark_mode
)
1856 && !NILP (current_buffer
->mark_active
))
1857 /* Don't use try_window_id if newline
1858 doesn't display as the end of a line. */
1859 && !(dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, '\n')))
1860 && NILP (w
->region_showing
)
1861 && EQ (last_arrow_position
, Voverlay_arrow_position
)
1862 && EQ (last_arrow_string
, Voverlay_arrow_string
)
1863 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
1866 /* tem > 0 means success. tem == -1 means choose new start.
1867 tem == -2 means try again with same start,
1868 and nothing but whitespace follows the changed stuff.
1869 tem == 0 means try again with same start. */
1873 else if (startp
>= BEGV
&& startp
<= ZV
1875 /* Avoid starting at end of buffer. */
1876 #if 0 /* This change causes trouble for M-! finger & RET.
1877 It will have to be considered later. */
1878 || ! EQ (window
, selected_window
)
1879 /* Don't do the recentering if redisplay
1880 is not for no user action. */
1881 || preserve_echo_area
1884 || (XFASTINT (w
->last_modified
) >= MODIFF
1885 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
1887 /* Try to redisplay starting at same place as before */
1888 /* If point has not moved off frame, accept the results */
1889 try_window (window
, startp
);
1890 if (cursor_vpos
>= 0)
1892 if (!just_this_one
|| current_buffer
->clip_changed
1893 || beg_unchanged
< startp
)
1894 /* Forget any recorded base line for line number display. */
1895 w
->base_line_number
= Qnil
;
1899 cancel_my_columns (w
);
1902 XSETFASTINT (w
->last_modified
, 0);
1903 XSETFASTINT (w
->last_overlay_modified
, 0);
1904 /* Redisplay the mode line. Select the buffer properly for that. */
1905 if (!update_mode_line
)
1907 set_buffer_temp (old
);
1908 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1909 update_mode_line
= 1;
1910 w
->update_mode_line
= Qt
;
1913 /* Try to scroll by specified few lines */
1915 if (scroll_conservatively
&& !current_buffer
->clip_changed
1916 && startp
>= BEGV
&& startp
<= ZV
)
1918 int this_scroll_margin
= scroll_margin
;
1920 /* Don't use a scroll margin that is negative or too large. */
1921 if (this_scroll_margin
< 0)
1922 this_scroll_margin
= 0;
1924 if (XINT (w
->height
) < 4 * scroll_margin
)
1925 this_scroll_margin
= XINT (w
->height
) / 4;
1927 if (PT
>= Z
- XFASTINT (w
->window_end_pos
))
1929 struct position pos
;
1930 pos
= *compute_motion (Z
- XFASTINT (w
->window_end_pos
), 0, 0, 0,
1931 PT
, XFASTINT (w
->height
), 0,
1932 XFASTINT (w
->width
), XFASTINT (w
->hscroll
),
1933 pos_tab_offset (w
, startp
), w
);
1934 if (pos
.vpos
> scroll_conservatively
)
1937 pos
= *vmotion (startp
, pos
.vpos
+ 1 + this_scroll_margin
, w
);
1939 if (! NILP (Vwindow_scroll_functions
))
1941 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
1942 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1943 make_number (pos
.bufpos
));
1944 pos
.bufpos
= marker_position (w
->start
);
1946 try_window (window
, pos
.bufpos
);
1947 if (cursor_vpos
>= 0)
1949 if (!just_this_one
|| current_buffer
->clip_changed
1950 || beg_unchanged
< startp
)
1951 /* Forget any recorded base line for line number display. */
1952 w
->base_line_number
= Qnil
;
1956 cancel_my_columns (w
);
1960 struct position pos
;
1961 pos
= *compute_motion (PT
, 0, 0, 0,
1962 startp
, XFASTINT (w
->height
), 0,
1963 XFASTINT (w
->width
), XFASTINT (w
->hscroll
),
1964 pos_tab_offset (w
, startp
), w
);
1965 if (pos
.vpos
>= scroll_conservatively
)
1968 pos
= *vmotion (startp
, - pos
.vpos
- this_scroll_margin
, w
);
1970 if (! NILP (Vwindow_scroll_functions
))
1972 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
1973 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1974 make_number (pos
.bufpos
));
1975 pos
.bufpos
= marker_position (w
->start
);
1977 try_window (window
, pos
.bufpos
);
1978 if (cursor_vpos
>= 0)
1980 if (!just_this_one
|| current_buffer
->clip_changed
1981 || beg_unchanged
< startp
)
1982 /* Forget any recorded base line for line number display. */
1983 w
->base_line_number
= Qnil
;
1987 cancel_my_columns (w
);
1992 if (scroll_step
&& !current_buffer
->clip_changed
1993 && startp
>= BEGV
&& startp
<= ZV
)
1997 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), scroll_step
, w
);
1998 if (pos
.vpos
>= height
)
2002 pos
= *vmotion (startp
, (PT
< startp
? - scroll_step
: scroll_step
), w
);
2004 if (PT
>= pos
.bufpos
)
2006 if (! NILP (Vwindow_scroll_functions
))
2008 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
2009 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2010 make_number (pos
.bufpos
));
2011 pos
.bufpos
= marker_position (w
->start
);
2013 try_window (window
, pos
.bufpos
);
2014 if (cursor_vpos
>= 0)
2016 if (!just_this_one
|| current_buffer
->clip_changed
2017 || beg_unchanged
< startp
)
2018 /* Forget any recorded base line for line number display. */
2019 w
->base_line_number
= Qnil
;
2023 cancel_my_columns (w
);
2028 /* Finally, just choose place to start which centers point */
2031 /* Forget any previously recorded base line for line number display. */
2032 w
->base_line_number
= Qnil
;
2034 pos
= *vmotion (PT
, - (height
/ 2), w
);
2035 /* Set startp here explicitly in case that helps avoid an infinite loop
2036 in case the window-scroll-functions functions get errors. */
2037 Fset_marker (w
->start
, make_number (pos
.bufpos
), Qnil
);
2038 if (! NILP (Vwindow_scroll_functions
))
2040 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2041 make_number (pos
.bufpos
));
2042 pos
.bufpos
= marker_position (w
->start
);
2044 try_window (window
, pos
.bufpos
);
2046 startp
= marker_position (w
->start
);
2047 w
->start_at_line_beg
2048 = (startp
== BEGV
|| FETCH_BYTE (startp
- 1) == '\n') ? Qt
: Qnil
;
2051 if ((update_mode_line
2052 /* If window not full width, must redo its mode line
2053 if the window to its side is being redone */
2054 || (!just_this_one
&& !WINDOW_FULL_WIDTH_P (w
))
2055 || INTEGERP (w
->base_line_pos
)
2056 || (!NILP (w
->column_number_displayed
)
2057 && XFASTINT (w
->column_number_displayed
) != current_column ()))
2058 && height
!= XFASTINT (w
->height
))
2059 display_mode_line (w
);
2060 if (! line_number_displayed
2061 && ! BUFFERP (w
->base_line_pos
))
2063 w
->base_line_pos
= Qnil
;
2064 w
->base_line_number
= Qnil
;
2067 /* When we reach a frame's selected window, redo the frame's menu bar. */
2068 if (update_mode_line
2069 && (FRAME_WINDOW_P (f
)
2071 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
2072 FRAME_EXTERNAL_MENU_BAR (f
)
2074 FRAME_MENU_BAR_LINES (f
) > 0
2076 : FRAME_MENU_BAR_LINES (f
) > 0)
2077 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
2078 display_menu_bar (w
);
2081 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2083 int start
, end
, whole
;
2085 /* Calculate the start and end positions for the current window.
2086 At some point, it would be nice to choose between scrollbars
2087 which reflect the whole buffer size, with special markers
2088 indicating narrowing, and scrollbars which reflect only the
2091 Note that minibuffers sometimes aren't displaying any text. */
2092 if (! MINI_WINDOW_P (w
)
2093 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
2096 start
= marker_position (w
->start
) - BEGV
;
2097 /* I don't think this is guaranteed to be right. For the
2098 moment, we'll pretend it is. */
2099 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
2101 if (end
< start
) end
= start
;
2102 if (whole
< (end
- start
)) whole
= end
- start
;
2105 start
= end
= whole
= 0;
2107 /* Indicate what this scroll bar ought to be displaying now. */
2108 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
2110 /* Note that we actually used the scroll bar attached to this window,
2111 so it shouldn't be deleted at the end of redisplay. */
2112 (*redeem_scroll_bar_hook
) (w
);
2115 BUF_PT (current_buffer
) = opoint
;
2116 if (update_mode_line
)
2117 set_buffer_internal_1 (old
);
2119 set_buffer_temp (old
);
2120 BUF_PT (current_buffer
) = lpoint
;
2123 /* Do full redisplay on one window, starting at position `pos'. */
2126 try_window (window
, pos
)
2130 register struct window
*w
= XWINDOW (window
);
2131 register int height
= window_internal_height (w
);
2132 register int vpos
= XFASTINT (w
->top
);
2133 register int last_text_vpos
= vpos
;
2134 FRAME_PTR f
= XFRAME (w
->frame
);
2135 int width
= window_internal_width (w
) - 1;
2136 struct position val
;
2138 /* POS should never be out of range! */
2139 if (pos
< XBUFFER (w
->buffer
)->begv
2140 || pos
> XBUFFER (w
->buffer
)->zv
)
2143 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2145 overlay_arrow_seen
= 0;
2146 zv_strings_seen
= 0;
2147 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
2148 val
.ovstring_chars_done
= 0;
2149 val
.tab_offset
= pos_tab_offset (w
, pos
);
2151 while (--height
>= 0)
2153 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, val
.tab_offset
,
2154 val
.ovstring_chars_done
);
2155 /* The following code is omitted because we maintain tab_offset
2158 tab_offset
+= width
;
2159 if (val
.vpos
) tab_offset
= 0;
2162 if (pos
!= val
.bufpos
)
2165 #ifdef USE_TEXT_PROPERTIES
2166 Lisp_Object invis_prop
;
2167 invis_prop
= Fget_char_property (val
.bufpos
-1, Qinvisible
, window
);
2168 invis
= TEXT_PROP_MEANS_INVISIBLE (invis_prop
);
2172 /* Next line, unless prev line ended in end of buffer with no cr */
2174 && (FETCH_BYTE (val
.bufpos
- 1) != '\n' || invis
));
2179 /* If last line is continued in middle of character,
2180 include the split character in the text considered on the frame */
2181 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2184 /* If bottom just moved off end of frame, change mode line percentage. */
2185 if (XFASTINT (w
->window_end_pos
) == 0
2187 w
->update_mode_line
= Qt
;
2189 /* Say where last char on frame will be, once redisplay is finished. */
2190 XSETFASTINT (w
->window_end_pos
, Z
- pos
);
2191 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
- XFASTINT (w
->top
));
2192 /* But that is not valid info until redisplay finishes. */
2193 w
->window_end_valid
= Qnil
;
2196 /* Try to redisplay when buffer is modified locally,
2197 computing insert/delete line to preserve text outside
2198 the bounds of the changes.
2199 Return 1 if successful, 0 if if cannot tell what to do,
2200 or -1 to tell caller to find a new window start,
2201 or -2 to tell caller to do normal redisplay with same window start. */
2204 try_window_id (window
)
2208 register struct window
*w
= XWINDOW (window
);
2209 register int height
= window_internal_height (w
);
2210 FRAME_PTR f
= XFRAME (w
->frame
);
2211 int top
= XFASTINT (w
->top
);
2212 int start
= marker_position (w
->start
);
2213 int width
= window_internal_width (w
) - 1;
2214 int hscroll
= XINT (w
->hscroll
);
2215 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
2218 register int i
, tem
;
2219 int last_text_vpos
= 0;
2221 int selective
= (INTEGERP (current_buffer
->selective_display
)
2222 ? XINT (current_buffer
->selective_display
)
2223 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
2225 struct position val
, bp
, ep
, xp
, pp
;
2226 int scroll_amount
= 0;
2230 if (GPT
- BEG
< beg_unchanged
)
2231 beg_unchanged
= GPT
- BEG
;
2232 if (Z
- GPT
< end_unchanged
)
2233 end_unchanged
= Z
- GPT
;
2235 if (beg_unchanged
+ BEG
< start
)
2236 return 0; /* Give up if changes go above top of window */
2238 /* Find position before which nothing is changed. */
2239 bp
= *compute_motion (start
, 0, lmargin
, 0,
2240 min (ZV
, beg_unchanged
+ BEG
), height
,
2241 /* BUG FIX: See the comment of
2242 Fpos_visible_in_window_p() (window.c). */
2243 - (1 << (BITS_PER_SHORT
- 1)),
2244 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2245 if (bp
.vpos
>= height
)
2249 /* All changes are beyond the window end, and point is on the screen.
2250 We don't need to change the text at all.
2251 But we need to update window_end_pos to account for
2252 any change in buffer size. */
2253 bp
= *compute_motion (start
, 0, lmargin
, 0,
2255 /* BUG FIX: See the comment of
2256 Fpos_visible_in_window_p() (window.c). */
2257 - (1 << (BITS_PER_SHORT
- 1)),
2258 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2259 XSETFASTINT (w
->window_end_vpos
, height
);
2260 XSETFASTINT (w
->window_end_pos
, Z
- bp
.bufpos
);
2268 /* Find beginning of that frame line. Must display from there. */
2269 bp
= *vmotion (bp
.bufpos
, 0, w
);
2277 /* If about to start displaying at the beginning of a continuation line,
2278 really start with previous frame line, in case it was not
2279 continued when last redisplayed */
2280 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
2282 /* Likewise if we have to worry about selective display. */
2283 (selective
> 0 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
2285 bp
= *vmotion (bp
.bufpos
, -1, w
);
2289 val
.tab_offset
= bp
.tab_offset
; /* Update tab offset. */
2291 if (bp
.contin
&& bp
.hpos
!= lmargin
)
2293 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
2294 val
.tab_offset
= bp
.tab_offset
+ bp
.prevhpos
- width
;
2301 /* Find first visible newline after which no more is changed. */
2302 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
2304 while (tem
< ZV
- 1 && (indented_beyond_p (tem
, selective
)))
2305 tem
= find_next_newline (tem
, 1);
2307 /* Compute the cursor position after that newline. */
2308 ep
= *compute_motion (pos
, vpos
, val
.hpos
, did_motion
, tem
,
2309 height
, - (1 << (BITS_PER_SHORT
- 1)),
2311 /* We have tab offset in VAL, use it. */
2314 /* If changes reach past the text available on the frame,
2315 just display rest of frame. */
2316 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
2319 stop_vpos
= ep
.vpos
;
2321 /* If no newline before ep, the line ep is on includes some changes
2322 that must be displayed. Make sure we don't stop before it. */
2323 /* Also, if changes reach all the way until ep.bufpos,
2324 it is possible that something was deleted after the
2325 newline before it, so the following line must be redrawn. */
2326 if (stop_vpos
== ep
.vpos
2327 && (ep
.bufpos
== BEGV
2328 || FETCH_BYTE (ep
.bufpos
- 1) != '\n'
2329 || ep
.bufpos
== Z
- end_unchanged
))
2330 stop_vpos
= ep
.vpos
+ 1;
2333 overlay_arrow_seen
= 0;
2334 zv_strings_seen
= 0;
2336 /* If changes do not reach to bottom of window,
2337 figure out how much to scroll the rest of the window */
2338 if (stop_vpos
< height
)
2340 /* Now determine how far up or down the rest of the window has moved */
2341 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2342 Z
- XFASTINT (w
->window_end_pos
),
2343 /* Don't care for VPOS... */
2344 1 << (BITS_PER_SHORT
- 1),
2346 1 << (BITS_PER_SHORT
- 1),
2347 width
, hscroll
, ep
.tab_offset
, w
);
2348 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
2350 /* Is everything on frame below the changes whitespace?
2351 If so, no scrolling is really necessary. */
2352 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
2354 tem
= FETCH_BYTE (i
);
2355 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
2361 XSETFASTINT (w
->window_end_vpos
,
2362 XFASTINT (w
->window_end_vpos
) + scroll_amount
);
2364 /* Before doing any scrolling, verify that point will be on frame. */
2365 if (PT
> ep
.bufpos
&& !(PT
<= xp
.bufpos
&& xp
.vpos
< height
))
2367 if (PT
<= xp
.bufpos
)
2369 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2370 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2372 /* We have tab offset in EP, use it. */
2377 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
, 1,
2378 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2380 /* We have tab offset in XP, use it. */
2383 if (pp
.bufpos
< PT
|| pp
.vpos
== height
)
2385 cursor_vpos
= pp
.vpos
+ top
;
2386 cursor_hpos
= WINDOW_LEFT_MARGIN (w
) + minmax (0, pp
.hpos
, width
);
2389 if (stop_vpos
- scroll_amount
>= height
2390 || ep
.bufpos
== xp
.bufpos
)
2392 if (scroll_amount
< 0)
2393 stop_vpos
-= scroll_amount
;
2395 /* In this path, we have altered window_end_vpos
2396 and not left it negative.
2397 We must make sure that, in case display is preempted
2398 before the frame changes to reflect what we do here,
2399 further updates will not come to try_window_id
2400 and assume the frame and window_end_vpos match. */
2401 blank_end_of_window
= 1;
2403 else if (!scroll_amount
)
2405 /* Even if we don't need to scroll, we must adjust the
2406 charstarts of subsequent lines (that we won't redisplay)
2407 according to the amount of text inserted or deleted. */
2408 int oldpos
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2409 int adjust
= ep
.bufpos
- oldpos
;
2410 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1, adjust
);
2412 else if (bp
.bufpos
== Z
- end_unchanged
)
2414 /* If reprinting everything is nearly as fast as scrolling,
2415 don't bother scrolling. Can happen if lines are short. */
2416 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
2417 top
+ height
- max (0, scroll_amount
),
2419 > xp
.bufpos
- bp
.bufpos
- 20)
2420 /* Return "try normal display with same window-start."
2421 Too bad we can't prevent further scroll-thinking. */
2423 /* If pure deletion, scroll up as many lines as possible.
2424 In common case of killing a line, this can save the
2425 following line from being overwritten by scrolling
2426 and therefore having to be redrawn. */
2427 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
2428 top
+ height
- max (0, scroll_amount
),
2429 scroll_amount
, bp
.bufpos
);
2434 /* scroll_frame_lines did not properly adjust subsequent
2435 lines' charstarts in the case where the text of the
2436 screen line at bp.vpos has changed.
2437 (This can happen in a deletion that ends in mid-line.)
2438 To adjust properly, we need to make things consistent
2440 So do a second adjust to make that happen.
2441 Note that stop_vpos >= ep.vpos, so it is sufficient
2442 to update the charstarts for lines at ep.vpos and below. */
2444 = FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2445 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1,
2446 ep
.bufpos
- oldstart
);
2449 else if (scroll_amount
)
2451 /* If reprinting everything is nearly as fast as scrolling,
2452 don't bother scrolling. Can happen if lines are short. */
2453 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
2454 overestimate of cost of reprinting, since xp.bufpos
2455 would end up below the bottom of the window. */
2456 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
2457 top
+ height
- max (0, scroll_amount
),
2459 > xp
.bufpos
- ep
.bufpos
- 20)
2460 /* Return "try normal display with same window-start."
2461 Too bad we can't prevent further scroll-thinking. */
2463 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
2464 top
+ height
- max (0, scroll_amount
),
2465 scroll_amount
, ep
.bufpos
);
2466 if (!tem
) stop_vpos
= height
;
2470 /* In any case, do not display past bottom of window */
2471 if (stop_vpos
>= height
)
2477 /* Handle case where pos is before w->start --
2478 can happen if part of line had been clipped and is not clipped now */
2479 if (vpos
== 0 && pos
< marker_position (w
->start
))
2480 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2482 /* Redisplay the lines where the text was changed */
2483 last_text_vpos
= vpos
;
2484 /* The following code is omitted because we maintain tab offset in
2487 tab_offset
= pos_tab_offset (w
, pos
);
2488 /* If we are starting display in mid-character, correct tab_offset
2489 to account for passing the line that that character really starts in. */
2490 if (val
.hpos
< lmargin
)
2491 tab_offset
+= width
;
2494 while (vpos
< stop_vpos
)
2496 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, val
.tab_offset
,
2497 val
.ovstring_chars_done
);
2498 /* If display_text_line ran a hook and changed some text,
2499 redisplay all the way to bottom of buffer
2500 So that we show the changes. */
2501 if (old_tick
!= MODIFF
)
2503 /* The following code is omitted because we maintain tab offset
2504 in val.tab_offset. */
2506 tab_offset
+= width
;
2507 if (val
.vpos
) tab_offset
= 0;
2509 if (pos
!= val
.bufpos
)
2511 /* Next line, unless prev line ended in end of buffer with no cr */
2512 = vpos
- (val
.vpos
&& FETCH_BYTE (val
.bufpos
- 1) != '\n');
2516 /* There are two cases:
2517 1) we have displayed down to the bottom of the window
2518 2) we have scrolled lines below stop_vpos by scroll_amount */
2522 /* If last line is continued in middle of character,
2523 include the split character in the text considered on the frame */
2524 if (val
.hpos
< lmargin
)
2526 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
);
2527 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2530 /* If scrolling made blank lines at window bottom,
2531 redisplay to fill those lines */
2532 if (scroll_amount
< 0)
2534 /* Don't consider these lines for general-purpose scrolling.
2535 That will save time in the scrolling computation. */
2536 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
2540 val
.tab_offset
= xp
.tab_offset
;
2542 { /* Display from next line */
2543 vpos
= height
+ scroll_amount
;
2547 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
2549 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
2550 val
.tab_offset
= xp
.tab_offset
+ bp
.prevhpos
- width
;
2554 blank_end_of_window
= 1;
2555 /* The following code is omitted because we maintain tab offset
2556 in val.tab_offset. */
2558 tab_offset
= pos_tab_offset (w
, pos
);
2559 /* If we are starting display in mid-character, correct tab_offset
2560 to account for passing the line that that character starts in. */
2561 if (val
.hpos
< lmargin
)
2562 tab_offset
+= width
;
2564 while (vpos
< height
)
2566 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
,
2567 val
.tab_offset
, val
.ovstring_chars_done
);
2568 /* The following code is omitted because we maintain tab
2569 offset in val.tab_offset. */
2571 tab_offset
+= width
;
2572 if (val
.vpos
) tab_offset
= 0;
2577 /* Here is a case where display_text_line sets cursor_vpos wrong.
2578 Make it be fixed up, below. */
2584 /* If bottom just moved off end of frame, change mode line percentage. */
2585 if (XFASTINT (w
->window_end_pos
) == 0
2587 w
->update_mode_line
= Qt
;
2589 /* Attempt to adjust end-of-text positions to new bottom line */
2592 delta
= height
- xp
.vpos
;
2594 || (delta
> 0 && xp
.bufpos
<= ZV
)
2595 || (delta
== 0 && xp
.hpos
))
2597 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), delta
, w
);
2598 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2599 XSETFASTINT (w
->window_end_vpos
,
2600 XFASTINT (w
->window_end_vpos
) + val
.vpos
);
2604 w
->window_end_valid
= Qnil
;
2606 /* If point was not in a line that was displayed, find it */
2607 if (cursor_vpos
< 0)
2610 val
= *compute_motion (start
, 0, lmargin
, 0, PT
,
2611 /* Don't care for VPOS... */
2612 1 << (BITS_PER_SHORT
- 1),
2614 1 << (BITS_PER_SHORT
- 1),
2615 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2616 /* Admit failure if point is off frame now */
2617 if (val
.vpos
>= height
)
2619 for (vpos
= 0; vpos
< height
; vpos
++)
2620 cancel_line (vpos
+ top
, f
);
2623 cursor_vpos
= val
.vpos
+ top
;
2624 cursor_hpos
= WINDOW_LEFT_MARGIN (w
) + minmax (0, val
.hpos
, width
);
2627 FRAME_CURSOR_X (f
) = cursor_hpos
;
2628 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2632 val
= *compute_motion (start
, 0, lmargin
, 0, ZV
,
2633 height
, - (1 << (BITS_PER_SHORT
- 1)),
2634 width
, hscroll
, pos_tab_offset (w
, start
), w
);
2635 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
2637 if (XFASTINT (w
->window_end_pos
)
2645 /* Copy LEN glyphs starting address FROM to the rope TO.
2646 But don't actually copy the parts that would come in before S.
2647 Value is TO, advanced past the copied data.
2648 F is the frame we are displaying in. */
2651 copy_part_of_rope (f
, to
, s
, from
, len
, face
)
2653 register GLYPH
*to
; /* Copy to here. */
2654 register GLYPH
*s
; /* Starting point. */
2655 Lisp_Object
*from
; /* Data to copy. */
2657 int face
; /* Face to apply to glyphs which don't specify one. */
2660 register Lisp_Object
*fp
= from
;
2661 /* These cache the results of the last call to compute_glyph_face. */
2663 int last_merged
= 0;
2666 if (! FRAME_TERMCAP_P (f
))
2669 GLYPH glyph
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
2671 unsigned int c
= FAST_GLYPH_CHAR (glyph
);
2674 /* For an invalid character code, use space. */
2677 if (FAST_GLYPH_FACE (glyph
) == 0)
2678 /* If GLYPH has no face code, use FACE. */
2680 else if (FAST_GLYPH_FACE (glyph
) == last_code
)
2681 /* If it's same as previous glyph, use same result. */
2682 facecode
= last_merged
;
2685 /* Merge this glyph's face and remember the result. */
2686 last_code
= FAST_GLYPH_FACE (glyph
);
2687 last_merged
= facecode
= compute_glyph_face (f
, last_code
, face
);
2691 *to
= FAST_MAKE_GLYPH (c
, facecode
);
2699 if (to
>= s
) *to
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
2706 /* Correct a glyph by replacing its specified user-level face code
2707 with a displayable computed face code. */
2710 fix_glyph (f
, glyph
, cface
)
2716 if (! FRAME_TERMCAP_P (f
))
2718 if (FAST_GLYPH_FACE (glyph
) != 0)
2719 cface
= compute_glyph_face (f
, FAST_GLYPH_FACE (glyph
), cface
);
2720 glyph
= FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph
), cface
);
2726 /* Display one line of window W, starting at position START in W's buffer.
2728 Display starting at horizontal position HPOS, expressed relative to
2729 W's left edge. In situations where the text at START shouldn't
2730 start at the left margin (i.e. when the window is hscrolled, or
2731 we're continuing a line which left off in the midst of a
2732 multi-column character), HPOS should be negative; we throw away
2733 characters up 'til hpos = 0. So, HPOS must take hscrolling into
2736 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
2738 OVSTR_DONE is the number of chars of overlay before/after strings
2739 at this position which have already been processed.
2741 Display on position VPOS on the frame. It is origin 0, relative to
2742 the top of the frame, not W.
2744 Returns a STRUCT POSITION giving character to start next line with
2745 and where to display it, including a zero or negative hpos.
2746 The vpos field is not really a vpos; it is 1 unless the line is continued */
2748 struct position val_display_text_line
;
2750 static struct position
*
2751 display_text_line (w
, start
, vpos
, hpos
, taboffset
, ovstr_done
)
2759 register int pos
= start
;
2763 register unsigned char *p
;
2765 register GLYPH
*leftmargin
;
2766 register GLYPH
*p1prev
;
2767 register GLYPH
*p1start
;
2770 FRAME_PTR f
= XFRAME (w
->frame
);
2771 int tab_width
= XINT (current_buffer
->tab_width
);
2772 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
2773 int width
= window_internal_width (w
) - 1;
2774 struct position val
;
2777 int last_invis_skip
= 0;
2778 Lisp_Object last_invis_prop
;
2779 int hscroll
= XINT (w
->hscroll
);
2780 int truncate
= (hscroll
2781 || (truncate_partial_width_windows
2782 && !WINDOW_FULL_WIDTH_P (w
))
2783 || !NILP (current_buffer
->truncate_lines
));
2785 /* 1 if we should highlight the region. */
2786 int highlight_region
2787 = (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
)
2788 && (XWINDOW (current_buffer
->last_selected_window
) == w
2789 || highlight_nonselected_windows
));
2790 int region_beg
, region_end
;
2792 int selective
= (INTEGERP (current_buffer
->selective_display
)
2793 ? XINT (current_buffer
->selective_display
)
2794 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
2795 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
2796 register struct Lisp_Char_Table
*dp
= window_display_table (w
);
2798 Lisp_Object default_invis_vector
[3];
2799 /* Number of characters of ellipsis to display after an invisible line
2800 if it calls for an ellipsis.
2801 Note that this value can be nonzero regardless of whether
2802 selective display is enabled--you must check that separately. */
2804 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
2805 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
2806 : !NILP (current_buffer
->selective_display_ellipses
) ? 3 : 0);
2807 /* This is the sequence of Lisp objects to display
2808 when there are invisible lines. */
2809 Lisp_Object
*invis_vector_contents
2810 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
2811 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
2812 : default_invis_vector
);
2814 GLYPH truncator
= (dp
== 0 || !INTEGERP (DISP_TRUNC_GLYPH (dp
))
2815 || !GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (dp
)))
2816 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
2817 GLYPH continuer
= (dp
== 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp
))
2818 || !GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (dp
)))
2819 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
2821 /* If 1, we must handle multibyte characters. */
2822 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
2823 /* Length of multibyte form of each character. */
2825 /* Glyphs generated should be set this bit mask if text must be
2826 displayed from right to left. */
2827 GLYPH rev_dir_bit
= (NILP (current_buffer
->direction_reversed
)
2828 ? 0 : GLYPH_MASK_REV_DIR
);
2830 /* The next buffer location at which the face should change, due
2831 to overlays or text property changes. */
2832 int next_face_change
;
2834 /* The next location where the `invisible' property changes, or an
2835 overlay starts or ends. */
2838 /* The face we're currently using. */
2839 int current_face
= 0;
2842 XSETFASTINT (default_invis_vector
[2], '.');
2843 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
2845 hpos
+= WINDOW_LEFT_MARGIN (w
);
2846 get_display_line (f
, vpos
, WINDOW_LEFT_MARGIN (w
));
2847 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
2849 /* Show where to highlight the region. */
2850 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
2851 /* Maybe highlight only in selected window. */
2852 && (highlight_nonselected_windows
2853 || w
== XWINDOW (selected_window
)))
2855 region_beg
= marker_position (current_buffer
->mark
);
2856 if (PT
< region_beg
)
2858 region_end
= region_beg
;
2863 w
->region_showing
= Qt
;
2867 region_beg
= region_end
= -1;
2868 w
->region_showing
= Qnil
;
2871 if (MINI_WINDOW_P (w
)
2873 && vpos
== XFASTINT (w
->top
))
2875 if (! NILP (minibuf_prompt
))
2877 minibuf_prompt_width
2878 = (display_string (w
, vpos
, XSTRING (minibuf_prompt
)->data
,
2879 XSTRING (minibuf_prompt
)->size
, hpos
,
2880 /* Display a space if we truncate. */
2883 /* Truncate the prompt a little before the
2884 margin, so user input can at least start
2885 on the first line. */
2886 (XFASTINT (w
->width
) > 10
2887 ? XFASTINT (w
->width
) - 4 : -1))
2889 hpos
+= minibuf_prompt_width
;
2890 taboffset
-= minibuf_prompt_width
;
2893 minibuf_prompt_width
= 0;
2896 /* If we're hscrolled at all, use compute_motion to skip over any
2897 text off the left edge of the window. compute_motion may know
2898 tricks to do this faster than we can. */
2901 struct position
*left_edge
2902 = compute_motion (pos
, vpos
, hpos
, 0,
2904 width
, hscroll
, taboffset
, w
);
2906 /* Retrieve the buffer position and column provided by
2907 compute_motion. We can't assume that the column will be
2908 zero, because you may have multi-column characters crossing
2911 compute_motion may have moved us past the screen position we
2912 requested, if we hit a multi-column character, or the end of
2913 the line. If so, back up. */
2914 if (left_edge
->vpos
> vpos
2915 || left_edge
->hpos
> 0)
2917 pos
= left_edge
->bufpos
;
2918 /* Since this should not be a valid multibyte character, we
2919 can decrease POS by 1. */
2921 hpos
= left_edge
->prevhpos
;
2925 pos
= left_edge
->bufpos
;
2926 hpos
= left_edge
->hpos
;
2930 desired_glyphs
->bufp
[vpos
] = start
;
2931 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2933 charstart
= desired_glyphs
->charstarts
[vpos
] + hpos
;
2934 /* In case we don't ever write anything into it... */
2935 desired_glyphs
->charstarts
[vpos
][WINDOW_LEFT_MARGIN (w
)] = -1;
2936 leftmargin
= desired_glyphs
->glyphs
[vpos
] + WINDOW_LEFT_MARGIN (w
);
2937 endp
= leftmargin
+ width
;
2939 /* Arrange the overlays nicely for our purposes. Usually, we call
2940 display_text_line on only one line at a time, in which case this
2941 can't really hurt too much, or we call it on lines which appear
2942 one after another in the buffer, in which case all calls to
2943 recenter_overlay_lists but the first will be pretty cheap. */
2944 recenter_overlay_lists (current_buffer
, pos
);
2946 /* Loop generating characters.
2947 Stop at end of buffer, before newline,
2948 if reach or pass continuation column,
2949 or at face change. */
2951 next_face_change
= pos
;
2952 next_boundary
= pos
;
2961 while (pos
== next_boundary
)
2963 Lisp_Object position
, limit
, prop
, ww
;
2965 /* Display the overlay strings here, unless we're at ZV
2966 and have already displayed the appropriate strings
2967 on an earlier line. */
2968 if (pos
< ZV
|| !zv_strings_seen
++)
2971 unsigned char *ovstr
;
2972 ovlen
= overlay_strings (pos
, w
, &ovstr
);
2976 /* Skip the ones we did in a previous line. */
2977 ovstr
+= ovstr_done
;
2978 ovlen
-= ovstr_done
;
2987 c
= STRING_CHAR_AND_LENGTH (ovstr
, ovlen
, len
);
2988 ovstr
+= len
, ovlen
-= len
, ovstr_done
+= len
;
2989 charset
= CHAR_CHARSET (c
);
2990 cols
= (charset
== CHARSET_COMPOSITION
2991 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
2992 : CHARSET_WIDTH (charset
));
2996 c
= *ovstr
++, ovlen
--, ovstr_done
++;
2999 g
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3002 if (p1
>= leftmargin
&& p1
< endp
)
3003 *p1
= g
, g
|= GLYPH_MASK_PADDING
;
3007 /* If we did all the overlay strings
3008 and we have room for text, clear ovstr_done
3009 just for neatness' sake. */
3010 if (ovlen
== 0 && p1
< endp
)
3015 /* Did we reach point? Record the cursor location. */
3016 if (pos
== PT
&& cursor_vpos
< 0)
3019 cursor_hpos
= p1
- leftmargin
;
3025 XSETFASTINT (position
, pos
);
3026 limit
= Fnext_overlay_change (position
);
3027 #ifdef USE_TEXT_PROPERTIES
3028 /* This is just an estimate to give reasonable
3029 performance; nothing should go wrong if it is too small. */
3030 if (XFASTINT (limit
) > pos
+ 50)
3032 int limitpos
= pos
+ 50;
3034 INC_POS (limitpos
); /* Adjust to character boundary. */
3035 XSETFASTINT (limit
, limitpos
);
3037 limit
= Fnext_single_property_change (position
, Qinvisible
,
3038 Fcurrent_buffer (), limit
);
3040 next_boundary
= XFASTINT (limit
);
3041 /* if the `invisible' property is set, we can skip to
3042 the next property change. */
3044 prop
= Fget_char_property (position
, Qinvisible
, ww
);
3045 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
3047 if (pos
< PT
&& next_boundary
>= PT
)
3050 cursor_hpos
= p1
- leftmargin
;
3052 pos
= next_boundary
;
3053 last_invis_skip
= pos
;
3054 last_invis_prop
= prop
;
3058 /* Did we reach point? Record the cursor location. */
3059 if (pos
== PT
&& cursor_vpos
< 0)
3062 cursor_hpos
= p1
- leftmargin
;
3065 /* Did we hit the end of the visible region of the buffer?
3069 /* Update charstarts for the end of this line. */
3070 /* Do nothing if off the left edge or at the right edge. */
3071 if (p1
>= leftmargin
&& p1
+ 1 != endp
)
3073 int *p2x
= &charstart
[(p1
< leftmargin
3081 /* Figure out where (if at all) the
3082 redisplay_end_trigger-hook should run. */
3083 if (MARKERP (w
->redisplay_end_trigger
)
3084 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
3085 e_t_h
= marker_position (w
->redisplay_end_trigger
);
3086 else if (INTEGERP (w
->redisplay_end_trigger
))
3087 e_t_h
= XINT (w
->redisplay_end_trigger
);
3091 /* If we've gone past the place to run a hook,
3093 if (pos
>= e_t_h
&& e_t_h
!= ZV
)
3095 Lisp_Object args
[3];
3097 args
[0] = Qredisplay_end_trigger_functions
;
3098 XSETWINDOW (args
[1], w
);
3099 XSETINT (args
[2], e_t_h
);
3101 /* Since we are *trying* to run these functions,
3102 don't try to run them again, even if they get an error. */
3103 w
->redisplay_end_trigger
= Qnil
;
3104 Frun_hook_with_args (3, args
);
3107 /* Notice if it changed the face of this character. */
3108 next_face_change
= pos
;
3112 /* Did we hit a face change? Figure out what face we should
3113 use now. We also hit this the first time through the
3114 loop, to see what face we should start with. */
3115 if (pos
>= next_face_change
3116 && (FRAME_WINDOW_P (f
) || FRAME_MSDOS_P (f
)))
3118 int limit
= pos
+ 50;
3120 if (limit
< Z
&& !CHAR_HEAD_P (POS_ADDR (limit
)))
3121 INC_POS (limit
); /* Adjust to character boundary. */
3122 current_face
= compute_char_face (f
, w
, pos
,
3123 region_beg
, region_end
,
3124 &next_face_change
, limit
, 0);
3128 /* Compute the next place we need to stop
3129 and do something special; set PAUSE. */
3133 if (pos
< next_boundary
&& next_boundary
< pause
)
3134 pause
= next_boundary
;
3135 if (pos
< next_face_change
&& next_face_change
< pause
)
3136 pause
= next_face_change
;
3141 /* Wouldn't you hate to read the next line to someone over
3143 if (pos
< PT
&& PT
< pause
)
3145 if (pos
< GPT
&& GPT
< pause
)
3157 /* PAUSE is surely at character boundary. */
3158 c
= STRING_CHAR_AND_LENGTH (p
, pause
- pos
, len
), p
+= len
;
3161 /* Let a display table override all standard display methods. */
3162 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
3164 p1
= copy_part_of_rope (f
, p1
, leftmargin
,
3165 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
3166 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
3167 current_face
, rev_dir_bit
);
3169 else if (c
>= 040 && c
< 0177)
3171 if (p1
>= leftmargin
)
3172 *p1
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3178 /* Same as p1prev, but after the invis_vector_contents text
3179 (if we have that on this line). */
3180 GLYPH
*p1prev_modified
;
3184 if (last_invis_skip
== pos
3185 && TEXT_PROP_MEANS_INVISIBLE_WITH_ELLIPSIS (last_invis_prop
))
3189 && indented_beyond_p (pos
+ 1, selective
))
3192 pos
= find_next_newline (pos
+ 1, 1);
3193 if (FETCH_BYTE (pos
- 1) == '\n')
3196 if (invis
&& selective_rlen
> 0 && p1
>= leftmargin
)
3201 cs
= charstart
+ (p1
- p1start
);
3204 p1
+= selective_rlen
;
3205 if (p1
- leftmargin
> width
)
3208 #if 0 /* This needs more work; charstarts needs to record
3209 both whether a position ho;ds an ellipsis character
3210 and what buffer position it corresponds to. */
3211 csend
= charstart
+ (p1
- p1start
);
3214 /* The idea is to use p1prev_modified instead of p1prev
3215 in the loop below over p2x. */
3216 p1prev_modified
= p1
;
3219 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
3220 (p1
- p1prev
), current_face
, rev_dir_bit
);
3223 /* Update charstarts for the newline that ended this line. */
3224 /* Do nothing here for a char that's entirely off the left edge
3225 or if it starts at the right edge. */
3226 if (p1
>= leftmargin
&& p1prev
!= endp
)
3228 /* Store the newline's position into charstarts
3229 for the column where the newline starts.
3230 Store -1 for the rest of the glyphs it occupies. */
3231 int *p2x
= &charstart
[(p1prev
< leftmargin
3232 ? leftmargin
: p1prev
)
3234 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3241 /* Draw the face of the newline character as extending all the
3242 way to the end of the frame line. */
3245 if (p1
< leftmargin
)
3248 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
) | rev_dir_bit
;
3258 if (p1
>= leftmargin
&& p1
< endp
)
3259 *p1
= MAKE_GLYPH (f
, ' ', current_face
) | rev_dir_bit
;
3262 while ((p1
- leftmargin
+ taboffset
+ hscroll
- (hscroll
> 0))
3265 else if (c
== Ctl ('M') && selective
== -1)
3267 pos
= find_next_newline (pos
, 1);
3268 if (FETCH_BYTE (pos
- 1) == '\n')
3270 if (selective_rlen
> 0)
3272 p1
+= selective_rlen
;
3273 if (p1
- leftmargin
> width
)
3275 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
3276 (p1
- p1prev
), current_face
, rev_dir_bit
);
3279 /* Draw the face of the newline character as extending all the
3280 way to the end of the frame line. */
3283 if (p1
< leftmargin
)
3286 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
) | rev_dir_bit
;
3290 /* Update charstarts for the ^M that ended this line. */
3291 /* Do nothing here for a char that's entirely off the left edge
3292 or if it starts at the right edge. */
3293 if (p1
>= leftmargin
&& p1prev
!= endp
)
3295 /* Store the newline's position into charstarts
3296 for the column where the newline starts.
3297 Store -1 for the rest of the glyphs it occupies. */
3298 int *p2x
= &charstart
[(p1prev
< leftmargin
3299 ? leftmargin
: p1prev
)
3301 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3309 else if (c
< 0200 && ctl_arrow
)
3311 if (p1
>= leftmargin
)
3313 (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
3314 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp
)))
3315 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
3319 if (p1
>= leftmargin
&& p1
< endp
)
3320 *p1
= MAKE_GLYPH (f
, c
^ 0100, current_face
) | rev_dir_bit
;
3325 /* C is not a multibyte character. */
3326 if (p1
>= leftmargin
)
3328 (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
3329 && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp
)))
3330 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
3334 if (p1
>= leftmargin
&& p1
< endp
)
3335 *p1
= MAKE_GLYPH (f
, (c
>> 6) + '0', current_face
) | rev_dir_bit
;
3337 if (p1
>= leftmargin
&& p1
< endp
)
3338 *p1
= (MAKE_GLYPH (f
, (7 & (c
>> 3)) + '0', current_face
)
3341 if (p1
>= leftmargin
&& p1
< endp
)
3342 *p1
= MAKE_GLYPH (f
, (7 & c
) + '0', current_face
) | rev_dir_bit
;
3347 /* C is a multibyte character. */
3348 int charset
= CHAR_CHARSET (c
);
3349 int columns
= (charset
== CHARSET_COMPOSITION
3350 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
3351 : CHARSET_WIDTH (charset
));
3352 GLYPH g
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3356 if (p1
>= leftmargin
&& p1
< endp
)
3357 *p1
= g
, g
|= GLYPH_MASK_PADDING
;
3365 /* Update charstarts for the character just output. */
3367 /* Do nothing here for a char that's entirely off the left edge. */
3368 if (p1
>= leftmargin
)
3370 /* Store the char's position into charstarts
3371 for the first glyph occupied by this char.
3372 Store -1 for the rest of the glyphs it occupies. */
3375 int *p2x
= &charstart
[(p1prev
< leftmargin
3376 ? leftmargin
: p1prev
)
3378 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3388 val
.hpos
= - XINT (w
->hscroll
);
3396 /* Store 0 in this charstart line for the positions where
3397 there is no character. But do leave what was recorded
3398 for the character that ended the line. */
3399 /* Add 1 in the endtest to compensate for the fact that ENDP was
3400 made from WIDTH, which is 1 less than the window's actual
3402 i
= p1
- p1start
+ 1;
3403 if (p1
< leftmargin
)
3404 i
+= leftmargin
- p1
;
3405 for (; i
< endp
- p1start
+ 1; i
++)
3408 /* Handle continuation in middle of a character */
3409 /* by backing up over it */
3412 /* Don't back up if we never actually displayed any text.
3413 This occurs when the minibuffer prompt takes up the whole line. */
3416 /* Start the next line with that same character whose
3417 character code is C and the length of multi-byte form is
3422 /* C is not a multi-byte character. We can break it and
3423 start from the middle column in the next line. So,
3424 adjust VAL.HPOS to skip the columns output on this
3426 val
.hpos
+= p1prev
- endp
;
3429 /* C is a multibyte character. Since we can't broke it
3430 in the middle, the whole character should be driven
3431 into the next line. */
3432 /* As the result, the actual columns occupied by the
3433 text on this line is less than WIDTH. VAL.TAB_OFFSET
3434 must be adjusted. */
3435 taboffset
= taboffset
+ (p1prev
- endp
);
3436 /* Let's fill unused columns with TRUNCATOR or CONTINUER. */
3438 GLYPH g
= fix_glyph (f
, truncate
? truncator
: continuer
, 0);
3439 while (p1prev
< endp
)
3442 /* If POINT is at POS, cursor should not on this line. */
3449 /* Keep in this line everything up to the continuation column. */
3453 /* Finish deciding which character to start the next line on,
3454 and what hpos to start it at.
3455 Also set `lastpos' to the last position which counts as "on this line"
3456 for cursor-positioning. */
3460 if (FETCH_BYTE (pos
) == '\n')
3462 /* If stopped due to a newline, start next line after it */
3465 /* Check again for hidden lines, in case the newline occurred exactly
3466 at the right margin. */
3467 while (pos
< ZV
&& selective
> 0
3468 && indented_beyond_p (pos
, selective
))
3469 pos
= find_next_newline (pos
, 1);
3472 /* Stopped due to right margin of window */
3476 *p1
++ = fix_glyph (f
, truncator
, 0);
3477 /* Truncating => start next line after next newline,
3478 and point is on this line if it is before the newline,
3479 and skip none of first char of next line */
3481 pos
= find_next_newline (pos
, 1);
3482 while (pos
< ZV
&& selective
> 0
3483 && indented_beyond_p (pos
, selective
));
3484 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
3486 lastpos
= pos
- (FETCH_BYTE (pos
- 1) == '\n');
3491 *p1
++ = fix_glyph (f
, continuer
, 0);
3494 val
.tab_offset
= taboffset
+ width
;
3501 /* If point is at eol or in invisible text at eol,
3502 record its frame location now. */
3504 if (start
<= PT
&& PT
<= lastpos
&& cursor_vpos
< 0)
3507 cursor_hpos
= p1
- leftmargin
;
3510 if (cursor_vpos
== vpos
)
3512 if (cursor_hpos
< 0) cursor_hpos
= 0;
3513 if (cursor_hpos
> width
) cursor_hpos
= width
;
3514 cursor_hpos
+= WINDOW_LEFT_MARGIN (w
);
3515 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
3517 if (!(cursor_in_echo_area
&& FRAME_HAS_MINIBUF_P (f
)
3518 && EQ (FRAME_MINIBUF_WINDOW (f
), minibuf_window
)))
3520 FRAME_CURSOR_Y (f
) = cursor_vpos
;
3521 FRAME_CURSOR_X (f
) = cursor_hpos
;
3524 if (w
== XWINDOW (selected_window
))
3526 /* Line is not continued and did not start
3527 in middle of character */
3528 if ((hpos
- WINDOW_LEFT_MARGIN (w
)
3529 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
3532 this_line_bufpos
= start
;
3533 this_line_buffer
= current_buffer
;
3534 this_line_vpos
= cursor_vpos
;
3535 this_line_start_hpos
= hpos
;
3536 this_line_endpos
= Z
- lastpos
;
3539 this_line_bufpos
= 0;
3544 /* If hscroll and line not empty, insert truncation-at-left marker */
3545 if (hscroll
&& lastpos
!= start
)
3547 GLYPH g
= fix_glyph (f
, truncator
, 0);
3549 if (p1
<= leftmargin
)
3550 p1
= leftmargin
+ 1;
3551 else /* MULE: it may be a wide-column character */
3553 p1prev
= leftmargin
+ 1;
3554 while (p1prev
< p1
&& *p1prev
& GLYPH_MASK_PADDING
)
3559 if (!WINDOW_RIGHTMOST_P (w
))
3562 if (p1
< leftmargin
) p1
= leftmargin
;
3563 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
3565 /* Don't draw vertical bars if we're using scroll bars. They're
3566 covered up by the scroll bars, and it's distracting to see
3567 them when the scroll bar windows are flickering around to be
3569 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
3572 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
3575 else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3576 *p1
++ = (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
3577 ? XINT (DISP_BORDER_GLYPH (dp
))
3580 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
3581 p1
- desired_glyphs
->glyphs
[vpos
]);
3582 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
3584 /* If the start of this line is the overlay arrow-position,
3585 then put the arrow string into the display-line. */
3587 if (MARKERP (Voverlay_arrow_position
)
3588 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
3589 && start
== marker_position (Voverlay_arrow_position
)
3590 && STRINGP (Voverlay_arrow_string
)
3591 && ! overlay_arrow_seen
)
3593 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
3595 int len
= XSTRING (Voverlay_arrow_string
)->size
;
3601 if (!NULL_INTERVAL_P (XSTRING (Voverlay_arrow_string
)->intervals
))
3603 /* If the arrow string has text props, obey them when displaying. */
3604 for (i
= 0; i
< len
; i
++)
3607 Lisp_Object face
, ilisp
;
3610 XSETFASTINT (ilisp
, i
);
3611 face
= Fget_text_property (ilisp
, Qface
, Voverlay_arrow_string
);
3612 newface
= compute_glyph_face_1 (f
, face
, 0);
3613 leftmargin
[i
] = FAST_MAKE_GLYPH (c
, newface
);
3617 #endif /* HAVE_FACES */
3619 for (i
= 0; i
< len
; i
++)
3620 leftmargin
[i
] = p
[i
];
3623 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
3624 arrow_end
= (leftmargin
- desired_glyphs
->glyphs
[vpos
]) + len
;
3625 if (desired_glyphs
->used
[vpos
] < arrow_end
)
3626 desired_glyphs
->used
[vpos
] = arrow_end
;
3628 overlay_arrow_seen
= 1;
3632 val
.ovstring_chars_done
= ovstr_done
;
3633 val_display_text_line
= val
;
3634 return &val_display_text_line
;
3637 /* Redisplay the menu bar in the frame for window W. */
3640 display_menu_bar (w
)
3643 Lisp_Object items
, tail
;
3644 register int vpos
= 0;
3645 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3646 int maxendcol
= FRAME_WIDTH (f
);
3651 if (!NILP (Vwindow_system
))
3655 #ifdef USE_X_TOOLKIT
3658 #endif /* USE_X_TOOLKIT */
3660 get_display_line (f
, vpos
, 0);
3662 items
= FRAME_MENU_BAR_ITEMS (f
);
3663 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
3665 Lisp_Object pos
, string
;
3666 string
= XVECTOR (items
)->contents
[i
+ 1];
3670 XSETFASTINT (XVECTOR (items
)->contents
[i
+ 3], hpos
);
3672 if (hpos
< maxendcol
)
3673 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
3674 XSTRING (string
)->data
,
3675 XSTRING (string
)->size
,
3676 hpos
, 0, 0, hpos
, maxendcol
);
3677 /* Put a space between items. */
3678 if (hpos
< maxendcol
)
3680 int hpos1
= hpos
+ 1;
3681 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0,
3682 min (hpos1
, maxendcol
), maxendcol
);
3686 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
3687 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
3689 /* Fill out the line with spaces. */
3690 if (maxendcol
> hpos
)
3691 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0, maxendcol
, maxendcol
);
3693 /* Clear the rest of the lines allocated to the menu bar. */
3695 while (vpos
< FRAME_MENU_BAR_LINES (f
))
3696 get_display_line (f
, vpos
++, 0);
3699 /* Display the mode line for window w */
3702 display_mode_line (w
)
3705 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
3706 register int left
= WINDOW_LEFT_MARGIN (w
);
3707 register int right
= WINDOW_RIGHT_MARGIN (w
);
3708 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3710 line_number_displayed
= 0;
3711 w
->column_number_displayed
= Qnil
;
3713 get_display_line (f
, vpos
, left
);
3715 /* Temporarily make frame F's kboard the current kboard
3716 so that kboard-local variables in the mode_line_format
3717 will get the right values. */
3718 push_frame_kboard (f
);
3720 display_mode_element (w
, vpos
, left
, 0, right
, right
,
3721 current_buffer
->mode_line_format
);
3723 pop_frame_kboard ();
3725 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
3727 /* Put the mode line in inverse video.
3728 Use faces if possible, since that lets us handle
3729 partial-width windows and avoid inverting the scroll bar columns. */
3731 if (! FRAME_TERMCAP_P (f
) && mode_line_inverse_video
)
3733 /* For a partial width window, explicitly set face of each glyph. */
3735 unsigned int padding
;
3736 GLYPH
*ptr
= FRAME_DESIRED_GLYPHS (f
)->glyphs
[vpos
];
3737 for (i
= left
; i
< right
; ++i
)
3739 padding
= ptr
[i
] & GLYPH_MASK_PADDING
;
3740 ptr
[i
] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr
[i
]), 1) | padding
;
3746 /* Make the mode line inverse video if the entire line
3747 is made of mode lines.
3748 I.e. if this window is full width,
3749 or if it is the child of a full width window
3750 (which implies that that window is split side-by-side
3751 and the rest of this line is mode lines of the sibling windows). */
3752 if (WINDOW_FULL_WIDTH_P (w
)
3753 || WINDOW_FULL_WIDTH_P (XWINDOW (w
->parent
)))
3754 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
3757 /* Contribute ELT to the mode line for window W.
3758 How it translates into text depends on its data type.
3760 VPOS is the position of the mode line being displayed.
3762 HPOS is the position (absolute on frame) where this element's text
3763 should start. The output is truncated automatically at the right
3766 DEPTH is the depth in recursion. It is used to prevent
3767 infinite recursion here.
3769 MINENDCOL is the hpos before which the element may not end.
3770 The element is padded at the right with spaces if nec
3771 to reach this column.
3773 MAXENDCOL is the hpos past which this element may not extend.
3774 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
3775 (This is necessary to make nested padding and truncation work.)
3777 Returns the hpos of the end of the text generated by ELT.
3778 The next element will receive that value as its HPOS arg,
3779 so as to concatenate the elements. */
3782 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
3784 register int vpos
, hpos
;
3787 register int maxendcol
;
3788 register Lisp_Object elt
;
3796 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
3800 /* A string: output it and check for %-constructs within it. */
3801 register unsigned char c
;
3802 register unsigned char *this = XSTRING (elt
)->data
;
3804 while (hpos
< maxendcol
&& *this)
3806 unsigned char *last
= this;
3807 while ((c
= *this++) != '\0' && c
!= '%')
3809 if (this - 1 != last
)
3811 register int lim
= --this - last
+ hpos
;
3812 if (frame_title_ptr
)
3813 hpos
= store_frame_title (last
, hpos
, min (lim
, maxendcol
));
3815 hpos
= display_string (w
, vpos
, last
, -1, hpos
, 0, 1,
3816 hpos
, min (lim
, maxendcol
));
3820 register int minendcol
;
3821 register int spec_width
= 0;
3823 /* We can't allow -ve args due to the "%-" construct */
3824 /* Argument specifies minwidth but not maxwidth
3825 (maxwidth can be specified by
3826 (<negative-number> . <stuff>) mode-line elements) */
3828 while ((c
= *this++) >= '0' && c
<= '9')
3830 spec_width
= spec_width
* 10 + (c
- '0');
3833 minendcol
= hpos
+ spec_width
;
3834 if (minendcol
> maxendcol
)
3836 spec_width
= maxendcol
- hpos
;
3837 minendcol
= maxendcol
;
3841 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
3842 spec_width
, maxendcol
,
3843 Vglobal_mode_string
);
3846 char *spec
= decode_mode_spec (w
, c
, spec_width
,
3848 if (frame_title_ptr
)
3849 hpos
= store_frame_title (spec
, minendcol
, maxendcol
);
3851 hpos
= display_string (w
, vpos
, spec
, -1,
3853 minendcol
, maxendcol
);
3861 /* A symbol: process the value of the symbol recursively
3862 as if it appeared here directly. Avoid error if symbol void.
3863 Special case: if value of symbol is a string, output the string
3866 register Lisp_Object tem
;
3867 tem
= Fboundp (elt
);
3870 tem
= Fsymbol_value (elt
);
3871 /* If value is a string, output that string literally:
3872 don't check for % within it. */
3875 if (frame_title_ptr
)
3876 hpos
= store_frame_title (XSTRING (tem
)->data
,
3877 minendcol
, maxendcol
);
3879 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
3880 XSTRING (tem
)->size
,
3881 hpos
, 0, 1, minendcol
, maxendcol
);
3883 /* Give up right away for nil or t. */
3884 else if (!EQ (tem
, elt
))
3885 { elt
= tem
; goto tail_recurse
; }
3892 register Lisp_Object car
, tem
;
3894 /* A cons cell: three distinct cases.
3895 If first element is a string or a cons, process all the elements
3896 and effectively concatenate them.
3897 If first element is a negative number, truncate displaying cdr to
3898 at most that many characters. If positive, pad (with spaces)
3899 to at least that many characters.
3900 If first element is a symbol, process the cadr or caddr recursively
3901 according to whether the symbol's value is non-nil or nil. */
3902 car
= XCONS (elt
)->car
;
3905 tem
= Fboundp (car
);
3906 elt
= XCONS (elt
)->cdr
;
3909 /* elt is now the cdr, and we know it is a cons cell.
3910 Use its car if CAR has a non-nil value. */
3913 tem
= Fsymbol_value (car
);
3915 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
3917 /* Symbol's value is nil (or symbol is unbound)
3918 Get the cddr of the original list
3919 and if possible find the caddr and use that. */
3920 elt
= XCONS (elt
)->cdr
;
3923 else if (!CONSP (elt
))
3925 elt
= XCONS (elt
)->car
;
3928 else if (INTEGERP (car
))
3930 register int lim
= XINT (car
);
3931 elt
= XCONS (elt
)->cdr
;
3933 /* Negative int means reduce maximum width.
3934 DO NOT change MINENDCOL here!
3935 (20 -10 . foo) should truncate foo to 10 col
3936 and then pad to 20. */
3937 maxendcol
= min (maxendcol
, hpos
- lim
);
3940 /* Padding specified. Don't let it be more than
3943 if (lim
> maxendcol
)
3945 /* If that's more padding than already wanted, queue it.
3946 But don't reduce padding already specified even if
3947 that is beyond the current truncation point. */
3948 if (lim
> minendcol
)
3953 else if (STRINGP (car
) || CONSP (car
))
3955 register int limit
= 50;
3956 /* LIMIT is to protect against circular lists. */
3957 while (CONSP (elt
) && --limit
> 0
3958 && hpos
< maxendcol
)
3960 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
3963 elt
= XCONS (elt
)->cdr
;
3971 if (frame_title_ptr
)
3972 hpos
= store_frame_title ("*invalid*", minendcol
, maxendcol
);
3974 hpos
= display_string (w
, vpos
, "*invalid*", -1, hpos
, 0, 1,
3975 minendcol
, maxendcol
);
3979 if (minendcol
> hpos
)
3980 if (frame_title_ptr
)
3981 hpos
= store_frame_title ("", minendcol
, maxendcol
);
3983 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 1, minendcol
, maxendcol
);
3987 /* Write a null-terminated, right justified decimal representation of
3988 the positive integer D to BUF using a minimal field width WIDTH. */
3991 pint2str (buf
, width
, d
)
3996 register char *p
= buf
;
4003 *p
++ = d
% 10 + '0';
4006 for (width
-= (int) (p
- buf
); width
> 0; --width
) *p
++ = ' ';
4016 /* Set a mnemonic character for CODING_SYSTEM (Lisp symbol) in BUF.
4017 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
4018 type of CODING_SYSTEM. Return updated pointer into BUF. */
4021 decode_mode_spec_coding (coding_system
, buf
, eol_flag
)
4022 Lisp_Object coding_system
;
4026 register Lisp_Object val
= coding_system
;
4028 if (NILP (val
)) /* Not yet decided. */
4031 if (eol_flag
) *buf
++ = eol_mnemonic_undecided
;
4035 while (!NILP (val
) && SYMBOLP (val
))
4036 val
= Fget (val
, Qcoding_system
);
4037 *buf
++ = XFASTINT (XVECTOR (val
)->contents
[1]);
4040 val
= Fget (coding_system
, Qeol_type
);
4042 if (NILP (val
)) /* Not yet decided. */
4043 *buf
++ = eol_mnemonic_undecided
;
4044 else if (VECTORP (val
)) /* Not yet decided. */
4045 *buf
++ = eol_mnemonic_undecided
;
4046 else /* INTEGERP (val) -- 1:LF, 2:CRLF, 3:CR */
4047 *buf
++ = (XFASTINT (val
) == 1
4049 : (XFASTINT (val
) == 2
4050 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
4056 /* Return a string for the output of a mode line %-spec for window W,
4057 generated by character C. SPEC_WIDTH is the field width when
4058 padding to the left (%c, %l). The value returned from this
4059 function will later be truncated to width MAXWIDTH. */
4061 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
4064 decode_mode_spec (w
, c
, spec_width
, maxwidth
)
4067 register int spec_width
;
4068 register int maxwidth
;
4071 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4072 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
4073 struct buffer
*b
= XBUFFER (w
->buffer
);
4076 if (maxwidth
> FRAME_WIDTH (f
))
4077 maxwidth
= FRAME_WIDTH (f
);
4082 if (!NILP (b
->read_only
))
4084 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4089 /* This differs from %* only for a modified read-only buffer. */
4090 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4092 if (!NILP (b
->read_only
))
4097 /* This differs from %* in ignoring read-only-ness. */
4098 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4110 if (command_loop_level
> 5)
4112 p
= decode_mode_spec_buf
;
4113 for (i
= 0; i
< command_loop_level
; i
++)
4116 return decode_mode_spec_buf
;
4124 if (command_loop_level
> 5)
4126 p
= decode_mode_spec_buf
;
4127 for (i
= 0; i
< command_loop_level
; i
++)
4130 return decode_mode_spec_buf
;
4138 if (maxwidth
< sizeof (lots_of_dashes
))
4139 return lots_of_dashes
;
4142 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
4146 return decode_mode_spec_buf
;
4152 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
4154 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
4155 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
4156 decode_mode_spec_buf
[maxwidth
] = '\0';
4157 return decode_mode_spec_buf
;
4164 int col
= current_column ();
4165 XSETFASTINT (w
->column_number_displayed
, col
);
4166 pint2str (decode_mode_spec_buf
, spec_width
, col
);
4167 return decode_mode_spec_buf
;
4171 /* %F displays the frame name. */
4172 if (!NILP (f
->title
))
4173 return (char *) XSTRING (f
->title
)->data
;
4174 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
4175 return (char *) XSTRING (f
->name
)->data
;
4183 else if (STRINGP (obj
) && XSTRING (obj
)->size
> maxwidth
)
4185 bcopy ("...", decode_mode_spec_buf
, 3);
4186 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
4187 decode_mode_spec_buf
+ 3, maxwidth
- 3);
4188 return decode_mode_spec_buf
;
4195 int startpos
= marker_position (w
->start
);
4196 int line
, linepos
, topline
;
4199 int height
= XFASTINT (w
->height
);
4201 /* If we decided that this buffer isn't suitable for line numbers,
4202 don't forget that too fast. */
4203 if (EQ (w
->base_line_pos
, w
->buffer
))
4205 /* But do forget it, if the window shows a different buffer now. */
4206 else if (BUFFERP (w
->base_line_pos
))
4207 w
->base_line_pos
= Qnil
;
4209 /* If the buffer is very big, don't waste time. */
4210 if (BUF_ZV (b
) - BUF_BEGV (b
) > line_number_display_limit
)
4212 w
->base_line_pos
= Qnil
;
4213 w
->base_line_number
= Qnil
;
4217 if (!NILP (w
->base_line_number
)
4218 && !NILP (w
->base_line_pos
)
4219 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
4221 line
= XFASTINT (w
->base_line_number
);
4222 linepos
= XFASTINT (w
->base_line_pos
);
4227 linepos
= BUF_BEGV (b
);
4230 /* Count lines from base line to window start position. */
4231 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
4233 topline
= nlines
+ line
;
4235 /* Determine a new base line, if the old one is too close
4236 or too far away, or if we did not have one.
4237 "Too close" means it's plausible a scroll-down would
4239 if (startpos
== BUF_BEGV (b
))
4241 XSETFASTINT (w
->base_line_number
, topline
);
4242 XSETFASTINT (w
->base_line_pos
, BUF_BEGV (b
));
4244 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
4245 || linepos
== BUF_BEGV (b
))
4247 int limit
= BUF_BEGV (b
);
4249 int distance
= (height
* 2 + 30) * 200;
4251 if (startpos
- distance
> limit
)
4252 limit
= startpos
- distance
;
4254 nlines
= display_count_lines (startpos
, limit
,
4257 /* If we couldn't find the lines we wanted within
4259 give up on line numbers for this window. */
4260 if (position
== startpos
- distance
)
4262 w
->base_line_pos
= w
->buffer
;
4263 w
->base_line_number
= Qnil
;
4267 XSETFASTINT (w
->base_line_number
, topline
- nlines
);
4268 XSETFASTINT (w
->base_line_pos
, position
);
4271 /* Now count lines from the start pos to point. */
4272 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
4274 /* Record that we did display the line number. */
4275 line_number_displayed
= 1;
4277 /* Make the string to show. */
4278 pint2str (decode_mode_spec_buf
, spec_width
, topline
+ nlines
);
4279 return decode_mode_spec_buf
;
4282 char* p
= decode_mode_spec_buf
;
4283 for (spec_width
-= 2; spec_width
> 0; --spec_width
) *p
++ = ' ';
4285 return decode_mode_spec_buf
;
4295 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
4301 int pos
= marker_position (w
->start
);
4302 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
4304 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
4306 if (pos
<= BUF_BEGV (b
))
4311 else if (pos
<= BUF_BEGV (b
))
4315 if (total
> 1000000)
4316 /* Do it differently for a large value, to avoid overflow. */
4317 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
4319 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
4320 /* We can't normally display a 3-digit number,
4321 so get us a 2-digit number that is close. */
4324 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
4325 return decode_mode_spec_buf
;
4329 /* Display percentage of size above the bottom of the screen. */
4332 int toppos
= marker_position (w
->start
);
4333 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
4334 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
4336 if (botpos
>= BUF_ZV (b
))
4338 if (toppos
<= BUF_BEGV (b
))
4345 if (total
> 1000000)
4346 /* Do it differently for a large value, to avoid overflow. */
4347 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
4349 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
4350 /* We can't normally display a 3-digit number,
4351 so get us a 2-digit number that is close. */
4354 if (toppos
<= BUF_BEGV (b
))
4355 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
4357 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
4358 return decode_mode_spec_buf
;
4363 /* status of process */
4364 obj
= Fget_buffer_process (w
->buffer
);
4366 return "no process";
4368 obj
= Fsymbol_name (Fprocess_status (obj
));
4372 case 't': /* indicate TEXT or BINARY */
4373 #ifdef MODE_LINE_BINARY_TEXT
4374 return MODE_LINE_BINARY_TEXT (b
);
4380 /* coding-system (not including end-of-line format) */
4382 /* coding-system (including end-of-line type) */
4384 int eol_flag
= (c
== 'Z');
4387 p
= decode_mode_spec_coding
4388 (find_symbol_value (Qbuffer_file_coding_system
),
4389 decode_mode_spec_buf
, eol_flag
);
4390 if (FRAME_TERMCAP_P (f
))
4392 p
= decode_mode_spec_coding (keyboard_coding
.symbol
, p
, eol_flag
);
4393 p
= decode_mode_spec_coding (terminal_coding
.symbol
, p
, eol_flag
);
4396 obj
= Fget_buffer_process (Fcurrent_buffer ());
4399 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
4401 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
4404 #endif /* subprocesses */
4406 return decode_mode_spec_buf
;
4411 return (char *) XSTRING (obj
)->data
;
4416 /* Search for COUNT instances of a line boundary, which means either a
4417 newline or (if selective display enabled) a carriage return.
4418 Start at START. If COUNT is negative, search backwards.
4420 If we find COUNT instances, set *SHORTAGE to zero, and return the
4421 position after the COUNTth match. Note that for reverse motion
4422 this is not the same as the usual convention for Emacs motion commands.
4424 If we don't find COUNT instances before reaching the end of the
4425 buffer (or the beginning, if scanning backwards), set *SHORTAGE to
4426 the number of line boundaries left unfound, and return the end of the
4427 buffer we bumped up against. */
4430 display_scan_buffer (start
, count
, shortage
)
4431 int *shortage
, start
;
4434 int limit
= ((count
> 0) ? ZV
- 1 : BEGV
);
4435 int direction
= ((count
> 0) ? 1 : -1);
4437 register unsigned char *cursor
;
4438 unsigned char *base
;
4440 register int ceiling
;
4441 register unsigned char *ceiling_addr
;
4443 /* If we are not in selective display mode,
4444 check only for newlines. */
4445 if (! (!NILP (current_buffer
->selective_display
)
4446 && !INTEGERP (current_buffer
->selective_display
)))
4447 return scan_buffer ('\n', start
, 0, count
, shortage
, 0);
4449 /* The code that follows is like scan_buffer
4450 but checks for either newline or carriage return. */
4456 while (start
!= limit
+ 1)
4458 ceiling
= BUFFER_CEILING_OF (start
);
4459 ceiling
= min (limit
, ceiling
);
4460 ceiling_addr
= POS_ADDR (ceiling
) + 1;
4461 base
= (cursor
= POS_ADDR (start
));
4464 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
4466 if (cursor
!= ceiling_addr
)
4471 return (start
+ cursor
- base
+ 1);
4474 if (++cursor
== ceiling_addr
)
4480 start
+= cursor
- base
;
4484 start
--; /* first character we scan */
4485 while (start
> limit
- 1)
4486 { /* we WILL scan under start */
4487 ceiling
= BUFFER_FLOOR_OF (start
);
4488 ceiling
= max (limit
, ceiling
);
4489 ceiling_addr
= POS_ADDR (ceiling
) - 1;
4490 base
= (cursor
= POS_ADDR (start
));
4494 while (--cursor
!= ceiling_addr
4495 && *cursor
!= '\n' && *cursor
!= 015)
4497 if (cursor
!= ceiling_addr
)
4502 return (start
+ cursor
- base
+ 1);
4508 start
+= cursor
- base
;
4513 *shortage
= count
* direction
;
4514 return (start
+ ((direction
== 1 ? 0 : 1)));
4517 /* Count up to N lines starting from FROM.
4518 But don't go beyond LIMIT.
4519 Return the number of lines thus found (always positive).
4520 Store the position after what was found into *POS_PTR. */
4523 display_count_lines (from
, limit
, n
, pos_ptr
)
4536 *pos_ptr
= display_scan_buffer (from
, n
, &shortage
);
4542 /* When scanning backwards, scan_buffer stops *after* the last newline
4543 it finds, but does count it. Compensate for that. */
4544 return - n
- shortage
- (*pos_ptr
!= limit
);
4545 return n
- shortage
;
4548 /* Display STRING on one line of window W, starting at HPOS.
4549 Display at position VPOS. Caller should have done get_display_line.
4550 If VPOS == -1, display it as the current frame's title.
4551 LENGTH is the length of STRING, or -1 meaning STRING is null-terminated.
4553 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
4555 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
4556 MAXCOL is the last column ok to end at. Truncate here.
4557 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
4558 Both count from the left edge of the frame, as does HPOS.
4559 The right edge of W is an implicit maximum.
4560 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
4562 OBEY_WINDOW_WIDTH says to put spaces or vertical bars
4563 at the place where the current window ends in this line
4564 and not display anything beyond there. Otherwise, only MAXCOL
4565 controls where to stop output.
4567 Returns ending hpos. */
4570 display_string (w
, vpos
, string
, length
, hpos
, truncate
,
4571 obey_window_width
, mincol
, maxcol
)
4573 unsigned char *string
;
4577 int obey_window_width
;
4583 int hscroll
= XINT (w
->hscroll
);
4584 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
4585 register GLYPH
*start
;
4586 register GLYPH
*end
;
4587 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4588 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
4589 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
4590 int window_width
= XFASTINT (w
->width
);
4591 /* If 1, we must display multibyte characters. */
4592 int multibyte
= !NILP (XBUFFER (w
->buffer
)->enable_multibyte_characters
);
4594 /* Use the standard display table, not the window's display table.
4595 We don't want the mode line in rot13. */
4596 register struct Lisp_Char_Table
*dp
= 0;
4599 if (DISP_TABLE_P (Vstandard_display_table
))
4600 dp
= XCHAR_TABLE (Vstandard_display_table
);
4602 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
4605 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
4607 if (obey_window_width
)
4609 end
= start
+ window_width
- (truncate
!= 0);
4611 if (!WINDOW_RIGHTMOST_P (w
))
4613 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4617 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
4620 else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4625 if (! obey_window_width
4626 || (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
))
4627 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
4629 /* Store 0 in charstart for these columns. */
4630 for (i
= (hpos
>= 0 ? hpos
: 0); i
< end
- p1start
+ hpos
; i
++)
4631 desired_glyphs
->charstarts
[vpos
][i
] = 0;
4633 if (maxcol
>= 0 && mincol
> maxcol
)
4637 /* We need this value for multibyte characters. */
4638 length
= strlen (string
);
4640 /* We set truncated to 1 if we get stopped by trying to pass END
4641 (that is, trying to pass MAXCOL.) */
4650 c
= STRING_CHAR_AND_LENGTH (string
, length
, len
);
4652 c
= *string
, len
= 1;
4654 string
+= len
, length
-= len
;
4662 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
4664 p1
= copy_part_of_rope (f
, p1
, start
,
4665 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
4666 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
4669 else if (c
>= 040 && c
< 0177)
4679 if (p1
>= start
&& p1
< end
)
4683 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
4685 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
4689 (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
4690 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp
)))
4691 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
4694 if (p1
>= start
&& p1
< end
)
4700 /* C is a control character or a binary byte data. */
4703 (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
4704 && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp
)))
4705 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
4708 if (p1
>= start
&& p1
< end
)
4709 *p1
= (c
>> 6) + '0';
4711 if (p1
>= start
&& p1
< end
)
4712 *p1
= (7 & (c
>> 3)) + '0';
4714 if (p1
>= start
&& p1
< end
)
4715 *p1
= (7 & c
) + '0';
4720 /* C is a multibyte character. */
4721 int charset
= CHAR_CHARSET (c
);
4722 int columns
= (charset
== CHARSET_COMPOSITION
4723 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
4724 : CHARSET_WIDTH (charset
));
4728 /* Since we can't show the left part of C, fill all
4729 columns with spaces. */
4730 columns
-= start
- p1
;
4739 else if (p1
+ columns
> end
)
4741 /* Since we can't show the right part of C, fill all
4742 columns with TRUNCATE if TRUNCATE is specified. */
4746 *p1
++ = fix_glyph (f
, truncate
, 0);
4747 /* And tell the line is truncated. */
4754 /* We can show the whole glyph of C. */
4757 *p1
++ = c
| GLYPH_MASK_PADDING
;
4765 if (truncate
) *p1
++ = fix_glyph (f
, truncate
, 0);
4767 else if (mincol
>= 0)
4769 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
4775 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
4777 if (len
> desired_glyphs
->used
[vpos
])
4778 desired_glyphs
->used
[vpos
] = len
;
4779 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
4785 /* This is like a combination of memq and assq.
4786 Return 1 if PROPVAL appears as an element of LIST
4787 or as the car of an element of LIST.
4788 If PROPVAL is a list, compare each element against LIST
4789 in that way, and return 1 if any element of PROPVAL is found in LIST.
4791 This function cannot quit. */
4794 invisible_p (propval
, list
)
4795 register Lisp_Object propval
;
4798 register Lisp_Object tail
, proptail
;
4799 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4801 register Lisp_Object tem
;
4802 tem
= XCONS (tail
)->car
;
4803 if (EQ (propval
, tem
))
4805 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
4808 if (CONSP (propval
))
4809 for (proptail
= propval
; CONSP (proptail
);
4810 proptail
= XCONS (proptail
)->cdr
)
4812 Lisp_Object propelt
;
4813 propelt
= XCONS (proptail
)->car
;
4814 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4816 register Lisp_Object tem
;
4817 tem
= XCONS (tail
)->car
;
4818 if (EQ (propelt
, tem
))
4820 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
4827 /* Return 1 if PROPVAL appears as the car of an element of LIST
4828 and the cdr of that element is non-nil.
4829 If PROPVAL is a list, check each element of PROPVAL in that way,
4830 and the first time some element is found,
4831 return 1 if the cdr of that element is non-nil.
4833 This function cannot quit. */
4836 invisible_ellipsis_p (propval
, list
)
4837 register Lisp_Object propval
;
4840 register Lisp_Object tail
, proptail
;
4841 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4843 register Lisp_Object tem
;
4844 tem
= XCONS (tail
)->car
;
4845 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
4846 return ! NILP (XCONS (tem
)->cdr
);
4848 if (CONSP (propval
))
4849 for (proptail
= propval
; CONSP (proptail
);
4850 proptail
= XCONS (proptail
)->cdr
)
4852 Lisp_Object propelt
;
4853 propelt
= XCONS (proptail
)->car
;
4854 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4856 register Lisp_Object tem
;
4857 tem
= XCONS (tail
)->car
;
4858 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
4859 return ! NILP (XCONS (tem
)->cdr
);
4868 staticpro (&Qmenu_bar_update_hook
);
4869 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
4871 staticpro (&Qoverriding_terminal_local_map
);
4872 Qoverriding_terminal_local_map
= intern ("overriding-terminal-local-map");
4874 staticpro (&Qoverriding_local_map
);
4875 Qoverriding_local_map
= intern ("overriding-local-map");
4877 staticpro (&Qwindow_scroll_functions
);
4878 Qwindow_scroll_functions
= intern ("window-scroll-functions");
4880 staticpro (&Qredisplay_end_trigger_functions
);
4881 Qredisplay_end_trigger_functions
= intern ("redisplay-end-trigger-functions");
4883 staticpro (&last_arrow_position
);
4884 staticpro (&last_arrow_string
);
4885 last_arrow_position
= Qnil
;
4886 last_arrow_string
= Qnil
;
4888 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
4889 "String (or mode line construct) included (normally) in `mode-line-format'.");
4890 Vglobal_mode_string
= Qnil
;
4892 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
4893 "Marker for where to display an arrow on top of the buffer text.\n\
4894 This must be the beginning of a line in order to work.\n\
4895 See also `overlay-arrow-string'.");
4896 Voverlay_arrow_position
= Qnil
;
4898 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
4899 "String to display as an arrow. See also `overlay-arrow-position'.");
4900 Voverlay_arrow_string
= Qnil
;
4902 DEFVAR_INT ("scroll-step", &scroll_step
,
4903 "*The number of lines to try scrolling a window by when point moves out.\n\
4904 If that fails to bring point back on frame, point is centered instead.\n\
4905 If this is zero, point is always centered after it moves off frame.");
4907 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively
,
4908 "*Scroll up to this many lines, to bring point back on screen.");
4909 scroll_conservatively
= 0;
4911 DEFVAR_INT ("scroll-margin", &scroll_margin
,
4912 "*Number of lines of margin at the top and bottom of a window.\n\
4913 Recenter the window whenever point gets within this many lines\n\
4914 of the top or bottom of the window.");
4917 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
4919 DEFVAR_BOOL ("truncate-partial-width-windows",
4920 &truncate_partial_width_windows
,
4921 "*Non-nil means truncate lines in all windows less than full frame wide.");
4922 truncate_partial_width_windows
= 1;
4924 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
4925 "*Non-nil means use inverse video for the mode line.");
4926 mode_line_inverse_video
= 1;
4928 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
4929 "*Maximum buffer size for which line number should be displayed.");
4930 line_number_display_limit
= 1000000;
4932 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
4933 "*Non-nil means highlight region even in nonselected windows.");
4934 highlight_nonselected_windows
= 0;
4936 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
4937 "Non-nil if more than one frame is visible on this display.\n\
4938 Minibuffer-only frames don't count, but iconified frames do.\n\
4939 This variable is not guaranteed to be accurate except while processing\n\
4940 `frame-title-format' and `icon-title-format'.");
4942 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
4943 "Template for displaying the titlebar of visible frames.\n\
4944 \(Assuming the window manager supports this feature.)\n\
4945 This variable has the same structure as `mode-line-format' (which see),\n\
4946 and is used only on frames for which no explicit name has been set\n\
4947 \(see `modify-frame-parameters').");
4948 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
4949 "Template for displaying the titlebar of an iconified frame.\n\
4950 \(Assuming the window manager supports this feature.)\n\
4951 This variable has the same structure as `mode-line-format' (which see),\n\
4952 and is used only on frames for which no explicit name has been set\n\
4953 \(see `modify-frame-parameters').");
4955 = Vframe_title_format
4956 = Fcons (intern ("multiple-frames"),
4957 Fcons (build_string ("%b"),
4958 Fcons (Fcons (build_string (""),
4959 Fcons (intern ("invocation-name"),
4960 Fcons (build_string ("@"),
4961 Fcons (intern ("system-name"),
4965 DEFVAR_LISP ("message-log-max", &Vmessage_log_max
,
4966 "Maximum number of lines to keep in the message log buffer.\n\
4967 If nil, disable message logging. If t, log messages but don't truncate\n\
4968 the buffer when it becomes large.");
4969 XSETFASTINT (Vmessage_log_max
, 50);
4971 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions
,
4972 "Functions called before redisplay, if window sizes have changed.\n\
4973 The value should be a list of functions that take one argument.\n\
4974 Just before redisplay, for each frame, if any of its windows have changed\n\
4975 size since the last redisplay, or have been split or deleted,\n\
4976 all the functions in the list are called, with the frame as argument.");
4977 Vwindow_size_change_functions
= Qnil
;
4979 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions
,
4980 "List of Functions to call before redisplaying a window with scrolling.\n\
4981 Each function is called with two arguments, the window\n\
4982 and its new display-start position. Note that the value of `window-end'\n\
4983 is not valid when these functions are called.");
4984 Vwindow_scroll_functions
= Qnil
;
4987 /* initialize the window system */
4990 Lisp_Object root_window
;
4991 #ifndef COMPILER_REGISTER_BUG
4993 #endif /* COMPILER_REGISTER_BUG */
4994 struct window
*mini_w
;
4996 this_line_bufpos
= 0;
4998 mini_w
= XWINDOW (minibuf_window
);
4999 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
5001 echo_area_glyphs
= 0;
5002 previous_echo_glyphs
= 0;
5004 if (!noninteractive
)
5006 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
5007 XSETFASTINT (XWINDOW (root_window
)->top
, 0);
5008 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
5009 XSETFASTINT (mini_w
->top
, FRAME_HEIGHT (f
) - 1);
5010 set_window_height (minibuf_window
, 1, 0);
5012 XSETFASTINT (XWINDOW (root_window
)->width
, FRAME_WIDTH (f
));
5013 XSETFASTINT (mini_w
->width
, FRAME_WIDTH (f
));