1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 /*#include <ctype.h>*/
31 #include "dispextern.h"
38 #include "termhooks.h"
39 #include "intervals.h"
44 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
45 extern void set_frame_menubar ();
46 extern int pending_menu_activation
;
49 extern int interrupt_input
;
50 extern int command_loop_level
;
52 extern int minibuffer_auto_raise
;
54 extern Lisp_Object Qface
;
56 extern Lisp_Object Voverriding_local_map
;
57 extern Lisp_Object Voverriding_local_map_menu_flag
;
59 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
60 Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
61 Lisp_Object Qredisplay_end_trigger_functions
;
63 /* Nonzero means print newline to stdout before next minibuffer message. */
65 int noninteractive_need_newline
;
67 /* Nonzero means print newline to message log before next message. */
69 static int message_log_need_newline
;
71 #define min(a, b) ((a) < (b) ? (a) : (b))
72 #define max(a, b) ((a) > (b) ? (a) : (b))
73 #define minmax(floor, val, ceil) \
74 ((val) < (floor) ? (floor) : (val) > (ceil) ? (ceil) : (val))
76 /* The buffer position of the first character appearing
77 entirely or partially on the current frame line.
78 Or zero, which disables the optimization for the current frame line. */
79 static int this_line_bufpos
;
81 /* Number of characters past the end of this line,
82 including the terminating newline */
83 static int this_line_endpos
;
85 /* The vertical position of this frame line. */
86 static int this_line_vpos
;
88 /* Hpos value for start of display on this frame line.
89 Usually zero, but negative if first character really began
91 static int this_line_start_hpos
;
93 /* Buffer that this_line variables are describing. */
94 static struct buffer
*this_line_buffer
;
96 /* Value of echo_area_glyphs when it was last acted on.
97 If this is nonzero, there is a message on the frame
98 in the minibuffer and it should be erased as soon
99 as it is no longer requested to appear. */
100 char *previous_echo_glyphs
;
102 /* Nonzero means truncate lines in all windows less wide than the frame */
103 int truncate_partial_width_windows
;
105 /* Nonzero means we have more than one non-minibuffer-only frame.
106 Not guaranteed to be accurate except while parsing frame-title-format. */
109 Lisp_Object Vglobal_mode_string
;
111 /* Marker for where to display an arrow on top of the buffer text. */
112 Lisp_Object Voverlay_arrow_position
;
114 /* String to display for the arrow. */
115 Lisp_Object Voverlay_arrow_string
;
117 /* Values of those variables at last redisplay.
118 However, if Voverlay_arrow_position is a marker,
119 last_arrow_position is its numerical position. */
120 static Lisp_Object last_arrow_position
, last_arrow_string
;
122 /* Like mode-line-format, but for the titlebar on a visible frame. */
123 Lisp_Object Vframe_title_format
;
125 /* Like mode-line-format, but for the titlebar on an iconified frame. */
126 Lisp_Object Vicon_title_format
;
128 /* List of functions to call when a window's size changes. These
129 functions get one arg, a frame on which one or more windows' sizes
131 static Lisp_Object Vwindow_size_change_functions
;
133 Lisp_Object Qmenu_bar_update_hook
;
135 /* Nonzero if overlay arrow has been displayed once in this window. */
136 static int overlay_arrow_seen
;
138 /* Nonzero if visible end of buffer has already been displayed once
139 in this window. (We need this variable in case there are overlay
140 strings that get displayed there.) */
141 static int zv_strings_seen
;
143 /* Nonzero means highlight the region even in nonselected windows. */
144 static int highlight_nonselected_windows
;
146 /* If cursor motion alone moves point off frame,
147 Try scrolling this many lines up or down if that will bring it back. */
148 static int scroll_step
;
150 /* Non-0 means scroll just far enough to bring point back on the screen,
152 static int scroll_conservatively
;
154 /* Recenter the window whenever point gets within this many lines
155 of the top or bottom of the window. */
158 /* Number of characters of overlap to show,
159 when scrolling a one-line window such as a minibuffer. */
160 static int minibuffer_scroll_overlap
;
162 /* Nonzero if try_window_id has made blank lines at window bottom
163 since the last redisplay that paused */
164 static int blank_end_of_window
;
166 /* Number of windows showing the buffer of the selected window
167 (or another buffer with the same base buffer).
168 keyboard.c refers to this. */
171 /* display_text_line sets these to the frame position (origin 0) of point,
172 whether the window is selected or not.
173 Set one to -1 first to determine whether point was found afterwards. */
175 static int cursor_vpos
;
176 static int cursor_hpos
;
178 static int debug_end_pos
;
180 /* Nonzero means display mode line highlighted */
181 int mode_line_inverse_video
;
183 static void redisplay_internal ();
184 static int message_log_check_duplicate ();
185 static void echo_area_display ();
186 void mark_window_display_accurate ();
187 static void redisplay_windows ();
188 static void redisplay_window ();
189 static void update_menu_bar ();
190 static void try_window ();
191 static int try_window_id ();
192 static struct position
*display_text_line ();
193 static void display_mode_line ();
194 static int display_mode_element ();
195 static char *decode_mode_spec ();
196 static int display_string ();
197 static void display_menu_bar ();
198 static int display_count_lines ();
200 /* Prompt to display in front of the minibuffer contents */
201 Lisp_Object minibuf_prompt
;
203 /* Width in columns of current minibuffer prompt. */
204 int minibuf_prompt_width
;
206 /* Message to display instead of minibuffer contents
207 This is what the functions error and message make,
208 and command echoing uses it as well.
209 It overrides the minibuf_prompt as well as the buffer. */
210 char *echo_area_glyphs
;
212 /* This is the length of the message in echo_area_glyphs. */
213 int echo_area_glyphs_length
;
215 /* This is the window where the echo area message was displayed.
216 It is always a minibuffer window, but it may not be the
217 same window currently active as a minibuffer. */
218 Lisp_Object echo_area_window
;
220 /* Nonzero means multibyte characters were enabled when the echo area
221 message was specified. */
222 int message_enable_multibyte
;
224 /* true iff we should redraw the mode lines on the next redisplay */
225 int update_mode_lines
;
227 /* Smallest number of characters before the gap
228 at any time since last redisplay that finished.
229 Valid for current buffer when try_window_id can be called. */
232 /* Smallest number of characters after the gap
233 at any time since last redisplay that finished.
234 Valid for current buffer when try_window_id can be called. */
237 /* MODIFF as of last redisplay that finished;
238 if it matches MODIFF, and overlay_unchanged_modified
239 matches OVERLAY_MODIFF, that means beg_unchanged and end_unchanged
240 contain no useful information */
241 int unchanged_modified
;
243 /* OVERLAY_MODIFF as of last redisplay that finished. */
244 int overlay_unchanged_modified
;
246 /* Nonzero if window sizes or contents have changed
247 since last redisplay that finished */
248 int windows_or_buffers_changed
;
250 /* Nonzero after display_mode_line if %l was used
251 and it displayed a line number. */
252 int line_number_displayed
;
254 /* Maximum buffer size for which to display line numbers. */
255 static int line_number_display_limit
;
257 /* Number of lines to keep in the message log buffer.
258 t means infinite. nil means don't log at all. */
259 Lisp_Object Vmessage_log_max
;
261 #define COERCE_MARKER(X) \
262 (MARKERP ((X)) ? Fmarker_position (X) : (X))
264 static int pos_tab_offset
P_ ((struct window
*, int, int));
266 /* Output a newline in the *Messages* buffer if "needs" one. */
269 message_log_maybe_newline ()
271 if (message_log_need_newline
)
272 message_dolog ("", 0, 1, 0);
276 /* Add a string to the message log, optionally terminated with a newline.
277 This function calls low-level routines in order to bypass text property
278 hooks, etc. which might not be safe to run.
279 MULTIBYTE, if nonzero, means interpret the contents of M as multibyte. */
282 message_dolog (m
, len
, nlflag
, multibyte
)
284 int len
, nlflag
, multibyte
;
286 if (!NILP (Vmessage_log_max
))
288 struct buffer
*oldbuf
;
289 Lisp_Object oldpoint
, oldbegv
, oldzv
;
290 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
291 int point_at_end
= 0;
293 Lisp_Object old_deactivate_mark
;
295 old_deactivate_mark
= Vdeactivate_mark
;
296 oldbuf
= current_buffer
;
297 Fset_buffer (Fget_buffer_create (build_string ("*Messages*")));
298 current_buffer
->undo_list
= Qt
;
300 oldpoint
= Fpoint_marker ();
301 oldbegv
= Fpoint_min_marker ();
302 oldzv
= Fpoint_max_marker ();
310 BEGV_BYTE
= BEG_BYTE
;
313 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
315 /* Insert the string--maybe converting multibyte to single byte
316 or vice versa, so that all the text fits the buffer. */
318 && NILP (current_buffer
->enable_multibyte_characters
))
320 int c
, i
= 0, nbytes
;
321 /* Convert a multibyte string to single-byte
322 for the *Message* buffer. */
325 c
= STRING_CHAR (m
+ i
, len
- i
);
326 i
+= XFASTINT (Fchar_bytes (make_number (c
)));
327 /* Truncate the character to its last byte--we can only hope
328 the user is happy with the character he gets,
329 since if it isn't right, there is no way to do it right. */
335 && ! NILP (current_buffer
->enable_multibyte_characters
))
338 unsigned char *msg
= (unsigned char *) m
;
339 /* Convert a single-byte string to multibyte
340 for the *Message* buffer. */
343 int c
= unibyte_char_to_multibyte (msg
[i
++]);
348 insert_1 (m
, len
, 1, 0, 0);
352 int this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
, dup
;
353 insert_1 ("\n", 1, 1, 0, 0);
355 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
357 this_bol_byte
= PT_BYTE
;
361 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
363 prev_bol_byte
= PT_BYTE
;
365 dup
= message_log_check_duplicate (prev_bol
, prev_bol_byte
,
366 this_bol
, this_bol_byte
);
369 del_range_both (prev_bol
, prev_bol_byte
,
370 this_bol
, this_bol_byte
, 0);
376 /* If you change this format, don't forget to also
377 change message_log_check_duplicate. */
378 sprintf (dupstr
, " [%d times]", dup
);
379 duplen
= strlen (dupstr
);
380 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
381 insert_1 (dupstr
, duplen
, 1, 0, 1);
386 if (NATNUMP (Vmessage_log_max
))
388 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
389 -XFASTINT (Vmessage_log_max
) - 1, 0);
390 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
393 BEGV
= XMARKER (oldbegv
)->charpos
;
394 BEGV_BYTE
= marker_byte_position (oldbegv
);
403 ZV
= XMARKER (oldzv
)->charpos
;
404 ZV_BYTE
= marker_byte_position (oldzv
);
408 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
410 Fgoto_char (oldpoint
);
412 free_marker (oldpoint
);
413 free_marker (oldbegv
);
416 set_buffer_internal (oldbuf
);
417 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
418 message_log_need_newline
= !nlflag
;
419 Vdeactivate_mark
= old_deactivate_mark
;
423 /* We are at the end of the buffer after just having inserted a newline.
424 (Note: We depend on the fact we won't be crossing the gap.)
425 Check to see if the most recent message looks a lot like the previous one.
426 Return 0 if different, 1 if the new one should just replace it, or a
427 value N > 1 if we should also append " [N times]". */
430 message_log_check_duplicate (prev_bol
, prev_bol_byte
, this_bol
, this_bol_byte
)
431 int prev_bol
, this_bol
;
432 int prev_bol_byte
, this_bol_byte
;
435 int len
= Z
- 1 - this_bol
;
437 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
438 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
440 for (i
= 0; i
< len
; i
++)
442 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.'
451 if (*p1
++ == ' ' && *p1
++ == '[')
454 while (*p1
>= '0' && *p1
<= '9')
455 n
= n
* 10 + *p1
++ - '0';
456 if (strncmp (p1
, " times]\n", 8) == 0)
462 /* Display an echo area message M with a specified length of LEN chars.
463 The string may include null characters. 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. */
473 message2 (m
, len
, multibyte
)
478 /* First flush out any partial line written with print. */
479 message_log_maybe_newline ();
481 message_dolog (m
, len
, 1, multibyte
);
482 message2_nolog (m
, len
, multibyte
);
486 /* The non-logging counterpart of message2. */
489 message2_nolog (m
, len
, multibyte
)
493 message_enable_multibyte
= multibyte
;
497 if (noninteractive_need_newline
)
499 noninteractive_need_newline
= 0;
501 fwrite (m
, len
, 1, stderr
);
502 if (cursor_in_echo_area
== 0)
503 fprintf (stderr
, "\n");
506 /* A null message buffer means that the frame hasn't really been
507 initialized yet. Error messages get reported properly by
508 cmd_error, so this must be just an informative message; toss it. */
509 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
511 Lisp_Object mini_window
;
514 /* Get the frame containing the minibuffer
515 that the selected frame is using. */
516 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
517 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
519 FRAME_SAMPLE_VISIBILITY (f
);
520 if (FRAME_VISIBLE_P (selected_frame
)
521 && ! FRAME_VISIBLE_P (f
))
522 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
526 echo_area_glyphs
= m
;
527 echo_area_glyphs_length
= len
;
529 if (minibuffer_auto_raise
)
530 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
533 echo_area_glyphs
= previous_echo_glyphs
= 0;
535 do_pending_window_change ();
536 echo_area_display ();
537 update_frame (f
, 1, 1);
538 do_pending_window_change ();
539 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
540 (*frame_up_to_date_hook
) (f
);
544 /* Display in echo area the null-terminated ASCII-only string M.
545 If M is 0, clear out any existing message,
546 and let the minibuffer text show through.
548 The string M must continue to exist until after the echo area
549 gets cleared or some other message gets displayed there.
551 Do not pass text that is stored in a Lisp string.
552 Do not pass text in a buffer that was alloca'd. */
558 message2 (m
, (m
? strlen (m
) : 0), 0);
565 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
568 /* Display a message M which contains a single %s
569 which gets replaced with STRING. */
572 message_with_string (m
, string
, log
)
581 if (noninteractive_need_newline
)
583 noninteractive_need_newline
= 0;
584 fprintf (stderr
, m
, XSTRING (string
)->data
);
585 if (cursor_in_echo_area
== 0)
586 fprintf (stderr
, "\n");
590 else if (INTERACTIVE
)
592 /* The frame whose minibuffer we're going to display the message on.
593 It may be larger than the selected frame, so we need
594 to use its buffer, not the selected frame's buffer. */
595 Lisp_Object mini_window
;
598 /* Get the frame containing the minibuffer
599 that the selected frame is using. */
600 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
601 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
603 /* A null message buffer means that the frame hasn't really been
604 initialized yet. Error messages get reported properly by
605 cmd_error, so this must be just an informative message; toss it. */
606 if (FRAME_MESSAGE_BUF (f
))
610 a
[0] = (char *) XSTRING (string
)->data
;
612 len
= doprnt (FRAME_MESSAGE_BUF (f
),
613 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
616 message2 (FRAME_MESSAGE_BUF (f
), len
,
617 STRING_MULTIBYTE (string
));
619 message2_nolog (FRAME_MESSAGE_BUF (f
), len
,
620 STRING_MULTIBYTE (string
));
622 /* Print should start at the beginning of the message
624 message_buf_print
= 0;
629 /* Truncate what will be displayed in the echo area
630 the next time we display it--but don't redisplay it now. */
633 truncate_echo_area (len
)
636 /* A null message buffer means that the frame hasn't really been
637 initialized yet. Error messages get reported properly by
638 cmd_error, so this must be just an informative message; toss it. */
639 if (!noninteractive
&& INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
640 echo_area_glyphs_length
= len
;
643 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
644 zero if being used by message. */
645 int message_buf_print
;
647 /* Dump an informative message to the minibuf. If M is 0, clear out
648 any existing message, and let the minibuffer text show through. */
652 message (m
, a1
, a2
, a3
)
654 EMACS_INT a1
, a2
, a3
;
660 if (noninteractive_need_newline
)
662 noninteractive_need_newline
= 0;
663 fprintf (stderr
, m
, a1
, a2
, a3
);
664 if (cursor_in_echo_area
== 0)
665 fprintf (stderr
, "\n");
669 else if (INTERACTIVE
)
671 /* The frame whose minibuffer we're going to display the message on.
672 It may be larger than the selected frame, so we need
673 to use its buffer, not the selected frame's buffer. */
674 Lisp_Object mini_window
;
677 /* Get the frame containing the minibuffer
678 that the selected frame is using. */
679 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
680 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
682 /* A null message buffer means that the frame hasn't really been
683 initialized yet. Error messages get reported properly by
684 cmd_error, so this must be just an informative message; toss it. */
685 if (FRAME_MESSAGE_BUF (f
))
696 len
= doprnt (FRAME_MESSAGE_BUF (f
),
697 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
699 len
= doprnt (FRAME_MESSAGE_BUF (f
),
700 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3,
702 #endif /* NO_ARG_ARRAY */
704 message2 (FRAME_MESSAGE_BUF (f
), len
, 0);
709 /* Print should start at the beginning of the message
711 message_buf_print
= 0;
716 /* The non-logging version of message. */
718 message_nolog (m
, a1
, a2
, a3
)
720 EMACS_INT a1
, a2
, a3
;
722 Lisp_Object old_log_max
;
723 old_log_max
= Vmessage_log_max
;
724 Vmessage_log_max
= Qnil
;
725 message (m
, a1
, a2
, a3
);
726 Vmessage_log_max
= old_log_max
;
732 message2 (echo_area_glyphs
, echo_area_glyphs_length
,
733 ! NILP (current_buffer
->enable_multibyte_characters
));
741 Lisp_Object mini_window
;
743 /* Choose the minibuffer window for this display.
744 It is the minibuffer window used by the selected frame. */
745 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
746 /* This is the frame that window is in. */
747 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
749 if (! FRAME_VISIBLE_P (f
))
754 redraw_garbaged_frames ();
758 if (echo_area_glyphs
|| minibuf_level
== 0)
762 echo_area_window
= mini_window
;
764 vpos
= XFASTINT (XWINDOW (mini_window
)->top
);
765 get_display_line (f
, vpos
, 0);
767 /* Make sure the columns that overlap a left-hand scroll bar
769 for (i
= 0; i
< FRAME_LEFT_SCROLL_BAR_WIDTH (f
); i
++)
770 f
->desired_glyphs
->glyphs
[vpos
][i
] = SPACEGLYPH
;
772 display_string (XWINDOW (mini_window
), vpos
,
773 echo_area_glyphs
? echo_area_glyphs
: "",
774 echo_area_glyphs
? echo_area_glyphs_length
: -1,
775 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
777 FRAME_WIDTH (f
) + FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
778 message_enable_multibyte
);
780 #if 0 /* This just gets in the way. update_frame does the job. */
781 /* If desired cursor location is on this line, put it at end of text */
782 if (cursor_in_echo_area
)
783 FRAME_CURSOR_Y (f
) = vpos
;
784 if (FRAME_CURSOR_Y (f
) == vpos
)
785 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
788 /* Fill the rest of the minibuffer window with blank lines. */
793 i
< vpos
+ XFASTINT (XWINDOW (mini_window
)->height
); i
++)
795 get_display_line (f
, i
, 0);
796 /* We don't use FRAME_SCROLL_BAR_WIDTH (f) as the starting
797 hpos, because it is good to clear whatever is behind the
798 scroll bar. This does not affect the scroll bar itself. */
799 display_string (XWINDOW (mini_window
), i
,
802 0, FRAME_WIDTH (f
) + FRAME_SCROLL_BAR_WIDTH (f
),
807 else if (!EQ (mini_window
, selected_window
))
808 windows_or_buffers_changed
++;
810 if (EQ (mini_window
, selected_window
))
811 this_line_bufpos
= 0;
813 previous_echo_glyphs
= echo_area_glyphs
;
816 /* Update frame titles. */
818 #ifdef HAVE_WINDOW_SYSTEM
819 static char frame_title_buf
[512];
820 static char *frame_title_ptr
;
823 store_frame_title (str
, mincol
, maxcol
)
828 if (maxcol
< 0 || maxcol
>= sizeof(frame_title_buf
))
829 maxcol
= sizeof (frame_title_buf
);
830 limit
= &frame_title_buf
[maxcol
];
831 while (*str
!= '\0' && frame_title_ptr
< limit
)
832 *frame_title_ptr
++ = *str
++;
833 while (frame_title_ptr
< &frame_title_buf
[mincol
])
834 *frame_title_ptr
++ = ' ';
835 return frame_title_ptr
- frame_title_buf
;
839 x_consider_frame_title (frame
)
845 FRAME_PTR f
= XFRAME (frame
);
847 if (!(FRAME_WINDOW_P (f
) || FRAME_MINIBUF_ONLY_P (f
) || f
->explicit_name
))
850 /* Do we have more than one visible frame on this X display? */
854 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
856 FRAME_PTR tf
= XFRAME (XCONS (tail
)->car
);
858 if (tf
!= f
&& FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
859 && !FRAME_MINIBUF_ONLY_P (tf
)
860 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
864 multiple_frames
= CONSP (tail
);
867 obuf
= current_buffer
;
868 Fset_buffer (XWINDOW (f
->selected_window
)->buffer
);
869 fmt
= (FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
);
870 frame_title_ptr
= frame_title_buf
;
871 len
= display_mode_element (XWINDOW (f
->selected_window
), 0, 0, 0,
872 0, sizeof (frame_title_buf
), fmt
);
874 set_buffer_internal (obuf
);
875 /* Set the name only if it's changed. This avoids consing
876 in the common case where it hasn't. (If it turns out that we've
877 already wasted too much time by walking through the list with
878 display_mode_element, then we might need to optimize at a higher
880 if (! STRINGP (f
->name
) || STRING_BYTES (XSTRING (f
->name
)) != len
881 || bcmp (frame_title_buf
, XSTRING (f
->name
)->data
, len
) != 0)
882 x_implicitly_set_name (f
, make_string (frame_title_buf
, len
), Qnil
);
885 #define frame_title_ptr ((char *)0)
886 #define store_frame_title(str, mincol, maxcol) 0
889 /* Prepare for redisplay by updating menu-bar item lists when appropriate.
890 This can call eval. */
895 register struct window
*w
= XWINDOW (selected_window
);
897 struct gcpro gcpro1
, gcpro2
;
899 all_windows
= (update_mode_lines
|| buffer_shared
> 1
900 || windows_or_buffers_changed
);
902 /* Update all frame titles based on their buffer names, etc.
903 We do this before the menu bars so that the buffer-menu
904 will show the up-to-date frame titles.
906 This used to be done after the menu bars, for a reason that
907 was stated as follows but which I do not understand:
908 "We do this after the menu bars so that the frame will first
909 create its menu bar using the name `emacs' if no other name
910 has yet been specified."
911 I think that is no longer a concern. */
912 #ifdef HAVE_WINDOW_SYSTEM
913 if (windows_or_buffers_changed
|| update_mode_lines
)
915 Lisp_Object tail
, frame
;
917 FOR_EACH_FRAME (tail
, frame
)
918 if (FRAME_VISIBLE_P (XFRAME (frame
))
919 || FRAME_ICONIFIED_P (XFRAME (frame
)))
920 x_consider_frame_title (frame
);
924 /* Update the menu bar item lists, if appropriate.
925 This has to be done before any actual redisplay
926 or generation of display lines. */
929 Lisp_Object tail
, frame
;
930 int count
= specpdl_ptr
- specpdl
;
932 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
934 FOR_EACH_FRAME (tail
, frame
)
936 /* If a window on this frame changed size,
937 report that to the user and clear the size-change flag. */
938 if (FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)))
940 Lisp_Object functions
;
941 /* Clear flag first in case we get error below. */
942 FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)) = 0;
943 functions
= Vwindow_size_change_functions
;
944 GCPRO2 (tail
, functions
);
945 while (CONSP (functions
))
947 call1 (XCONS (functions
)->car
, frame
);
948 functions
= XCONS (functions
)->cdr
;
953 update_menu_bar (XFRAME (frame
), 0);
957 unbind_to (count
, Qnil
);
960 update_menu_bar (selected_frame
, 1);
962 /* Motif needs this. See comment in xmenu.c.
963 Turn it off when pending_menu_activation is not defined. */
965 pending_menu_activation
= 0;
969 /* Do a frame update, taking possible shortcuts into account.
970 This is the main external entry point for redisplay.
972 If the last redisplay displayed an echo area message and that
973 message is no longer requested, we clear the echo area
974 or bring back the minibuffer if that is in use.
976 Do not call eval from within this function.
977 Calls to eval after the call to echo_area_display would confuse
978 the display_line mechanism and would cause a crash.
979 Calls to eval before that point will work most of the time,
980 but can still lose, because this function
981 can be called from signal handlers; with alarms set up;
982 or with synchronous processes running.
984 See Fcall_process; if you called it from here, it could be
985 entered recursively. */
987 static int do_verify_charstarts
;
989 /* Counter is used to clear the face cache
990 no more than once ever 1000 redisplays. */
991 static int clear_face_cache_count
;
993 /* Record the previous terminal frame we displayed. */
994 static FRAME_PTR previous_terminal_frame
;
999 redisplay_internal (0);
1002 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay
1003 is not in response to any user action; therefore, we should
1004 preserve the echo area. (Actually, our caller does that job.)
1005 Perhaps in the future avoid recentering windows
1006 if it is not necessary; currently that causes some problems. */
1009 redisplay_internal (preserve_echo_area
)
1010 int preserve_echo_area
;
1012 register struct window
*w
= XWINDOW (selected_window
);
1014 int must_finish
= 0;
1016 register int tlbufpos
, tlendpos
;
1017 struct position pos
;
1018 int number_of_visible_frames
;
1023 #ifdef USE_X_TOOLKIT
1024 if (popup_activated ())
1030 if (! FRAME_WINDOW_P (selected_frame
)
1031 && previous_terminal_frame
!= selected_frame
)
1033 /* Since frames on an ASCII terminal share the same display area,
1034 displaying a different frame means redisplay the whole thing. */
1035 windows_or_buffers_changed
++;
1036 SET_FRAME_GARBAGED (selected_frame
);
1037 XSETFRAME (Vterminal_frame
, selected_frame
);
1039 previous_terminal_frame
= selected_frame
;
1041 /* Set the visible flags for all frames.
1042 Do this before checking for resized or garbaged frames; they want
1043 to know if their frames are visible.
1044 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
1046 Lisp_Object tail
, frame
;
1048 number_of_visible_frames
= 0;
1050 FOR_EACH_FRAME (tail
, frame
)
1052 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1054 if (FRAME_VISIBLE_P (XFRAME (frame
)))
1055 number_of_visible_frames
++;
1057 /* Clear out all the display lines in which we will generate the
1058 glyphs to display. */
1059 init_desired_glyphs (XFRAME (frame
));
1063 /* Notice any pending interrupt request to change frame size. */
1064 do_pending_window_change ();
1068 redraw_garbaged_frames ();
1072 prepare_menu_bars ();
1074 if (windows_or_buffers_changed
)
1075 update_mode_lines
++;
1077 /* Detect case that we need to write or remove a star in the mode line. */
1078 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
1080 w
->update_mode_line
= Qt
;
1081 if (buffer_shared
> 1)
1082 update_mode_lines
++;
1085 /* If %c is in use, update it if needed. */
1086 if (!NILP (w
->column_number_displayed
)
1087 /* This alternative quickly identifies a common case
1088 where no change is needed. */
1089 && !(PT
== XFASTINT (w
->last_point
)
1090 && XFASTINT (w
->last_modified
) >= MODIFF
1091 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
1092 && XFASTINT (w
->column_number_displayed
) != current_column ())
1093 w
->update_mode_line
= Qt
;
1095 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
1097 all_windows
= update_mode_lines
|| buffer_shared
> 1;
1099 /* If specs for an arrow have changed, do thorough redisplay
1100 to ensure we remove any arrow that should no longer exist. */
1101 if (! EQ (COERCE_MARKER (Voverlay_arrow_position
), last_arrow_position
)
1102 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
1105 /* Normally the message* functions will have already displayed and
1106 updated the echo area, but the frame may have been trashed, or
1107 the update may have been preempted, so display the echo area
1109 if (echo_area_glyphs
|| previous_echo_glyphs
)
1111 echo_area_display ();
1115 /* If showing region, and mark has changed, must redisplay whole window. */
1116 if (((!NILP (Vtransient_mark_mode
)
1117 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
1118 != !NILP (w
->region_showing
))
1119 || (!NILP (w
->region_showing
)
1120 && !EQ (w
->region_showing
,
1121 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
1122 this_line_bufpos
= -1;
1124 tlbufpos
= this_line_bufpos
;
1125 tlendpos
= this_line_endpos
;
1126 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
1127 && !current_buffer
->clip_changed
1128 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
1129 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
1130 /* Make sure recorded data applies to current buffer, etc */
1131 && this_line_buffer
== current_buffer
1132 && current_buffer
== XBUFFER (w
->buffer
)
1133 && NILP (w
->force_start
)
1134 /* Point must be on the line that we have info recorded about */
1136 && PT
<= Z
- tlendpos
1137 /* All text outside that line, including its final newline,
1138 must be unchanged */
1139 && ((XFASTINT (w
->last_modified
) >= MODIFF
1140 && (XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
))
1141 || (beg_unchanged
>= tlbufpos
- 1
1143 /* If selective display, can't optimize
1144 if the changes start at the beginning of the line. */
1145 && ((INTEGERP (current_buffer
->selective_display
)
1146 && XINT (current_buffer
->selective_display
) > 0
1147 ? (beg_unchanged
>= tlbufpos
1150 && end_unchanged
>= tlendpos
1151 && Z
- GPT
>= tlendpos
)))
1153 int tlbufpos_byte
= CHAR_TO_BYTE (tlbufpos
);
1154 if (tlbufpos
> BEGV
&& FETCH_BYTE (tlbufpos_byte
- 1) != '\n'
1156 || FETCH_BYTE (tlbufpos_byte
) == '\n'))
1157 /* Former continuation line has disappeared by becoming empty */
1159 else if (XFASTINT (w
->last_modified
) < MODIFF
1160 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
1161 || MINI_WINDOW_P (w
))
1163 /* We have to handle the case of continuation around a
1164 wide-column character (See the comment in indent.c around
1167 For instance, in the following case:
1169 -------- Insert --------
1170 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
1171 J_I_ ==> J_I_ `^^' are cursors.
1175 As we have to redraw the line above, we should goto cancel. */
1177 struct position val
;
1179 int opoint
= PT
, opoint_byte
= PT_BYTE
;
1181 scan_newline (tlbufpos
, tlbufpos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
1183 val
= *compute_motion (PT
, 0,
1184 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1187 1 << (BITS_PER_SHORT
- 1),
1188 1 << (BITS_PER_SHORT
- 1),
1189 window_internal_width (w
) - 1,
1190 XINT (w
->hscroll
), 0, w
);
1191 SET_PT_BOTH (opoint
, opoint_byte
);
1192 if (val
.hpos
!= this_line_start_hpos
)
1196 overlay_arrow_seen
= 0;
1197 zv_strings_seen
= 0;
1198 display_text_line (w
, tlbufpos
, tlbufpos_byte
,
1199 this_line_vpos
, this_line_start_hpos
,
1200 pos_tab_offset (w
, tlbufpos
, tlbufpos_byte
), 0);
1201 /* If line contains point, is not continued,
1202 and ends at same distance from eob as before, we win */
1203 if (cursor_vpos
>= 0 && this_line_bufpos
1204 && this_line_endpos
== tlendpos
)
1206 /* If this is not the window's last line,
1207 we must adjust the charstarts of the lines below. */
1208 if (this_line_vpos
+ 1
1209 < XFASTINT (w
->top
) + window_internal_height (w
))
1211 int left
= WINDOW_LEFT_MARGIN (w
);
1212 int *charstart_next_line
1213 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[this_line_vpos
+ 1];
1216 if (Z
- tlendpos
== ZV
)
1217 /* This line ends at end of (accessible part of) buffer.
1218 There is no newline to count. */
1219 adjust
= Z
- tlendpos
- charstart_next_line
[left
];
1221 /* This line ends in a newline.
1222 Must take account of the newline and the rest of the
1223 text that follows. */
1224 adjust
= Z
- tlendpos
+ 1 - charstart_next_line
[left
];
1226 adjust_window_charstarts (w
, this_line_vpos
, adjust
);
1229 if (!WINDOW_FULL_WIDTH_P (w
))
1230 preserve_other_columns (w
);
1236 else if (PT
== XFASTINT (w
->last_point
)
1237 /* Make sure the cursor was last displayed
1238 in this window. Otherwise we have to reposition it. */
1239 && XINT (w
->top
) <= FRAME_CURSOR_Y (selected_frame
)
1240 && (XINT (w
->top
) + XINT (w
->height
)
1241 > FRAME_CURSOR_Y (selected_frame
)))
1245 do_pending_window_change ();
1250 /* If highlighting the region, or if the cursor is in the echo area,
1251 then we can't just move the cursor. */
1252 else if (! (!NILP (Vtransient_mark_mode
)
1253 && !NILP (current_buffer
->mark_active
))
1254 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1255 || highlight_nonselected_windows
)
1256 && NILP (w
->region_showing
)
1257 && !cursor_in_echo_area
)
1259 pos
= *compute_motion (tlbufpos
, 0,
1260 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1262 PT
, 2, - (1 << (BITS_PER_SHORT
- 1)),
1263 window_internal_width (w
) - 1,
1265 pos_tab_offset (w
, tlbufpos
, tlbufpos_byte
),
1269 int width
= window_internal_width (w
) - 1;
1270 FRAME_CURSOR_X (selected_frame
)
1271 = WINDOW_LEFT_MARGIN (w
) + minmax (0, pos
.hpos
, width
);
1272 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
1279 /* Text changed drastically or point moved off of line */
1280 cancel_line (this_line_vpos
, selected_frame
);
1283 this_line_bufpos
= 0;
1284 all_windows
|= buffer_shared
> 1;
1286 clear_face_cache_count
++;
1290 Lisp_Object tail
, frame
;
1293 /* Clear the face cache, only when we do a full redisplay
1294 and not too often either. */
1295 if (clear_face_cache_count
> 1000)
1297 clear_face_cache ();
1298 clear_face_cache_count
= 0;
1302 /* Recompute # windows showing selected buffer.
1303 This will be incremented each time such a window is displayed. */
1306 FOR_EACH_FRAME (tail
, frame
)
1308 FRAME_PTR f
= XFRAME (frame
);
1309 if (FRAME_WINDOW_P (f
) || f
== selected_frame
)
1312 /* Mark all the scroll bars to be removed; we'll redeem the ones
1313 we want when we redisplay their windows. */
1314 if (condemn_scroll_bars_hook
)
1315 (*condemn_scroll_bars_hook
) (f
);
1317 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
1318 redisplay_windows (FRAME_ROOT_WINDOW (f
), preserve_echo_area
);
1320 /* Any scroll bars which redisplay_windows should have nuked
1321 should now go away. */
1322 if (judge_scroll_bars_hook
)
1323 (*judge_scroll_bars_hook
) (f
);
1327 else if (FRAME_VISIBLE_P (selected_frame
) && !FRAME_OBSCURED_P (selected_frame
))
1329 redisplay_window (selected_window
, 1, preserve_echo_area
);
1330 if (!WINDOW_FULL_WIDTH_P (w
))
1331 preserve_other_columns (w
);
1335 /* Prevent various kinds of signals during display update.
1336 stdio is not robust about handling signals,
1337 which can cause an apparent I/O error. */
1338 if (interrupt_input
)
1348 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1352 if (!FRAMEP (XCONS (tail
)->car
))
1355 f
= XFRAME (XCONS (tail
)->car
);
1357 if ((FRAME_WINDOW_P (f
) || f
== selected_frame
)
1358 && FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
1360 pause
|= update_frame (f
, 0, 0);
1363 mark_window_display_accurate (f
->root_window
, 1);
1364 if (frame_up_to_date_hook
!= 0)
1365 (*frame_up_to_date_hook
) (f
);
1372 if (FRAME_VISIBLE_P (selected_frame
) && !FRAME_OBSCURED_P (selected_frame
))
1373 pause
= update_frame (selected_frame
, 0, 0);
1377 /* We may have called echo_area_display at the top of this
1378 function. If the echo area is on another frame, that may
1379 have put text on a frame other than the selected one, so the
1380 above call to update_frame would not have caught it. Catch
1383 Lisp_Object mini_window
;
1384 FRAME_PTR mini_frame
;
1386 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
1387 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
1389 if (mini_frame
!= selected_frame
&& FRAME_WINDOW_P (mini_frame
))
1390 pause
|= update_frame (mini_frame
, 0, 0);
1394 /* If frame does not match, prevent doing single-line-update next time.
1395 Also, don't forget to check every line to update the arrow. */
1398 this_line_bufpos
= 0;
1399 if (!NILP (last_arrow_position
))
1401 last_arrow_position
= Qt
;
1402 last_arrow_string
= Qt
;
1404 /* If we pause after scrolling, some lines in current_frame
1405 may be null, so preserve_other_columns won't be able to
1406 preserve all the vertical-bar separators. So, avoid using it
1408 if (!WINDOW_FULL_WIDTH_P (w
))
1409 update_mode_lines
= 1;
1412 /* Now text on frame agrees with windows, so
1413 put info into the windows for partial redisplay to follow */
1417 register struct buffer
*b
= XBUFFER (w
->buffer
);
1419 blank_end_of_window
= 0;
1420 unchanged_modified
= BUF_MODIFF (b
);
1421 overlay_unchanged_modified
= BUF_OVERLAY_MODIFF (b
);
1422 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
1423 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
1425 XSETFASTINT (w
->last_point
, BUF_PT (b
));
1426 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (selected_frame
));
1427 XSETFASTINT (w
->last_point_y
, FRAME_CURSOR_Y (selected_frame
));
1430 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
1433 b
->clip_changed
= 0;
1434 w
->update_mode_line
= Qnil
;
1435 XSETFASTINT (w
->last_modified
, BUF_MODIFF (b
));
1436 XSETFASTINT (w
->last_overlay_modified
, BUF_OVERLAY_MODIFF (b
));
1438 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1441 /* Record if we are showing a region, so can make sure to
1442 update it fully at next redisplay. */
1443 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
1444 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1445 || highlight_nonselected_windows
)
1446 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
1447 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
1450 w
->window_end_valid
= w
->buffer
;
1451 last_arrow_position
= COERCE_MARKER (Voverlay_arrow_position
);
1452 last_arrow_string
= Voverlay_arrow_string
;
1453 if (do_verify_charstarts
)
1454 verify_charstarts (w
);
1455 if (frame_up_to_date_hook
!= 0)
1456 (*frame_up_to_date_hook
) (selected_frame
);
1458 update_mode_lines
= 0;
1459 windows_or_buffers_changed
= 0;
1462 /* Start SIGIO interrupts coming again.
1463 Having them off during the code above
1464 makes it less likely one will discard output,
1465 but not impossible, since there might be stuff
1466 in the system buffer here.
1467 But it is much hairier to try to do anything about that. */
1469 if (interrupt_input
)
1473 /* If something has become visible now which was not before,
1474 redisplay again, so that we get them. */
1477 Lisp_Object tail
, frame
;
1480 FOR_EACH_FRAME (tail
, frame
)
1482 int this_is_visible
= 0;
1484 if (XFRAME (frame
)->visible
)
1485 this_is_visible
= 1;
1486 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1487 if (XFRAME (frame
)->visible
)
1488 this_is_visible
= 1;
1490 if (this_is_visible
)
1494 if (new_count
!= number_of_visible_frames
)
1495 windows_or_buffers_changed
++;
1498 /* Change frame size now if a change is pending. */
1499 do_pending_window_change ();
1501 /* If we just did a pending size change, or have additional
1502 visible frames, redisplay again. */
1503 if (windows_or_buffers_changed
&& !pause
)
1507 /* Redisplay, but leave alone any recent echo area message
1508 unless another message has been requested in its place.
1510 This is useful in situations where you need to redisplay but no
1511 user action has occurred, making it inappropriate for the message
1512 area to be cleared. See tracking_off and
1513 wait_reading_process_input for examples of these situations. */
1516 redisplay_preserve_echo_area ()
1518 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
1520 echo_area_glyphs
= previous_echo_glyphs
;
1521 redisplay_internal (1);
1522 echo_area_glyphs
= 0;
1525 redisplay_internal (1);
1529 mark_window_display_accurate (window
, flag
)
1533 register struct window
*w
;
1535 for (;!NILP (window
); window
= w
->next
)
1537 if (!WINDOWP (window
)) abort ();
1538 w
= XWINDOW (window
);
1540 if (!NILP (w
->buffer
))
1542 XSETFASTINT (w
->last_modified
,
1543 !flag
? 0 : BUF_MODIFF (XBUFFER (w
->buffer
)));
1544 XSETFASTINT (w
->last_overlay_modified
,
1545 !flag
? 0 : BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
)));
1547 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1550 /* Record if we are showing a region, so can make sure to
1551 update it fully at next redisplay. */
1552 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
1553 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1554 || highlight_nonselected_windows
)
1555 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
1556 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
1560 w
->window_end_valid
= w
->buffer
;
1561 w
->update_mode_line
= Qnil
;
1562 if (!NILP (w
->buffer
) && flag
)
1563 XBUFFER (w
->buffer
)->clip_changed
= 0;
1565 if (!NILP (w
->vchild
))
1566 mark_window_display_accurate (w
->vchild
, flag
);
1567 if (!NILP (w
->hchild
))
1568 mark_window_display_accurate (w
->hchild
, flag
);
1573 last_arrow_position
= COERCE_MARKER (Voverlay_arrow_position
);
1574 last_arrow_string
= Voverlay_arrow_string
;
1578 /* t is unequal to any useful value of Voverlay_arrow_... */
1579 last_arrow_position
= Qt
;
1580 last_arrow_string
= Qt
;
1584 /* Update the menu bar item list for frame F.
1585 This has to be done before we start to fill in any display lines,
1586 because it can call eval.
1588 If SAVE_MATCH_DATA is 1, we must save and restore it here. */
1591 update_menu_bar (f
, save_match_data
)
1593 int save_match_data
;
1595 struct buffer
*old
= current_buffer
;
1597 register struct window
*w
;
1599 window
= FRAME_SELECTED_WINDOW (f
);
1600 w
= XWINDOW (window
);
1602 if (update_mode_lines
)
1603 w
->update_mode_line
= Qt
;
1605 if (FRAME_WINDOW_P (f
)
1607 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1608 FRAME_EXTERNAL_MENU_BAR (f
)
1610 FRAME_MENU_BAR_LINES (f
) > 0
1612 : FRAME_MENU_BAR_LINES (f
) > 0)
1614 /* If the user has switched buffers or windows, we need to
1615 recompute to reflect the new bindings. But we'll
1616 recompute when update_mode_lines is set too; that means
1617 that people can use force-mode-line-update to request
1618 that the menu bar be recomputed. The adverse effect on
1619 the rest of the redisplay algorithm is about the same as
1620 windows_or_buffers_changed anyway. */
1621 if (windows_or_buffers_changed
1622 || !NILP (w
->update_mode_line
)
1623 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1624 < BUF_MODIFF (XBUFFER (w
->buffer
)))
1625 != !NILP (w
->last_had_star
))
1626 || ((!NILP (Vtransient_mark_mode
)
1627 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
1628 != !NILP (w
->region_showing
)))
1630 struct buffer
*prev
= current_buffer
;
1631 int count
= specpdl_ptr
- specpdl
;
1633 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1634 if (save_match_data
)
1635 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1636 if (NILP (Voverriding_local_map_menu_flag
))
1638 specbind (Qoverriding_terminal_local_map
, Qnil
);
1639 specbind (Qoverriding_local_map
, Qnil
);
1642 /* Run the Lucid hook. */
1643 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1644 /* If it has changed current-menubar from previous value,
1645 really recompute the menubar from the value. */
1646 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1647 call0 (Qrecompute_lucid_menubar
);
1648 safe_run_hooks (Qmenu_bar_update_hook
);
1649 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1650 /* Redisplay the menu bar in case we changed it. */
1651 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1652 if (FRAME_WINDOW_P (f
))
1653 set_frame_menubar (f
, 0, 0);
1655 /* On a terminal screen, the menu bar is an ordinary screen
1656 line, and this makes it get updated. */
1657 w
->update_mode_line
= Qt
;
1658 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
1659 /* In the non-toolkit version, the menu bar is an ordinary screen
1660 line, and this makes it get updated. */
1661 w
->update_mode_line
= Qt
;
1662 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
1664 unbind_to (count
, Qnil
);
1665 set_buffer_internal_1 (prev
);
1672 /* Redisplay WINDOW and its subwindows and siblings. */
1675 redisplay_windows (window
, preserve_echo_area
)
1677 int preserve_echo_area
;
1679 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
1680 redisplay_window (window
, 0, preserve_echo_area
);
1683 /* Return value in display table DP (Lisp_Char_Table *) for character
1684 C. Since a display table doesn't have any parent, we don't have to
1685 follow parent. Do not call this function directly but use the
1686 macro DISP_CHAR_VECTOR. */
1688 disp_char_vector (dp
, c
)
1689 struct Lisp_Char_Table
*dp
;
1695 if (SINGLE_BYTE_CHAR_P (c
)) return (dp
->contents
[c
]);
1697 SPLIT_NON_ASCII_CHAR (c
, code
[0], code
[1], code
[2]);
1698 if (code
[0] != CHARSET_COMPOSITION
)
1700 if (code
[1] < 32) code
[1] = -1;
1701 else if (code
[2] < 32) code
[2] = -1;
1703 /* Here, the possible range of CODE[0] (== charset ID) is
1704 128..MAX_CHARSET. Since the top level char table contains data
1705 for multibyte characters after 256th element, we must increment
1706 CODE[0] by 128 to get a correct index. */
1708 code
[3] = -1; /* anchor */
1710 for (i
= 0; code
[i
] >= 0; i
++, dp
= XCHAR_TABLE (val
))
1712 val
= dp
->contents
[code
[i
]];
1713 if (!SUB_CHAR_TABLE_P (val
))
1714 return (NILP (val
) ? dp
->defalt
: val
);
1716 /* Here, VAL is a sub char table. We return the default value of it. */
1717 return (dp
->defalt
);
1720 /* Redisplay window WINDOW and its subwindows. */
1723 redisplay_window (window
, just_this_one
, preserve_echo_area
)
1725 int just_this_one
, preserve_echo_area
;
1727 register struct window
*w
= XWINDOW (window
);
1728 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1731 int lpoint_byte
= PT_BYTE
;
1732 struct buffer
*old
= current_buffer
;
1733 register int width
= window_internal_width (w
) - 1;
1734 register int startp
, startp_byte
;
1735 register int hscroll
= XINT (w
->hscroll
);
1736 struct position pos
;
1738 int opoint_byte
= PT_BYTE
;
1740 int update_mode_line
;
1741 struct Lisp_Char_Table
*dp
= window_display_table (w
);
1742 int really_switched_buffer
= 0;
1744 if (Z
== Z_BYTE
&& lpoint
!= lpoint_byte
)
1746 if (lpoint_byte
< lpoint
)
1749 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1751 /* If this is a combination window, do its children; that's all. */
1753 if (!NILP (w
->vchild
))
1755 redisplay_windows (w
->vchild
, preserve_echo_area
);
1758 if (!NILP (w
->hchild
))
1760 redisplay_windows (w
->hchild
, preserve_echo_area
);
1763 if (NILP (w
->buffer
))
1766 height
= window_internal_height (w
);
1767 update_mode_line
= (!NILP (w
->update_mode_line
) || update_mode_lines
);
1768 if (XBUFFER (w
->buffer
)->clip_changed
)
1769 update_mode_line
= 1;
1771 if (MINI_WINDOW_P (w
))
1773 if (w
== XWINDOW (echo_area_window
) && echo_area_glyphs
)
1774 /* We've already displayed the echo area glyphs in this window. */
1775 goto finish_scroll_bars
;
1776 else if (w
!= XWINDOW (minibuf_window
))
1778 /* This is a minibuffer, but it's not the currently active one,
1780 int vpos
= XFASTINT (w
->top
);
1783 for (i
= 0; i
< height
; i
++)
1785 get_display_line (f
, vpos
+ i
, 0);
1786 display_string (w
, vpos
+ i
, "", 0,
1787 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
1791 goto finish_scroll_bars
;
1795 /* Otherwise set up data on this window; select its buffer and point value */
1797 if (update_mode_line
)
1798 /* Really select the buffer, for the sake of buffer-local variables. */
1800 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1801 really_switched_buffer
= 1;
1804 set_buffer_temp (XBUFFER (w
->buffer
));
1807 opoint_byte
= PT_BYTE
;
1809 if (Z
== Z_BYTE
&& opoint
!= opoint_byte
)
1811 if (opoint_byte
< opoint
)
1814 /* If %c is in mode line, update it if needed. */
1815 if (!NILP (w
->column_number_displayed
)
1816 /* This alternative quickly identifies a common case
1817 where no change is needed. */
1818 && !(PT
== XFASTINT (w
->last_point
)
1819 && XFASTINT (w
->last_modified
) >= MODIFF
1820 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
1821 && XFASTINT (w
->column_number_displayed
) != current_column ())
1822 update_mode_line
= 1;
1824 /* Count number of windows showing the selected buffer.
1825 An indirect buffer counts as its base buffer. */
1829 struct buffer
*current_base
, *window_base
;
1830 current_base
= current_buffer
;
1831 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1832 if (current_base
->base_buffer
)
1833 current_base
= current_base
->base_buffer
;
1834 if (window_base
->base_buffer
)
1835 window_base
= window_base
->base_buffer
;
1836 if (current_base
== window_base
)
1840 /* POINT refers normally to the selected window.
1841 For any other window, set up appropriate value. */
1843 if (!EQ (window
, selected_window
))
1845 int new_pt
= XMARKER (w
->pointm
)->charpos
;
1846 int new_pt_byte
= marker_byte_position (w
->pointm
);
1850 new_pt_byte
= BEGV_BYTE
;
1851 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
1853 else if (new_pt
> (ZV
- 1))
1856 new_pt_byte
= ZV_BYTE
;
1857 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
1859 /* We don't use SET_PT so that the point-motion hooks don't run. */
1860 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
1863 /* If any of the character widths specified in the display table
1864 have changed, invalidate the width run cache. It's true that this
1865 may be a bit late to catch such changes, but the rest of
1866 redisplay goes (non-fatally) haywire when the display table is
1867 changed, so why should we worry about doing any better? */
1868 if (current_buffer
->width_run_cache
)
1870 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
1872 if (! disptab_matches_widthtab (disptab
,
1873 XVECTOR (current_buffer
->width_table
)))
1875 invalidate_region_cache (current_buffer
,
1876 current_buffer
->width_run_cache
,
1878 recompute_width_table (current_buffer
, disptab
);
1882 /* If window-start is screwed up, choose a new one. */
1883 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
1886 startp
= marker_position (w
->start
);
1887 startp_byte
= marker_byte_position (w
->start
);
1889 /* If someone specified a new starting point but did not insist,
1890 check whether it can be used. */
1891 if (!NILP (w
->optional_new_start
))
1893 w
->optional_new_start
= Qnil
;
1894 /* Check whether this start pos is usable given where point is. */
1896 pos
= *compute_motion (startp
, 0,
1897 (((EQ (window
, minibuf_window
)
1899 ? minibuf_prompt_width
: 0)
1900 + (hscroll
? 1 - hscroll
: 0)),
1903 /* BUG FIX: See the comment of
1904 Fpos_visible_in_window_p (window.c). */
1905 - (1 << (BITS_PER_SHORT
- 1)),
1907 pos_tab_offset (w
, startp
, startp_byte
), w
);
1908 /* If PT does fit on the screen, we will use this start pos,
1909 so do so by setting force_start. */
1910 if (pos
.bufpos
== PT
)
1911 w
->force_start
= Qt
;
1914 /* Handle case where place to start displaying has been specified,
1915 unless the specified location is outside the accessible range. */
1916 if (!NILP (w
->force_start
))
1918 w
->force_start
= Qnil
;
1919 /* Forget any recorded base line for line number display. */
1920 w
->base_line_number
= Qnil
;
1921 /* Redisplay the mode line. Select the buffer properly for that.
1922 Also, run the hook window-scroll-functions
1923 because we have scrolled. */
1924 /* Note, we do this after clearing force_start because
1925 if there's an error, it is better to forget about force_start
1926 than to get into an infinite loop calling the hook functions
1927 and having them get more errors. */
1928 if (!update_mode_line
1929 || ! NILP (Vwindow_scroll_functions
))
1931 Lisp_Object temp
[3];
1933 if (!really_switched_buffer
)
1935 set_buffer_temp (old
);
1936 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1938 really_switched_buffer
= 1;
1939 update_mode_line
= 1;
1940 w
->update_mode_line
= Qt
;
1941 if (! NILP (Vwindow_scroll_functions
))
1943 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1944 make_number (startp
));
1945 startp
= marker_position (w
->start
);
1948 XSETFASTINT (w
->last_modified
, 0);
1949 XSETFASTINT (w
->last_overlay_modified
, 0);
1950 if (startp
< BEGV
) startp
= BEGV
, startp_byte
= BEGV_BYTE
;
1951 if (startp
> ZV
) startp
= ZV
, startp
= ZV_BYTE
;
1952 try_window (window
, startp
);
1953 if (cursor_vpos
< 0)
1955 /* If point does not appear, move point so it does appear */
1956 pos
= *compute_motion (startp
, 0,
1957 (((EQ (window
, minibuf_window
)
1959 ? minibuf_prompt_width
: 0)
1960 + (hscroll
? 1 - hscroll
: 0)),
1963 - (1 << (BITS_PER_SHORT
- 1)),
1965 pos_tab_offset (w
, startp
, startp_byte
),
1967 TEMP_SET_PT_BOTH (pos
.bufpos
, pos
.bytepos
);
1968 if (w
!= XWINDOW (selected_window
))
1969 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
1972 if (current_buffer
== old
)
1975 lpoint_byte
= PT_BYTE
;
1977 FRAME_CURSOR_X (f
) = (WINDOW_LEFT_MARGIN (w
)
1978 + minmax (0, pos
.hpos
, width
));
1979 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1981 /* If we are highlighting the region,
1982 then we just changed the region, so redisplay to show it. */
1983 if (!NILP (Vtransient_mark_mode
)
1984 && !NILP (current_buffer
->mark_active
))
1986 cancel_my_columns (XWINDOW (window
));
1987 try_window (window
, startp
);
1993 /* Handle case where text has not changed, only point,
1994 and it has not moved off the frame. */
1996 /* This code is not used for minibuffer for the sake of
1997 the case of redisplaying to replace an echo area message;
1998 since in that case the minibuffer contents per se are usually unchanged.
1999 This code is of no real use in the minibuffer since
2000 the handling of this_line_bufpos, etc.,
2001 in redisplay handles the same cases. */
2003 if (XFASTINT (w
->last_modified
) >= MODIFF
2004 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
2005 && PT
>= startp
&& !current_buffer
->clip_changed
2006 && (just_this_one
|| WINDOW_FULL_WIDTH_P (w
))
2007 /* If force-mode-line-update was called, really redisplay;
2008 that's how redisplay is forced after e.g. changing
2009 buffer-invisibility-spec. */
2010 && NILP (w
->update_mode_line
)
2011 /* Can't use this case if highlighting a region. */
2012 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
2013 && NILP (w
->region_showing
)
2014 /* If end pos is out of date, scroll bar and percentage will be wrong */
2015 && INTEGERP (w
->window_end_vpos
)
2016 && XFASTINT (w
->window_end_vpos
) < XFASTINT (w
->height
)
2017 && !EQ (window
, minibuf_window
)
2018 && (!MARKERP (Voverlay_arrow_position
)
2019 || current_buffer
!= XMARKER (Voverlay_arrow_position
)->buffer
))
2021 /* All positions in this clause are relative to the window edge. */
2023 int this_scroll_margin
= scroll_margin
;
2024 int last_point_y
= XFASTINT (w
->last_point_y
) - XINT (w
->top
);
2025 int last_point_x
= (XFASTINT (w
->last_point_x
) - WINDOW_LEFT_MARGIN (w
));
2027 /* Find where PT is located now on the frame. */
2028 /* Check just_this_one as a way of verifying that the
2029 window edges have not changed. */
2030 if (PT
== XFASTINT (w
->last_point
) && just_this_one
)
2032 pos
.hpos
= last_point_x
;
2033 pos
.vpos
= last_point_y
;
2036 else if (PT
> XFASTINT (w
->last_point
)
2037 && XFASTINT (w
->last_point
) > startp
&& just_this_one
2038 /* We can't use this if point is in the left margin of a
2039 hscrolled window, because w->last_point_x has been
2040 clipped to the window edges. */
2041 && !(last_point_x
<= 0 && hscroll
))
2043 int last_point
= XFASTINT (w
->last_point
);
2044 int last_point_byte
= CHAR_TO_BYTE (last_point
);
2045 int tab_offset
= (pos_tab_offset (w
, last_point
, last_point_byte
)
2046 - (last_point_x
+ hscroll
- !! hscroll
));
2048 pos
= *compute_motion (last_point
, last_point_y
, last_point_x
, 0,
2050 /* BUG FIX: See the comment of
2051 Fpos_visible_in_window_p (window.c). */
2052 - (1 << (BITS_PER_SHORT
- 1)),
2059 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0), 0,
2061 /* BUG FIX: See the comment of
2062 Fpos_visible_in_window_p (window.c). */
2063 - (1 << (BITS_PER_SHORT
- 1)),
2065 pos_tab_offset (w
, startp
, startp_byte
),
2069 /* Don't use a scroll margin that is negative or too large. */
2070 if (this_scroll_margin
< 0)
2071 this_scroll_margin
= 0;
2073 if (XINT (w
->height
) < 4 * scroll_margin
)
2074 this_scroll_margin
= XINT (w
->height
) / 4;
2076 /* If point fits on the screen, and not within the scroll margin,
2078 if (pos
.vpos
< height
- this_scroll_margin
2079 && (pos
.vpos
>= this_scroll_margin
|| startp
== BEGV
))
2081 /* Ok, point is still on frame */
2082 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
2084 /* These variables are supposed to be origin 1 */
2085 FRAME_CURSOR_X (f
) = (WINDOW_LEFT_MARGIN (w
)
2086 + minmax (0, pos
.hpos
, width
));
2087 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
2089 /* This doesn't do the trick, because if a window to the right of
2090 this one must be redisplayed, this does nothing because there
2091 is nothing in DesiredFrame yet, and then the other window is
2092 redisplayed, making likes that are empty in this window's columns.
2093 if (WINDOW_FULL_WIDTH_P (w))
2094 preserve_my_columns (w);
2096 if (current_buffer
->clip_changed
2097 && ! NILP (Vwindow_scroll_functions
))
2098 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2099 make_number (marker_position (w
->start
)));
2103 /* Don't bother trying redisplay with same start;
2104 we already know it will lose */
2106 /* If current starting point was originally the beginning of a line
2107 but no longer is, find a new starting point. */
2108 else if (!NILP (w
->start_at_line_beg
)
2110 || FETCH_BYTE (startp_byte
- 1) == '\n'))
2114 else if (just_this_one
&& !MINI_WINDOW_P (w
)
2116 && XFASTINT (w
->last_modified
)
2117 /* or else vmotion on first line won't work. */
2118 && ! NILP (w
->start_at_line_beg
)
2119 && ! EQ (w
->window_end_valid
, Qnil
)
2120 && do_id
&& !current_buffer
->clip_changed
2121 && !blank_end_of_window
2122 && WINDOW_FULL_WIDTH_P (w
)
2123 /* Can't use this case if highlighting a region. */
2124 && !(!NILP (Vtransient_mark_mode
)
2125 && !NILP (current_buffer
->mark_active
))
2126 /* Don't use try_window_id if newline
2127 doesn't display as the end of a line. */
2128 && !(dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, '\n')))
2129 && NILP (w
->region_showing
)
2130 && EQ (last_arrow_position
, COERCE_MARKER (Voverlay_arrow_position
))
2131 && EQ (last_arrow_string
, Voverlay_arrow_string
)
2132 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
2135 /* tem > 0 means success. tem == -1 means choose new start.
2136 tem == -2 means try again with same start,
2137 and nothing but whitespace follows the changed stuff.
2138 tem == 0 means try again with same start. */
2142 else if (startp
>= BEGV
&& startp
<= ZV
2144 /* Avoid starting at end of buffer. */
2145 #if 0 /* This change causes trouble for M-! finger & RET.
2146 It will have to be considered later. */
2147 || ! EQ (window
, selected_window
)
2148 /* Don't do the recentering if redisplay
2149 is not for no user action. */
2150 || preserve_echo_area
2153 || (XFASTINT (w
->last_modified
) >= MODIFF
2154 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
2156 /* Try to redisplay starting at same place as before */
2157 /* If point has not moved off frame, accept the results */
2158 try_window (window
, startp
);
2159 if (cursor_vpos
>= 0)
2161 if (!just_this_one
|| current_buffer
->clip_changed
2162 || beg_unchanged
< startp
)
2163 /* Forget any recorded base line for line number display. */
2164 w
->base_line_number
= Qnil
;
2166 if (current_buffer
->clip_changed
2167 && ! NILP (Vwindow_scroll_functions
))
2168 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2169 make_number (marker_position (w
->start
)));
2174 cancel_my_columns (w
);
2177 XSETFASTINT (w
->last_modified
, 0);
2178 XSETFASTINT (w
->last_overlay_modified
, 0);
2179 /* Redisplay the mode line. Select the buffer properly for that. */
2180 if (!update_mode_line
)
2182 if (!really_switched_buffer
)
2184 set_buffer_temp (old
);
2185 set_buffer_internal_1 (XBUFFER (w
->buffer
));
2187 update_mode_line
= 1;
2188 w
->update_mode_line
= Qt
;
2191 /* Try to scroll by specified few lines */
2193 if (scroll_conservatively
&& !current_buffer
->clip_changed
2194 && startp
>= BEGV
&& startp
<= ZV
)
2196 int this_scroll_margin
= scroll_margin
;
2197 int scroll_margin_pos
;
2199 /* Don't use a scroll margin that is negative or too large. */
2200 if (this_scroll_margin
< 0)
2201 this_scroll_margin
= 0;
2203 if (XINT (w
->height
) < 4 * this_scroll_margin
)
2204 this_scroll_margin
= XINT (w
->height
) / 4;
2206 scroll_margin_pos
= Z
- XFASTINT (w
->window_end_pos
);
2207 if (this_scroll_margin
)
2209 pos
= *vmotion (scroll_margin_pos
, -this_scroll_margin
, w
);
2210 scroll_margin_pos
= pos
.bufpos
;
2212 if (PT
>= scroll_margin_pos
)
2214 struct position pos
;
2215 pos
= *compute_motion (scroll_margin_pos
, 0, 0, 0,
2216 PT
, XFASTINT (w
->height
), 0,
2217 XFASTINT (w
->width
), XFASTINT (w
->hscroll
),
2218 pos_tab_offset (w
, startp
, startp_byte
),
2220 if (pos
.vpos
> scroll_conservatively
)
2223 pos
= *vmotion (startp
, pos
.vpos
+ 1, w
);
2225 if (! NILP (Vwindow_scroll_functions
))
2227 set_marker_both (w
->start
, Qnil
, pos
.bufpos
, pos
.bytepos
);
2228 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2229 make_number (pos
.bufpos
));
2230 pos
.bufpos
= marker_position (w
->start
);
2232 try_window (window
, pos
.bufpos
);
2233 if (cursor_vpos
>= 0)
2235 if (!just_this_one
|| current_buffer
->clip_changed
2236 || beg_unchanged
< startp
)
2237 /* Forget any recorded base line for line number display. */
2238 w
->base_line_number
= Qnil
;
2242 cancel_my_columns (w
);
2245 scroll_margin_pos
= startp
;
2246 if (this_scroll_margin
)
2248 pos
= *vmotion (scroll_margin_pos
, this_scroll_margin
, w
);
2249 scroll_margin_pos
= pos
.bufpos
;
2251 if (PT
< scroll_margin_pos
)
2253 struct position pos
;
2254 pos
= *compute_motion (PT
, 0, 0, 0,
2255 scroll_margin_pos
, XFASTINT (w
->height
), 0,
2256 XFASTINT (w
->width
), XFASTINT (w
->hscroll
),
2257 pos_tab_offset (w
, startp
, startp_byte
),
2259 if (pos
.vpos
> scroll_conservatively
)
2262 pos
= *vmotion (startp
, -pos
.vpos
, w
);
2264 if (! NILP (Vwindow_scroll_functions
))
2266 set_marker_both (w
->start
, Qnil
, pos
.bufpos
, pos
.bytepos
);
2267 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2268 make_number (pos
.bufpos
));
2269 pos
.bufpos
= marker_position (w
->start
);
2271 try_window (window
, pos
.bufpos
);
2272 if (cursor_vpos
>= 0)
2274 if (!just_this_one
|| current_buffer
->clip_changed
2275 || beg_unchanged
< startp
)
2276 /* Forget any recorded base line for line number display. */
2277 w
->base_line_number
= Qnil
;
2281 cancel_my_columns (w
);
2286 if (scroll_step
&& !current_buffer
->clip_changed
2287 && startp
>= BEGV
&& startp
<= ZV
)
2291 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), scroll_step
, w
);
2292 if (pos
.vpos
>= height
)
2296 pos
= *vmotion (startp
, (PT
< startp
? - scroll_step
: scroll_step
), w
);
2298 if (PT
>= pos
.bufpos
)
2300 if (! NILP (Vwindow_scroll_functions
))
2302 set_marker_both (w
->start
, Qnil
, pos
.bufpos
, pos
.bytepos
);
2303 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2304 make_number (pos
.bufpos
));
2305 pos
.bufpos
= marker_position (w
->start
);
2307 try_window (window
, pos
.bufpos
);
2308 if (cursor_vpos
>= 0)
2310 if (!just_this_one
|| current_buffer
->clip_changed
2311 || beg_unchanged
< startp
)
2312 /* Forget any recorded base line for line number display. */
2313 w
->base_line_number
= Qnil
;
2317 cancel_my_columns (w
);
2322 /* Finally, just choose place to start which centers point */
2325 /* Forget any previously recorded base line for line number display. */
2326 w
->base_line_number
= Qnil
;
2328 pos
= *vmotion (PT
, - (height
/ 2), w
);
2330 /* The minibuffer is often just one line. Ordinary scrolling
2331 gives little overlap and looks bad. So show 20 chars before point. */
2333 && (pos
.bufpos
>= PT
- minibuffer_scroll_overlap
2334 /* If we scrolled less than 1/2 line forward, we will
2335 get too much overlap, so change to the usual amount. */
2336 || pos
.bufpos
< startp
+ width
/ 2)
2337 && PT
> BEGV
+ minibuffer_scroll_overlap
2338 /* If we scrolled to an actual line boundary,
2339 that's different; don't ignore line boundaries. */
2340 && FETCH_BYTE (pos
.bytepos
- 1) != '\n')
2342 pos
.bufpos
= PT
- minibuffer_scroll_overlap
;
2343 pos
.bytepos
= CHAR_TO_BYTE (pos
.bufpos
);
2346 /* Set startp here explicitly in case that helps avoid an infinite loop
2347 in case the window-scroll-functions functions get errors. */
2348 set_marker_both (w
->start
, Qnil
, pos
.bufpos
, pos
.bytepos
);
2349 if (! NILP (Vwindow_scroll_functions
))
2351 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2352 make_number (pos
.bufpos
));
2353 pos
.bufpos
= marker_position (w
->start
);
2354 pos
.bytepos
= marker_byte_position (w
->start
);
2356 try_window (window
, pos
.bufpos
);
2358 startp
= marker_position (w
->start
);
2359 startp_byte
= marker_byte_position (w
->start
);
2360 w
->start_at_line_beg
2361 = (startp
== BEGV
|| FETCH_BYTE (startp_byte
- 1) == '\n') ? Qt
: Qnil
;
2364 if ((update_mode_line
2365 /* If window not full width, must redo its mode line
2366 if the window to its side is being redone */
2367 || (!just_this_one
&& !WINDOW_FULL_WIDTH_P (w
))
2368 || INTEGERP (w
->base_line_pos
)
2369 || (!NILP (w
->column_number_displayed
)
2370 && XFASTINT (w
->column_number_displayed
) != current_column ()))
2371 && height
!= XFASTINT (w
->height
))
2373 FRAME_PTR oframe
= selected_frame
;
2374 if (!really_switched_buffer
)
2376 set_buffer_temp (old
);
2377 set_buffer_internal_1 (XBUFFER (w
->buffer
));
2378 really_switched_buffer
= 1;
2381 display_mode_line (w
);
2382 selected_frame
= oframe
;
2384 if (! line_number_displayed
2385 && ! BUFFERP (w
->base_line_pos
))
2387 w
->base_line_pos
= Qnil
;
2388 w
->base_line_number
= Qnil
;
2391 /* When we reach a frame's selected window, redo the frame's menu bar. */
2392 if (update_mode_line
2393 && (FRAME_WINDOW_P (f
)
2395 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
2396 FRAME_EXTERNAL_MENU_BAR (f
)
2398 FRAME_MENU_BAR_LINES (f
) > 0
2400 : FRAME_MENU_BAR_LINES (f
) > 0)
2401 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
2402 display_menu_bar (w
);
2405 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2407 int start
, end
, whole
;
2409 /* Calculate the start and end positions for the current window.
2410 At some point, it would be nice to choose between scrollbars
2411 which reflect the whole buffer size, with special markers
2412 indicating narrowing, and scrollbars which reflect only the
2415 Note that minibuffers sometimes aren't displaying any text. */
2416 if (! MINI_WINDOW_P (w
)
2417 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
2420 start
= marker_position (w
->start
) - BEGV
;
2421 /* I don't think this is guaranteed to be right. For the
2422 moment, we'll pretend it is. */
2423 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
2425 if (end
< start
) end
= start
;
2426 if (whole
< (end
- start
)) whole
= end
- start
;
2429 start
= end
= whole
= 0;
2431 /* Indicate what this scroll bar ought to be displaying now. */
2432 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
2434 /* Note that we actually used the scroll bar attached to this window,
2435 so it shouldn't be deleted at the end of redisplay. */
2436 (*redeem_scroll_bar_hook
) (w
);
2439 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
2440 if (really_switched_buffer
)
2441 set_buffer_internal_1 (old
);
2443 set_buffer_temp (old
);
2444 TEMP_SET_PT_BOTH (lpoint
, lpoint_byte
);
2447 /* Do full redisplay on one window, starting at position `pos'. */
2450 try_window (window
, pos
)
2454 register struct window
*w
= XWINDOW (window
);
2455 register int height
= window_internal_height (w
);
2456 register int vpos
= XFASTINT (w
->top
);
2457 register int last_text_vpos
= vpos
;
2458 FRAME_PTR f
= XFRAME (w
->frame
);
2459 int width
= window_internal_width (w
) - 1;
2460 struct position val
;
2462 /* POS should never be out of range! */
2463 if (pos
< XBUFFER (w
->buffer
)->begv
2464 || pos
> XBUFFER (w
->buffer
)->zv
)
2467 if (XMARKER (w
->start
)->charpos
!= pos
)
2468 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2471 overlay_arrow_seen
= 0;
2472 zv_strings_seen
= 0;
2473 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
2474 val
.ovstring_chars_done
= 0;
2475 val
.bytepos
= marker_byte_position (w
->start
);
2476 val
.tab_offset
= pos_tab_offset (w
, pos
, val
.bytepos
);
2478 while (--height
>= 0)
2480 val
= *display_text_line (w
, pos
, val
.bytepos
, vpos
,
2481 val
.hpos
, val
.tab_offset
,
2482 val
.ovstring_chars_done
);
2483 /* The following code is omitted because we maintain tab_offset
2486 tab_offset
+= width
;
2487 if (val
.vpos
) tab_offset
= 0;
2490 if (pos
!= val
.bufpos
)
2493 #ifdef USE_TEXT_PROPERTIES
2494 Lisp_Object invis_prop
;
2495 invis_prop
= Fget_char_property (val
.bufpos
-1, Qinvisible
, window
);
2496 invis
= TEXT_PROP_MEANS_INVISIBLE (invis_prop
);
2500 /* Next line, unless prev line ended in end of buffer with no cr */
2502 && (FETCH_BYTE (val
.bytepos
- 1) != '\n' || invis
));
2507 /* If last line is continued in middle of character,
2508 include the split character in the text considered on the frame */
2509 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2512 /* If bottom just moved off end of frame, change mode line percentage. */
2513 if (XFASTINT (w
->window_end_pos
) == 0
2515 w
->update_mode_line
= Qt
;
2517 /* Say where last char on frame will be, once redisplay is finished. */
2518 XSETFASTINT (w
->window_end_pos
, Z
- pos
);
2519 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
- XFASTINT (w
->top
));
2520 /* But that is not valid info until redisplay finishes. */
2521 w
->window_end_valid
= Qnil
;
2524 /* Try to redisplay when buffer is modified locally,
2525 computing insert/delete line to preserve text outside
2526 the bounds of the changes.
2527 Return 1 if successful, 0 if if cannot tell what to do,
2528 or -1 to tell caller to find a new window start,
2529 or -2 to tell caller to do normal redisplay with same window start. */
2532 try_window_id (window
)
2536 int opoint
, opoint_byte
;
2537 register struct window
*w
= XWINDOW (window
);
2538 register int height
= window_internal_height (w
);
2539 FRAME_PTR f
= XFRAME (w
->frame
);
2540 int top
= XFASTINT (w
->top
);
2541 int start
= marker_position (w
->start
);
2542 int width
= window_internal_width (w
) - 1;
2543 int hscroll
= XINT (w
->hscroll
);
2544 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
2547 register int i
, tem
;
2548 int last_text_vpos
= 0;
2550 int selective
= (INTEGERP (current_buffer
->selective_display
)
2551 ? XINT (current_buffer
->selective_display
)
2552 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
2553 struct position val
, bp
, ep
, xp
, pp
;
2554 int scroll_amount
= 0;
2558 int start_byte
= marker_byte_position (w
->start
);
2560 if (GPT
- BEG
< beg_unchanged
)
2561 beg_unchanged
= GPT
- BEG
;
2562 if (Z
- GPT
< end_unchanged
)
2563 end_unchanged
= Z
- GPT
;
2565 if (beg_unchanged
+ BEG
< start
)
2566 return 0; /* Give up if changes go above top of window */
2568 /* Find position before which nothing is changed. */
2569 bp
= *compute_motion (start
, 0, lmargin
, 0,
2570 min (ZV
, beg_unchanged
+ BEG
), height
,
2571 /* BUG FIX: See the comment of
2572 Fpos_visible_in_window_p (window.c). */
2573 - (1 << (BITS_PER_SHORT
- 1)),
2575 pos_tab_offset (w
, start
, start_byte
),
2577 if (bp
.vpos
>= height
)
2581 /* All changes are beyond the window end, and point is on the screen.
2582 We don't need to change the text at all.
2583 But we need to update window_end_pos to account for
2584 any change in buffer size. */
2585 bp
= *compute_motion (start
, 0, lmargin
, 0,
2587 /* BUG FIX: See the comment of
2588 Fpos_visible_in_window_p() (window.c). */
2589 - (1 << (BITS_PER_SHORT
- 1)),
2591 pos_tab_offset (w
, start
, start_byte
), w
);
2592 XSETFASTINT (w
->window_end_vpos
, height
);
2593 XSETFASTINT (w
->window_end_pos
, Z
- bp
.bufpos
);
2601 /* Find beginning of that frame line. Must display from there. */
2602 bp
= *vmotion (bp
.bufpos
, 0, w
);
2605 pos_byte
= bp
.bytepos
;
2611 /* If about to start displaying at the beginning of a continuation line,
2612 really start with previous frame line, in case it was not
2613 continued when last redisplayed */
2614 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
2616 /* Likewise if we have to worry about selective display. */
2617 (selective
> 0 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
2619 bp
= *vmotion (bp
.bufpos
, -1, w
);
2622 pos_byte
= bp
.bytepos
;
2624 val
.tab_offset
= bp
.tab_offset
; /* Update tab offset. */
2626 if (bp
.contin
&& bp
.hpos
!= lmargin
)
2628 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
2629 val
.tab_offset
= bp
.tab_offset
+ bp
.prevhpos
- width
;
2631 DEC_BOTH (pos
, pos_byte
);
2636 /* Find first visible newline after which no more is changed. */
2637 opoint
= PT
, opoint_byte
= PT_BYTE
;
2638 SET_PT (Z
- max (end_unchanged
, Z
- ZV
));
2639 scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, 1, 1);
2641 while (PT
< ZV
- 1 && indented_beyond_p (PT
, PT_BYTE
, selective
))
2642 scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, 1, 1);
2644 SET_PT_BOTH (opoint
, opoint_byte
);
2646 /* Compute the cursor position after that newline. */
2647 ep
= *compute_motion (pos
, vpos
, val
.hpos
, did_motion
, tem
,
2648 height
, - (1 << (BITS_PER_SHORT
- 1)),
2650 /* We have tab offset in VAL, use it. */
2653 /* If changes reach past the text available on the frame,
2654 just display rest of frame. */
2655 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
2658 stop_vpos
= ep
.vpos
;
2660 /* If no newline before ep, the line ep is on includes some changes
2661 that must be displayed. Make sure we don't stop before it. */
2662 /* Also, if changes reach all the way until ep.bufpos,
2663 it is possible that something was deleted after the
2664 newline before it, so the following line must be redrawn. */
2665 if (stop_vpos
== ep
.vpos
2666 && (ep
.bufpos
== BEGV
2667 || FETCH_BYTE (ep
.bytepos
- 1) != '\n'
2668 || ep
.bufpos
== Z
- end_unchanged
))
2669 stop_vpos
= ep
.vpos
+ 1;
2672 overlay_arrow_seen
= 0;
2673 zv_strings_seen
= 0;
2675 /* If changes do not reach to bottom of window,
2676 figure out how much to scroll the rest of the window */
2677 if (stop_vpos
< height
)
2679 /* Now determine how far up or down the rest of the window has moved */
2680 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2681 Z
- XFASTINT (w
->window_end_pos
),
2682 /* Don't care for VPOS... */
2683 1 << (BITS_PER_SHORT
- 1),
2685 1 << (BITS_PER_SHORT
- 1),
2686 width
, hscroll
, ep
.tab_offset
, w
);
2687 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
2689 /* Is everything on frame below the changes whitespace?
2690 If so, no scrolling is really necessary. */
2691 for (i
= ep
.bytepos
; i
< xp
.bytepos
; i
++)
2693 tem
= FETCH_BYTE (i
);
2694 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
2697 if (i
== xp
.bytepos
)
2700 XSETFASTINT (w
->window_end_vpos
,
2701 XFASTINT (w
->window_end_vpos
) + scroll_amount
);
2703 /* Before doing any scrolling, verify that point will be on frame. */
2704 if (PT
> ep
.bufpos
&& !(PT
<= xp
.bufpos
&& xp
.vpos
< height
))
2706 if (PT
<= xp
.bufpos
)
2708 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2709 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2711 /* We have tab offset in EP, use it. */
2716 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
, 1,
2717 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2719 /* We have tab offset in XP, use it. */
2722 if (pp
.bufpos
< PT
|| pp
.vpos
== height
)
2724 cursor_vpos
= pp
.vpos
+ top
;
2725 cursor_hpos
= WINDOW_LEFT_MARGIN (w
) + minmax (0, pp
.hpos
, width
);
2728 if (stop_vpos
- scroll_amount
>= height
2729 || ep
.bufpos
== xp
.bufpos
)
2731 if (scroll_amount
< 0)
2732 stop_vpos
-= scroll_amount
;
2734 /* In this path, we have altered window_end_vpos
2735 and not left it negative.
2736 We must make sure that, in case display is preempted
2737 before the frame changes to reflect what we do here,
2738 further updates will not come to try_window_id
2739 and assume the frame and window_end_vpos match. */
2740 blank_end_of_window
= 1;
2742 else if (!scroll_amount
)
2744 /* Even if we don't need to scroll, we must adjust the
2745 charstarts of subsequent lines (that we won't redisplay)
2746 according to the amount of text inserted or deleted. */
2747 int oldpos
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2748 int adjust
= ep
.bufpos
- oldpos
;
2749 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1, adjust
);
2751 else if (bp
.bufpos
== Z
- end_unchanged
)
2753 /* If reprinting everything is nearly as fast as scrolling,
2754 don't bother scrolling. Can happen if lines are short. */
2755 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
2756 top
+ height
- max (0, scroll_amount
),
2758 > xp
.bufpos
- bp
.bufpos
- 20)
2759 /* Return "try normal display with same window-start."
2760 Too bad we can't prevent further scroll-thinking. */
2762 /* If pure deletion, scroll up as many lines as possible.
2763 In common case of killing a line, this can save the
2764 following line from being overwritten by scrolling
2765 and therefore having to be redrawn. */
2766 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
2767 top
+ height
- max (0, scroll_amount
),
2768 scroll_amount
, bp
.bufpos
);
2773 /* scroll_frame_lines did not properly adjust subsequent
2774 lines' charstarts in the case where the text of the
2775 screen line at bp.vpos has changed.
2776 (This can happen in a deletion that ends in mid-line.)
2777 To adjust properly, we need to make things consistent
2779 So do a second adjust to make that happen.
2780 Note that stop_vpos >= ep.vpos, so it is sufficient
2781 to update the charstarts for lines at ep.vpos and below. */
2783 = FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2784 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1,
2785 ep
.bufpos
- oldstart
);
2788 else if (scroll_amount
)
2790 /* If reprinting everything is nearly as fast as scrolling,
2791 don't bother scrolling. Can happen if lines are short. */
2792 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
2793 overestimate of cost of reprinting, since xp.bufpos
2794 would end up below the bottom of the window. */
2795 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
2796 top
+ height
- max (0, scroll_amount
),
2798 > xp
.bufpos
- ep
.bufpos
- 20)
2799 /* Return "try normal display with same window-start."
2800 Too bad we can't prevent further scroll-thinking. */
2802 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
2803 top
+ height
- max (0, scroll_amount
),
2804 scroll_amount
, ep
.bufpos
);
2805 if (!tem
) stop_vpos
= height
;
2809 /* In any case, do not display past bottom of window */
2810 if (stop_vpos
>= height
)
2816 /* Handle case where pos is before w->start --
2817 can happen if part of line had been clipped and is not clipped now */
2818 if (vpos
== 0 && pos
< marker_position (w
->start
))
2819 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2821 val
.bytepos
= pos_byte
;
2823 /* Redisplay the lines where the text was changed */
2824 last_text_vpos
= vpos
;
2825 /* The following code is omitted because we maintain tab offset in
2828 tab_offset
= pos_tab_offset (w
, pos
, pos_byte
);
2829 /* If we are starting display in mid-character, correct tab_offset
2830 to account for passing the line that that character really starts in. */
2831 if (val
.hpos
< lmargin
)
2832 tab_offset
+= width
;
2835 while (vpos
< stop_vpos
)
2837 val
= *display_text_line (w
, pos
, val
.bytepos
, top
+ vpos
++,
2838 val
.hpos
, val
.tab_offset
,
2839 val
.ovstring_chars_done
);
2840 /* If display_text_line ran a hook and changed some text,
2841 redisplay all the way to bottom of buffer
2842 So that we show the changes. */
2843 if (old_tick
!= MODIFF
)
2845 /* The following code is omitted because we maintain tab offset
2846 in val.tab_offset. */
2848 tab_offset
+= width
;
2849 if (val
.vpos
) tab_offset
= 0;
2851 if (pos
!= val
.bufpos
)
2853 /* Next line, unless prev line ended in end of buffer with no cr */
2854 = vpos
- (val
.vpos
&& FETCH_BYTE (val
.bytepos
- 1) != '\n');
2858 /* There are two cases:
2859 1) we have displayed down to the bottom of the window
2860 2) we have scrolled lines below stop_vpos by scroll_amount */
2864 /* If last line is continued in middle of character,
2865 include the split character in the text considered on the frame */
2866 if (val
.hpos
< lmargin
)
2868 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
);
2869 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2872 /* If scrolling made blank lines at window bottom,
2873 redisplay to fill those lines */
2874 if (scroll_amount
< 0)
2876 /* Don't consider these lines for general-purpose scrolling.
2877 That will save time in the scrolling computation. */
2878 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
2881 pos_byte
= xp
.bytepos
;
2883 val
.tab_offset
= xp
.tab_offset
;
2885 { /* Display from next line */
2886 vpos
= height
+ scroll_amount
;
2890 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
2892 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
2893 val
.tab_offset
= xp
.tab_offset
+ bp
.prevhpos
- width
;
2894 DEC_BOTH (pos
, pos_byte
);
2897 blank_end_of_window
= 1;
2898 /* The following code is omitted because we maintain tab offset
2899 in val.tab_offset. */
2901 tab_offset
= pos_tab_offset (w
, pos
, pos_byte
);
2902 /* If we are starting display in mid-character, correct tab_offset
2903 to account for passing the line that that character starts in. */
2904 if (val
.hpos
< lmargin
)
2905 tab_offset
+= width
;
2907 val
.bytepos
= pos_byte
;
2908 while (vpos
< height
)
2910 val
= *display_text_line (w
, pos
, val
.bytepos
,
2911 top
+ vpos
++, val
.hpos
,
2912 val
.tab_offset
, val
.ovstring_chars_done
);
2913 /* The following code is omitted because we maintain tab
2914 offset in val.tab_offset. */
2916 tab_offset
+= width
;
2917 if (val
.vpos
) tab_offset
= 0;
2922 /* Here is a case where display_text_line sets cursor_vpos wrong.
2923 Make it be fixed up, below. */
2929 /* If bottom just moved off end of frame, change mode line percentage. */
2930 if (XFASTINT (w
->window_end_pos
) == 0
2932 w
->update_mode_line
= Qt
;
2934 /* Attempt to adjust end-of-text positions to new bottom line */
2937 delta
= height
- xp
.vpos
;
2939 || (delta
> 0 && xp
.bufpos
<= ZV
)
2940 || (delta
== 0 && xp
.hpos
))
2942 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), delta
, w
);
2943 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2944 XSETFASTINT (w
->window_end_vpos
,
2945 XFASTINT (w
->window_end_vpos
) + val
.vpos
);
2949 w
->window_end_valid
= Qnil
;
2951 /* If point was not in a line that was displayed, find it */
2952 if (cursor_vpos
< 0)
2955 val
= *compute_motion (start
, 0, lmargin
, 0, PT
,
2956 /* Don't care for VPOS... */
2957 1 << (BITS_PER_SHORT
- 1),
2959 1 << (BITS_PER_SHORT
- 1),
2961 pos_tab_offset (w
, start
, start_byte
),
2963 /* Admit failure if point is off frame now */
2964 if (val
.vpos
>= height
)
2966 for (vpos
= 0; vpos
< height
; vpos
++)
2967 cancel_line (vpos
+ top
, f
);
2970 cursor_vpos
= val
.vpos
+ top
;
2971 cursor_hpos
= WINDOW_LEFT_MARGIN (w
) + minmax (0, val
.hpos
, width
);
2974 FRAME_CURSOR_X (f
) = cursor_hpos
;
2975 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2979 val
= *compute_motion (start
, 0, lmargin
, 0, ZV
,
2980 height
, - (1 << (BITS_PER_SHORT
- 1)),
2982 pos_tab_offset (w
, start
, start_byte
),
2984 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
2986 if (XFASTINT (w
->window_end_pos
)
2994 /* Copy LEN glyphs starting address FROM to the rope TO.
2995 But don't actually copy the parts that would come in before S.
2996 Value is TO, advanced past the copied data.
2997 F is the frame we are displaying in. */
3000 copy_part_of_rope (f
, to
, s
, from
, len
, face
)
3002 register GLYPH
*to
; /* Copy to here. */
3003 register GLYPH
*s
; /* Starting point. */
3004 Lisp_Object
*from
; /* Data to copy. */
3006 int face
; /* Face to apply to glyphs which don't specify one. */
3009 register Lisp_Object
*fp
= from
;
3010 /* These cache the results of the last call to compute_glyph_face. */
3012 int last_merged
= 0;
3015 if (! FRAME_TERMCAP_P (f
))
3018 GLYPH glyph
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
3020 unsigned int c
= FAST_GLYPH_CHAR (glyph
);
3023 /* For an invalid character code, use space. */
3026 if (FAST_GLYPH_FACE (glyph
) == 0)
3027 /* If GLYPH has no face code, use FACE. */
3029 else if (FAST_GLYPH_FACE (glyph
) == last_code
)
3030 /* If it's same as previous glyph, use same result. */
3031 facecode
= last_merged
;
3034 /* Merge this glyph's face and remember the result. */
3035 last_code
= FAST_GLYPH_FACE (glyph
);
3036 last_merged
= facecode
= compute_glyph_face (f
, last_code
, face
);
3040 *to
= FAST_MAKE_GLYPH (c
, facecode
);
3048 if (to
>= s
) *to
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
3055 /* Correct a glyph by replacing its specified user-level face code
3056 with a displayable computed face code. */
3059 fix_glyph (f
, glyph
, cface
)
3065 if (! FRAME_TERMCAP_P (f
))
3067 if (FAST_GLYPH_FACE (glyph
) != 0)
3068 cface
= compute_glyph_face (f
, FAST_GLYPH_FACE (glyph
), cface
);
3069 glyph
= FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph
), cface
);
3075 /* Return the column of position POS / POS_BYTE in window W's buffer.
3076 When used on the character at the beginning of a line,
3077 starting at column 0, this says how much to subtract from
3078 the column position of any character in the line
3079 to get its horizontal position on the screen. */
3082 pos_tab_offset (w
, pos
, pos_byte
)
3084 register int pos
, pos_byte
;
3087 int opoint_byte
= PT_BYTE
;
3089 int width
= window_internal_width (w
) - 1;
3092 return MINI_WINDOW_P (w
) ? -minibuf_prompt_width
: 0;
3094 if (FETCH_BYTE (pos_byte
- 1) == '\n')
3097 TEMP_SET_PT_BOTH (pos
, pos_byte
);
3098 col
= current_column ();
3099 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
3104 /* Display one line of window W, starting at char position START in W's buffer.
3105 START_BYTE is the corresponding byte position.
3107 Display starting at horizontal position HPOS, expressed relative to
3108 W's left edge. In situations where the text at START shouldn't
3109 start at the left margin (i.e. when the window is hscrolled, or
3110 we're continuing a line which left off in the midst of a
3111 multi-column character), HPOS should be negative; we throw away
3112 characters up 'til hpos = 0. So, HPOS must take hscrolling into
3115 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
3117 OVSTR_DONE is the number of chars of overlay before/after strings
3118 at this position which have already been processed.
3120 Display on position VPOS on the frame. It is origin 0, relative to
3121 the top of the frame, not W.
3123 Returns a STRUCT POSITION giving character to start next line with
3124 and where to display it, including a zero or negative hpos.
3125 The vpos field is not really a vpos; it is 1 unless the line is continued */
3127 struct position val_display_text_line
;
3129 static struct position
*
3130 display_text_line (w
, start
, start_byte
, vpos
, hpos
, taboffset
, ovstr_done
)
3138 register int pos
= start
;
3139 int pos_byte
= start_byte
;
3142 int pause
, limit_byte
;
3143 register unsigned char *p
;
3145 register GLYPH
*leftmargin
;
3146 register GLYPH
*p1prev
;
3147 register GLYPH
*p1start
;
3148 GLYPH
*p1_wide_column_end
= (GLYPH
*) 0;
3149 int prevpos
, prevpos_byte
;
3151 FRAME_PTR f
= XFRAME (w
->frame
);
3152 int tab_width
= XINT (current_buffer
->tab_width
);
3153 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
3154 int width
= window_internal_width (w
) - 1;
3155 struct position val
;
3156 int lastpos
, lastpos_byte
;
3158 int last_invis_skip
= 0;
3159 Lisp_Object last_invis_prop
;
3160 int hscroll
= XINT (w
->hscroll
);
3161 int truncate
= (hscroll
3162 || (truncate_partial_width_windows
3163 && !WINDOW_FULL_WIDTH_P (w
))
3164 || !NILP (current_buffer
->truncate_lines
));
3166 /* 1 if this buffer has a region to highlight. */
3167 int highlight_region
3168 = (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
)
3169 && XMARKER (current_buffer
->mark
)->buffer
!= 0);
3170 int region_beg
, region_end
;
3172 int selective
= (INTEGERP (current_buffer
->selective_display
)
3173 ? XINT (current_buffer
->selective_display
)
3174 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
3175 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
3176 register struct Lisp_Char_Table
*dp
= window_display_table (w
);
3178 Lisp_Object default_invis_vector
[3];
3179 /* Number of characters of ellipsis to display after an invisible line
3180 if it calls for an ellipsis.
3181 Note that this value can be nonzero regardless of whether
3182 selective display is enabled--you must check that separately. */
3184 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
3185 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
3186 : !NILP (current_buffer
->selective_display_ellipses
) ? 3 : 0);
3187 /* This is the sequence of Lisp objects to display
3188 when there are invisible lines. */
3189 Lisp_Object
*invis_vector_contents
3190 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
3191 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
3192 : default_invis_vector
);
3194 GLYPH truncator
= (dp
== 0 || !INTEGERP (DISP_TRUNC_GLYPH (dp
))
3195 || !GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (dp
)))
3196 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
3197 GLYPH continuer
= (dp
== 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp
))
3198 || !GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (dp
)))
3199 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
3201 /* If 1, we must handle multibyte characters. */
3202 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
3203 /* Length of multibyte form of each character. */
3205 /* Glyphs generated should be set this bit mask if text must be
3206 displayed from right to left. */
3207 GLYPH rev_dir_bit
= (NILP (current_buffer
->direction_reversed
)
3208 ? 0 : GLYPH_MASK_REV_DIR
);
3210 /* The next buffer location at which the face should change, due
3211 to overlays or text property changes. */
3212 int next_face_change
;
3214 /* The next location where the `invisible' property changes, or an
3215 overlay starts or ends. */
3218 /* The face we're currently using. */
3219 int current_face
= 0;
3222 XSETFASTINT (default_invis_vector
[2], '.');
3223 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
3225 get_display_line (f
, vpos
, WINDOW_LEFT_MARGIN (w
));
3226 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
3228 /* Show where to highlight the region. */
3229 if (highlight_region
3230 /* Maybe highlight only in selected window. */
3231 && (highlight_nonselected_windows
3232 || w
== XWINDOW (selected_window
)
3233 || (MINI_WINDOW_P (XWINDOW (selected_window
))
3234 && w
== XWINDOW (Vminibuf_scroll_window
))))
3236 region_beg
= marker_position (current_buffer
->mark
);
3237 if (PT
< region_beg
)
3239 region_end
= region_beg
;
3244 w
->region_showing
= Qt
;
3248 region_beg
= region_end
= -1;
3249 w
->region_showing
= Qnil
;
3252 if (MINI_WINDOW_P (w
)
3254 && vpos
== XFASTINT (w
->top
))
3256 if (! NILP (minibuf_prompt
))
3258 int old_width
= minibuf_prompt_width
;
3260 minibuf_prompt_width
3261 = (display_string (w
, vpos
, XSTRING (minibuf_prompt
)->data
,
3262 STRING_BYTES (XSTRING (minibuf_prompt
)),
3263 hpos
+ WINDOW_LEFT_MARGIN (w
),
3264 /* Display a space if we truncate. */
3267 /* Truncate the prompt a little before the
3268 margin, so user input can at least start
3269 on the first line. */
3270 (XFASTINT (w
->width
) > 10
3271 ? XFASTINT (w
->width
) - 4 : -1),
3272 STRING_MULTIBYTE (minibuf_prompt
))
3273 - hpos
- WINDOW_LEFT_MARGIN (w
));
3274 hpos
+= minibuf_prompt_width
;
3275 taboffset
-= minibuf_prompt_width
- old_width
;
3278 minibuf_prompt_width
= 0;
3281 /* If we're hscrolled at all, use compute_motion to skip over any
3282 text off the left edge of the window. compute_motion may know
3283 tricks to do this faster than we can. */
3286 struct position
*left_edge
3287 = compute_motion (pos
, vpos
, hpos
, 0,
3289 width
, hscroll
, taboffset
, w
);
3291 /* Retrieve the buffer position and column provided by
3292 compute_motion. We can't assume that the column will be
3293 zero, because you may have multi-column characters crossing
3296 compute_motion may have moved us past the screen position we
3297 requested, if we hit a multi-column character, or the end of
3298 the line. If so, back up. */
3299 if (left_edge
->vpos
> vpos
3300 || left_edge
->hpos
> 0)
3302 pos
= left_edge
->bufpos
;
3303 pos_byte
= left_edge
->bytepos
;
3304 DEC_BOTH (pos
, pos_byte
);
3305 hpos
= left_edge
->prevhpos
;
3309 pos
= left_edge
->bufpos
;
3310 pos_byte
= left_edge
->bytepos
;
3311 hpos
= left_edge
->hpos
;
3315 hpos
+= WINDOW_LEFT_MARGIN (w
);
3317 desired_glyphs
->bufp
[vpos
] = start
;
3318 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
3320 charstart
= desired_glyphs
->charstarts
[vpos
] + hpos
;
3321 /* In case we don't ever write anything into it... */
3322 desired_glyphs
->charstarts
[vpos
][WINDOW_LEFT_MARGIN (w
)] = -1;
3323 leftmargin
= desired_glyphs
->glyphs
[vpos
] + WINDOW_LEFT_MARGIN (w
);
3324 endp
= leftmargin
+ width
;
3326 /* Arrange the overlays nicely for our purposes. Usually, we call
3327 display_text_line on only one line at a time, in which case this
3328 can't really hurt too much, or we call it on lines which appear
3329 one after another in the buffer, in which case all calls to
3330 recenter_overlay_lists but the first will be pretty cheap. */
3331 recenter_overlay_lists (current_buffer
, pos
);
3333 /* Loop generating characters.
3334 Stop at end of buffer, before newline,
3335 if reach or pass continuation column,
3336 or at face change. */
3338 limit_byte
= pos_byte
;
3339 next_face_change
= pos
;
3340 next_boundary
= pos
;
3343 prevpos_byte
= pos_byte
;
3345 /* If the window is hscrolled and point is in the invisible part of the
3346 current line beyond the left margin we can record the cursor location
3348 if (hscroll
&& start
<= PT
&& PT
< pos
&& cursor_vpos
< 0)
3351 cursor_hpos
= p1
- leftmargin
;
3356 int eat_following_binary_data
;
3362 while (pos
== next_boundary
)
3364 Lisp_Object position
, limit
, prop
, ww
;
3366 /* Display the overlay strings here, unless we're at ZV
3367 and have already displayed the appropriate strings
3368 on an earlier line. */
3369 if (pos
< ZV
|| !zv_strings_seen
++)
3372 unsigned char *ovstr
;
3373 ovlen
= overlay_strings (pos
, w
, &ovstr
);
3377 /* Skip the ones we did in a previous line. */
3378 ovstr
+= ovstr_done
;
3379 ovlen
-= ovstr_done
;
3388 c
= STRING_CHAR_AND_LENGTH (ovstr
, ovlen
, len
);
3389 ovstr
+= len
, ovlen
-= len
, ovstr_done
+= len
;
3390 charset
= CHAR_CHARSET (c
);
3391 cols
= (charset
== CHARSET_COMPOSITION
3392 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
3393 : CHARSET_WIDTH (charset
));
3397 c
= *ovstr
++, ovlen
--, ovstr_done
++;
3400 g
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3403 if (p1
>= leftmargin
&& p1
< endp
)
3404 *p1
= g
, g
|= GLYPH_MASK_PADDING
;
3408 /* If we did all the overlay strings
3409 and we have room for text, clear ovstr_done
3410 just for neatness' sake. */
3411 if (ovlen
== 0 && p1
< endp
)
3416 /* Did we reach point? Record the cursor location. */
3417 if (pos
== PT
&& cursor_vpos
< 0)
3420 cursor_hpos
= p1
- leftmargin
;
3426 XSETFASTINT (position
, pos
);
3427 limit
= Fnext_overlay_change (position
);
3428 #ifdef USE_TEXT_PROPERTIES
3429 /* This is just an estimate to give reasonable
3430 performance; nothing should go wrong if it is too small. */
3431 if (XFASTINT (limit
) > pos
+ 50)
3433 int limitpos
= pos
+ 50;
3434 XSETFASTINT (limit
, limitpos
);
3436 limit
= Fnext_single_property_change (position
, Qinvisible
,
3437 Fcurrent_buffer (), limit
);
3439 next_boundary
= XFASTINT (limit
);
3440 /* if the `invisible' property is set, we can skip to
3441 the next property change. */
3443 prop
= Fget_char_property (position
, Qinvisible
, ww
);
3444 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
3446 if (pos
< PT
&& next_boundary
>= PT
)
3449 cursor_hpos
= p1
- leftmargin
;
3451 pos
= next_boundary
;
3452 pos_byte
= CHAR_TO_BYTE (pos
);
3453 last_invis_skip
= pos
;
3454 last_invis_prop
= prop
;
3458 /* Did we reach point? Record the cursor location. */
3459 if (pos
== PT
&& cursor_vpos
< 0)
3462 cursor_hpos
= p1
- leftmargin
;
3465 /* Did we hit the end of the visible region of the buffer?
3469 /* Update charstarts for the end of this line. */
3470 /* Do nothing if off the left edge or at the right edge. */
3471 if (p1
>= leftmargin
&& p1
+ 1 != endp
)
3473 int *p2x
= &charstart
[(p1
< leftmargin
3481 /* Figure out where (if at all) the
3482 redisplay_end_trigger-hook should run. */
3483 if (MARKERP (w
->redisplay_end_trigger
)
3484 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
3485 e_t_h
= marker_position (w
->redisplay_end_trigger
);
3486 else if (INTEGERP (w
->redisplay_end_trigger
))
3487 e_t_h
= XINT (w
->redisplay_end_trigger
);
3491 /* If we've gone past the place to run a hook,
3493 if (pos
>= e_t_h
&& e_t_h
!= ZV
)
3495 Lisp_Object args
[3];
3497 args
[0] = Qredisplay_end_trigger_functions
;
3498 XSETWINDOW (args
[1], w
);
3499 XSETINT (args
[2], e_t_h
);
3501 /* Since we are *trying* to run these functions,
3502 don't try to run them again, even if they get an error. */
3503 w
->redisplay_end_trigger
= Qnil
;
3504 Frun_hook_with_args (3, args
);
3507 /* Notice if it changed the face of this character. */
3508 next_face_change
= pos
;
3512 /* Did we hit a face change? Figure out what face we should
3513 use now. We also hit this the first time through the
3514 loop, to see what face we should start with. */
3515 if (pos
>= next_face_change
3516 && (FRAME_WINDOW_P (f
) || FRAME_MSDOS_P (f
)))
3518 int limit
= pos
+ 50;
3520 current_face
= compute_char_face (f
, w
, pos
,
3521 region_beg
, region_end
,
3522 &next_face_change
, limit
, 0);
3526 /* Compute the next place we need to stop
3527 and do something special; set PAUSE. */
3531 if (pos
< next_boundary
&& next_boundary
< pause
)
3532 pause
= next_boundary
;
3533 if (pos
< next_face_change
&& next_face_change
< pause
)
3534 pause
= next_face_change
;
3539 /* Wouldn't you hate to read the next line to someone over
3541 if (pos
< PT
&& PT
< pause
)
3543 if (pos
< GPT
&& GPT
< pause
)
3546 /* LIMIT_BYTE is not the same place in the buffer as PAUSE.
3547 It is a limit on valid characters.
3548 We use it to bound STRING_CHAR_AND_LENGTH. */
3549 limit_byte
= ZV_BYTE
;
3550 if (pos
< GPT
&& GPT_BYTE
< limit_byte
)
3551 limit_byte
= GPT_BYTE
;
3554 int temp
= CHAR_TO_BYTE (pos
);
3555 p
= BYTE_POS_ADDR (temp
);
3563 p1_wide_column_end
= (GLYPH
*) 0;
3566 c
= STRING_CHAR_AND_LENGTH (p
, limit_byte
- pos_byte
, len
), p
+= len
;
3569 /* Let a display table override all standard display methods. */
3570 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
3572 p1
= copy_part_of_rope (f
, p1
, leftmargin
,
3573 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
3574 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
3575 current_face
, rev_dir_bit
);
3577 else if (c
>= 040 && c
< 0177)
3579 if (p1
>= leftmargin
)
3580 *p1
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3586 /* Same as p1prev, but after the invis_vector_contents text
3587 (if we have that on this line). */
3588 GLYPH
*p1prev_modified
;
3592 if (last_invis_skip
== pos
3593 && TEXT_PROP_MEANS_INVISIBLE_WITH_ELLIPSIS (last_invis_prop
))
3597 && indented_beyond_p (pos
+ 1, pos_byte
+ 1, selective
))
3599 int opoint
= PT
, opoint_byte
= PT_BYTE
;
3602 INC_BOTH (pos
, pos_byte
);
3603 scan_newline (pos
, pos_byte
, ZV
, ZV_BYTE
, 1, 1);
3604 if (FETCH_BYTE (pos_byte
- 1) == '\n')
3609 SET_PT_BOTH (opoint
, opoint_byte
);
3611 if (invis
&& selective_rlen
> 0 && p1
>= leftmargin
)
3616 cs
= charstart
+ (p1
- p1start
);
3619 p1
+= selective_rlen
;
3620 if (p1
- leftmargin
> width
)
3623 #if 0 /* This needs more work; charstarts needs to record
3624 both whether a position ho;ds an ellipsis character
3625 and what buffer position it corresponds to. */
3626 csend
= charstart
+ (p1
- p1start
);
3629 /* The idea is to use p1prev_modified instead of p1prev
3630 in the loop below over p2x. */
3631 p1prev_modified
= p1
;
3634 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
3635 (p1
- p1prev
), current_face
, rev_dir_bit
);
3638 /* Update charstarts for the newline that ended this line. */
3639 /* Do nothing here for a char that's entirely off the left edge
3640 or if it starts at the right edge. */
3641 if (p1
>= leftmargin
&& p1prev
!= endp
)
3643 /* Store the newline's position into charstarts
3644 for the column where the newline starts.
3645 Store -1 for the rest of the glyphs it occupies. */
3646 int *p2x
= &charstart
[(p1prev
< leftmargin
3647 ? leftmargin
: p1prev
)
3649 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3656 /* Draw the face of the newline character as extending all the
3657 way to the end of the frame line. */
3660 if (p1
< leftmargin
)
3663 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
) | rev_dir_bit
;
3673 if (p1
>= leftmargin
&& p1
< endp
)
3674 *p1
= MAKE_GLYPH (f
, ' ', current_face
) | rev_dir_bit
;
3677 while ((p1
- leftmargin
+ taboffset
+ hscroll
- (hscroll
> 0))
3680 else if (c
== Ctl ('M') && selective
== -1)
3682 int opoint
= PT
, opoint_byte
= PT_BYTE
;
3683 scan_newline (pos
, pos_byte
, ZV
, ZV_BYTE
, 1, 1);
3684 pos
= PT
, pos_byte
= PT_BYTE
;
3685 SET_PT_BOTH (opoint
, opoint_byte
);
3687 if (FETCH_BYTE (pos_byte
- 1) == '\n')
3689 if (selective_rlen
> 0)
3691 p1
+= selective_rlen
;
3692 if (p1
- leftmargin
> width
)
3694 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
3695 (p1
- p1prev
), current_face
, rev_dir_bit
);
3698 /* Draw the face of the newline character as extending all the
3699 way to the end of the frame line. */
3702 if (p1
< leftmargin
)
3705 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
) | rev_dir_bit
;
3709 /* Update charstarts for the ^M that ended this line. */
3710 /* Do nothing here for a char that's entirely off the left edge
3711 or if it starts at the right edge. */
3712 if (p1
>= leftmargin
&& p1prev
!= endp
)
3714 /* Store the newline's position into charstarts
3715 for the column where the newline starts.
3716 Store -1 for the rest of the glyphs it occupies. */
3717 int *p2x
= &charstart
[(p1prev
< leftmargin
3718 ? leftmargin
: p1prev
)
3720 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3728 else if (c
< 0200 && ctl_arrow
)
3730 if (p1
>= leftmargin
)
3732 (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
3733 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp
)))
3734 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
3738 if (p1
>= leftmargin
&& p1
< endp
)
3739 *p1
= MAKE_GLYPH (f
, c
^ 0100, current_face
) | rev_dir_bit
;
3744 /* C is not a multibyte character. */
3745 eat_following_binary_data
= multibyte
&& BASE_LEADING_CODE_P (c
);
3747 label_display_binary_data
:
3749 if (p1
>= leftmargin
&& p1
< endp
)
3751 (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
3752 && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp
)))
3753 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
3757 if (p1
>= leftmargin
&& p1
< endp
)
3758 *p1
= MAKE_GLYPH (f
, (c
>> 6) + '0', current_face
) | rev_dir_bit
;
3760 if (p1
>= leftmargin
&& p1
< endp
)
3761 *p1
= (MAKE_GLYPH (f
, (7 & (c
>> 3)) + '0', current_face
)
3764 if (p1
>= leftmargin
&& p1
< endp
)
3765 *p1
= MAKE_GLYPH (f
, (7 & c
) + '0', current_face
) | rev_dir_bit
;
3767 } while (eat_following_binary_data
3768 && (pos_byte
+ len
) < limit_byte
3769 && ! CHAR_HEAD_P (*p
)
3770 && ((c
= *p
++), len
++));
3774 /* C is a multibyte character. */
3775 int charset
= CHAR_CHARSET (c
);
3776 int columns
= (charset
== CHARSET_COMPOSITION
3777 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
3778 : CHARSET_WIDTH (charset
));
3779 GLYPH g
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3783 if (p1
>= leftmargin
&& p1
< endp
)
3784 *p1
= g
, g
|= GLYPH_MASK_PADDING
;
3788 p1_wide_column_end
= p1
;
3789 /* Check if binary data follows it. */
3790 if (pos_byte
+ len
< limit_byte
3791 && ! CHAR_HEAD_P (*p
))
3793 eat_following_binary_data
= 1;
3796 goto label_display_binary_data
;
3801 prevpos_byte
= pos_byte
;
3805 /* Update charstarts for the character just output. */
3807 /* Do nothing here for a char that's entirely off the left edge. */
3808 if (p1
>= leftmargin
)
3810 /* Store the char's position into charstarts
3811 for the first glyph occupied by this char.
3812 Store -1 for the rest of the glyphs it occupies. */
3815 int *p2x
= &charstart
[(p1prev
< leftmargin
3816 ? leftmargin
: p1prev
)
3818 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3828 val
.hpos
= - XINT (w
->hscroll
);
3835 lastpos_byte
= pos_byte
;
3837 /* Store 0 in this charstart line for the positions where
3838 there is no character. But do leave what was recorded
3839 for the character that ended the line. */
3840 /* Add 1 in the endtest to compensate for the fact that ENDP was
3841 made from WIDTH, which is 1 less than the window's actual
3843 i
= p1
- p1start
+ 1;
3844 if (p1
< leftmargin
)
3845 i
+= leftmargin
- p1
;
3846 for (; i
< endp
- p1start
+ 1; i
++)
3849 /* Handle continuation in middle of a character */
3850 /* by backing up over it */
3853 /* Don't back up if we never actually displayed any text.
3854 This occurs when the minibuffer prompt takes up the whole line. */
3857 /* Start the next line with that same character whose
3858 character code is C and the length of multi-byte form is
3861 pos_byte
= prevpos_byte
;
3863 if (p1_wide_column_end
< endp
)
3864 /* As ENDP is not in the middle of wide-column character,
3865 we can break the line at ENDP and start from the middle
3866 column in the next line. So, adjust VAL.HPOS to skip
3867 the columns output on this line. */
3868 val
.hpos
+= p1prev
- endp
;
3871 /* We displayed a wide-column character at around ENDP.
3872 Since we can't broke it in the middle, the whole
3873 character should be driven into the next line. */
3874 /* As the result, the actual columns occupied by the
3875 text on this line is less than WIDTH. VAL.TAB_OFFSET
3876 must be adjusted. */
3877 taboffset
= taboffset
+ (p1prev
- endp
);
3878 /* Let's fill unused columns with TRUNCATOR or CONTINUER. */
3880 GLYPH g
= fix_glyph (f
, truncate
? truncator
: continuer
, 0);
3881 while (p1prev
< endp
)
3884 /* If POINT is at POS, cursor should not on this line. */
3886 lastpos_byte
= pos_byte
;
3892 /* Keep in this line everything up to the continuation column. */
3896 /* Finish deciding which character to start the next line on,
3897 and what hpos to start it at.
3898 Also set `lastpos' to the last position which counts as "on this line"
3899 for cursor-positioning. */
3903 if (FETCH_BYTE (pos_byte
) == '\n')
3905 int opoint
= PT
, opoint_byte
= PT_BYTE
;
3907 /* If stopped due to a newline, start next line after it */
3908 SET_PT_BOTH (pos
+ 1, pos_byte
+ 1);
3911 /* Check again for hidden lines, in case the newline occurred exactly
3912 at the right margin. */
3913 while (PT
< ZV
&& selective
> 0
3914 && indented_beyond_p (PT
, PT_BYTE
, selective
))
3915 scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, 1, 1);
3917 pos
= PT
, pos_byte
= PT_BYTE
;
3918 SET_PT_BOTH (opoint
, opoint_byte
);
3921 /* Stopped due to right margin of window */
3925 int opoint
= PT
, opoint_byte
= PT_BYTE
;
3927 SET_PT_BOTH (pos
, pos_byte
);
3928 *p1
++ = fix_glyph (f
, truncator
, 0);
3929 /* Truncating => start next line after next newline,
3930 and point is on this line if it is before the newline,
3931 and skip none of first char of next line */
3933 scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, 1, 1);
3934 while (PT
< ZV
&& selective
> 0
3935 && indented_beyond_p (PT
, PT_BYTE
, selective
));
3936 pos
= PT
, pos_byte
= PT_BYTE
;
3937 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
3938 SET_PT_BOTH (opoint
, opoint_byte
);
3940 lastpos
= pos
- (FETCH_BYTE (pos_byte
- 1) == '\n');
3941 lastpos_byte
= CHAR_TO_BYTE (lastpos
);
3946 *p1
++ = fix_glyph (f
, continuer
, 0);
3948 DEC_BOTH (lastpos
, lastpos_byte
);
3949 val
.tab_offset
= taboffset
+ width
;
3956 /* If point is at eol or in invisible text at eol,
3957 record its frame location now. */
3959 if (start
<= PT
&& PT
<= lastpos
&& cursor_vpos
< 0)
3962 cursor_hpos
= p1
- leftmargin
;
3965 if (cursor_vpos
== vpos
)
3967 if (cursor_hpos
< 0) cursor_hpos
= 0;
3968 if (cursor_hpos
> width
) cursor_hpos
= width
;
3969 cursor_hpos
+= WINDOW_LEFT_MARGIN (w
);
3970 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
3972 if (!(cursor_in_echo_area
&& FRAME_HAS_MINIBUF_P (f
)
3973 && EQ (FRAME_MINIBUF_WINDOW (f
), minibuf_window
)))
3975 FRAME_CURSOR_Y (f
) = cursor_vpos
;
3976 FRAME_CURSOR_X (f
) = cursor_hpos
;
3979 if (w
== XWINDOW (selected_window
))
3981 /* Line is not continued and did not start
3982 in middle of character */
3983 if ((hpos
- WINDOW_LEFT_MARGIN (w
)
3984 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
3987 this_line_bufpos
= start
;
3988 this_line_buffer
= current_buffer
;
3989 this_line_vpos
= cursor_vpos
;
3990 this_line_start_hpos
= hpos
- WINDOW_LEFT_MARGIN (w
);
3991 this_line_endpos
= Z
- lastpos
;
3994 this_line_bufpos
= 0;
3999 /* If hscroll and line not empty, insert truncation-at-left marker */
4000 if (hscroll
&& lastpos
!= start
)
4002 GLYPH g
= fix_glyph (f
, truncator
, 0);
4004 if (p1
<= leftmargin
)
4005 p1
= leftmargin
+ 1;
4006 else /* MULE: it may be a wide-column character */
4008 p1prev
= leftmargin
+ 1;
4009 while (p1prev
< p1
&& *p1prev
& GLYPH_MASK_PADDING
)
4014 if (!WINDOW_RIGHTMOST_P (w
))
4017 if (p1
< leftmargin
) p1
= leftmargin
;
4018 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
4020 /* Don't draw vertical bars if we're using scroll bars. They're
4021 covered up by the scroll bars, and it's distracting to see
4022 them when the scroll bar windows are flickering around to be
4024 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4027 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
4030 else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4031 *p1
++ = (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
4032 ? XINT (DISP_BORDER_GLYPH (dp
))
4035 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
4036 p1
- desired_glyphs
->glyphs
[vpos
]);
4037 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
4039 /* If the start of this line is the overlay arrow-position,
4040 then put the arrow string into the display-line. */
4042 if (MARKERP (Voverlay_arrow_position
)
4043 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
4044 && start
== marker_position (Voverlay_arrow_position
)
4045 && STRINGP (Voverlay_arrow_string
)
4046 && ! overlay_arrow_seen
)
4049 int len
= XSTRING (Voverlay_arrow_string
)->size
;
4055 /* If the arrow string has text props, obey them when displaying. */
4056 for (i
= 0, i_byte
= 0; i
< len
; )
4059 Lisp_Object face
, ilisp
;
4063 if (STRING_MULTIBYTE (Voverlay_arrow_string
))
4064 FETCH_STRING_CHAR_ADVANCE (c
, Voverlay_arrow_string
, i
, i_byte
);
4066 c
= XSTRING (Voverlay_arrow_string
)->data
[i
++];
4068 XSETFASTINT (ilisp
, i
);
4070 if (FRAME_WINDOW_P (f
))
4072 face
= Fget_text_property (ilisp
, Qface
, Voverlay_arrow_string
);
4073 newface
= compute_glyph_face_1 (f
, face
, 0);
4074 c
= FAST_MAKE_GLYPH (c
, newface
);
4076 #endif /* HAVE_FACES */
4077 leftmargin
[idx
] = c
;
4080 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
4081 arrow_end
= (leftmargin
- desired_glyphs
->glyphs
[vpos
]) + len
;
4082 if (desired_glyphs
->used
[vpos
] < arrow_end
)
4083 desired_glyphs
->used
[vpos
] = arrow_end
;
4085 overlay_arrow_seen
= 1;
4089 val
.bytepos
= pos_byte
;
4090 val
.ovstring_chars_done
= ovstr_done
;
4091 val_display_text_line
= val
;
4092 return &val_display_text_line
;
4095 /* Redisplay the menu bar in the frame for window W. */
4098 display_menu_bar (w
)
4101 Lisp_Object items
, tail
;
4102 register int vpos
= 0;
4103 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4104 int maxendcol
= FRAME_WIDTH (f
);
4109 if (!NILP (Vwindow_system
))
4113 #ifdef USE_X_TOOLKIT
4116 #endif /* USE_X_TOOLKIT */
4118 get_display_line (f
, vpos
, 0);
4120 items
= FRAME_MENU_BAR_ITEMS (f
);
4121 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
4123 Lisp_Object pos
, string
;
4124 string
= XVECTOR (items
)->contents
[i
+ 1];
4128 XSETFASTINT (XVECTOR (items
)->contents
[i
+ 3], hpos
);
4130 if (hpos
< maxendcol
)
4131 hpos
= display_string (w
, vpos
,
4132 XSTRING (string
)->data
,
4133 STRING_BYTES (XSTRING (string
)),
4134 hpos
, 0, 0, hpos
, maxendcol
,
4135 STRING_MULTIBYTE (string
));
4136 /* Put a space between items. */
4137 if (hpos
< maxendcol
)
4139 int hpos1
= hpos
+ 1;
4140 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0,
4141 min (hpos1
, maxendcol
), maxendcol
, 0);
4145 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
4146 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
4148 /* Fill out the line with spaces. */
4149 if (maxendcol
> hpos
)
4150 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0, maxendcol
, maxendcol
, 0);
4152 /* Clear the rest of the lines allocated to the menu bar. */
4154 while (vpos
< FRAME_MENU_BAR_LINES (f
))
4155 get_display_line (f
, vpos
++, 0);
4158 /* Display the mode line for window w */
4161 display_mode_line (w
)
4164 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
4165 register int left
= WINDOW_LEFT_MARGIN (w
);
4166 register int right
= WINDOW_RIGHT_MARGIN (w
);
4167 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4169 line_number_displayed
= 0;
4170 w
->column_number_displayed
= Qnil
;
4172 get_display_line (f
, vpos
, left
);
4174 /* Temporarily make frame F's kboard the current kboard
4175 so that kboard-local variables in the mode_line_format
4176 will get the right values. */
4177 push_frame_kboard (f
);
4179 display_mode_element (w
, vpos
, left
, 0, right
, right
,
4180 current_buffer
->mode_line_format
);
4182 pop_frame_kboard ();
4184 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
4186 /* Put the mode line in inverse video.
4187 Use faces if possible, since that lets us handle
4188 partial-width windows and avoid inverting the scroll bar columns. */
4190 if (! FRAME_TERMCAP_P (f
) && mode_line_inverse_video
)
4192 /* For a partial width window, explicitly set face of each glyph. */
4194 unsigned int padding
;
4195 GLYPH
*ptr
= FRAME_DESIRED_GLYPHS (f
)->glyphs
[vpos
];
4196 for (i
= left
; i
< right
; ++i
)
4198 padding
= ptr
[i
] & GLYPH_MASK_PADDING
;
4199 ptr
[i
] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr
[i
]), 1) | padding
;
4205 /* Make the mode line inverse video if the entire line
4206 is made of mode lines.
4207 I.e. if this window is full width,
4208 or if it is the child of a full width window
4209 (which implies that that window is split side-by-side
4210 and the rest of this line is mode lines of the sibling windows). */
4211 if (WINDOW_FULL_WIDTH_P (w
)
4212 || WINDOW_FULL_WIDTH_P (XWINDOW (w
->parent
)))
4213 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
4216 /* Contribute ELT to the mode line for window W.
4217 How it translates into text depends on its data type.
4219 VPOS is the position of the mode line being displayed.
4221 HPOS is the position (absolute on frame) where this element's text
4222 should start. The output is truncated automatically at the right
4225 DEPTH is the depth in recursion. It is used to prevent
4226 infinite recursion here.
4228 MINENDCOL is the hpos before which the element may not end.
4229 The element is padded at the right with spaces if nec
4230 to reach this column.
4232 MAXENDCOL is the hpos past which this element may not extend.
4233 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
4234 (This is necessary to make nested padding and truncation work.)
4236 Returns the hpos of the end of the text generated by ELT.
4237 The next element will receive that value as its HPOS arg,
4238 so as to concatenate the elements. */
4241 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
4243 register int vpos
, hpos
;
4246 register int maxendcol
;
4247 register Lisp_Object elt
;
4255 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
4259 /* A string: output it and check for %-constructs within it. */
4260 register unsigned char c
;
4261 register unsigned char *this = XSTRING (elt
)->data
;
4263 while (hpos
< maxendcol
&& *this)
4265 unsigned char *last
= this;
4266 while ((c
= *this++) != '\0' && c
!= '%')
4268 if (this - 1 != last
)
4270 register int lim
= --this - last
+ hpos
;
4271 if (frame_title_ptr
)
4272 hpos
= store_frame_title (last
, hpos
, min (lim
, maxendcol
));
4274 hpos
= display_string (w
, vpos
, last
, -1, hpos
, 0, 1,
4275 hpos
, min (lim
, maxendcol
),
4276 STRING_MULTIBYTE (elt
));
4280 register int minendcol
;
4281 register int spec_width
= 0;
4283 /* We can't allow -ve args due to the "%-" construct */
4284 /* Argument specifies minwidth but not maxwidth
4285 (maxwidth can be specified by
4286 (<negative-number> . <stuff>) mode-line elements) */
4288 while ((c
= *this++) >= '0' && c
<= '9')
4290 spec_width
= spec_width
* 10 + (c
- '0');
4293 minendcol
= hpos
+ spec_width
;
4294 if (minendcol
> maxendcol
)
4296 spec_width
= maxendcol
- hpos
;
4297 minendcol
= maxendcol
;
4301 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
4302 spec_width
, maxendcol
,
4303 Vglobal_mode_string
);
4306 char *spec
= decode_mode_spec (w
, c
, spec_width
,
4308 if (frame_title_ptr
)
4309 hpos
= store_frame_title (spec
, minendcol
, maxendcol
);
4311 hpos
= display_string (w
, vpos
, spec
, -1,
4313 minendcol
, maxendcol
, -1);
4321 /* A symbol: process the value of the symbol recursively
4322 as if it appeared here directly. Avoid error if symbol void.
4323 Special case: if value of symbol is a string, output the string
4326 register Lisp_Object tem
;
4327 tem
= Fboundp (elt
);
4330 tem
= Fsymbol_value (elt
);
4331 /* If value is a string, output that string literally:
4332 don't check for % within it. */
4335 if (frame_title_ptr
)
4336 hpos
= store_frame_title (XSTRING (tem
)->data
,
4337 minendcol
, maxendcol
);
4339 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
4340 STRING_BYTES (XSTRING (tem
)),
4341 hpos
, 0, 1, minendcol
, maxendcol
,
4342 STRING_MULTIBYTE (tem
));
4344 /* Give up right away for nil or t. */
4345 else if (!EQ (tem
, elt
))
4346 { elt
= tem
; goto tail_recurse
; }
4353 register Lisp_Object car
, tem
;
4355 /* A cons cell: three distinct cases.
4356 If first element is a string or a cons, process all the elements
4357 and effectively concatenate them.
4358 If first element is a negative number, truncate displaying cdr to
4359 at most that many characters. If positive, pad (with spaces)
4360 to at least that many characters.
4361 If first element is a symbol, process the cadr or caddr recursively
4362 according to whether the symbol's value is non-nil or nil. */
4363 car
= XCONS (elt
)->car
;
4366 tem
= Fboundp (car
);
4367 elt
= XCONS (elt
)->cdr
;
4370 /* elt is now the cdr, and we know it is a cons cell.
4371 Use its car if CAR has a non-nil value. */
4374 tem
= Fsymbol_value (car
);
4376 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
4378 /* Symbol's value is nil (or symbol is unbound)
4379 Get the cddr of the original list
4380 and if possible find the caddr and use that. */
4381 elt
= XCONS (elt
)->cdr
;
4384 else if (!CONSP (elt
))
4386 elt
= XCONS (elt
)->car
;
4389 else if (INTEGERP (car
))
4391 register int lim
= XINT (car
);
4392 elt
= XCONS (elt
)->cdr
;
4394 /* Negative int means reduce maximum width.
4395 DO NOT change MINENDCOL here!
4396 (20 -10 . foo) should truncate foo to 10 col
4397 and then pad to 20. */
4398 maxendcol
= min (maxendcol
, hpos
- lim
);
4401 /* Padding specified. Don't let it be more than
4404 if (lim
> maxendcol
)
4406 /* If that's more padding than already wanted, queue it.
4407 But don't reduce padding already specified even if
4408 that is beyond the current truncation point. */
4409 if (lim
> minendcol
)
4414 else if (STRINGP (car
) || CONSP (car
))
4416 register int limit
= 50;
4417 /* LIMIT is to protect against circular lists. */
4418 while (CONSP (elt
) && --limit
> 0
4419 && hpos
< maxendcol
)
4421 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
4424 elt
= XCONS (elt
)->cdr
;
4432 if (frame_title_ptr
)
4433 hpos
= store_frame_title ("*invalid*", minendcol
, maxendcol
);
4435 hpos
= display_string (w
, vpos
, "*invalid*", -1, hpos
, 0, 1,
4436 minendcol
, maxendcol
, 0);
4440 if (minendcol
> hpos
)
4441 if (frame_title_ptr
)
4442 hpos
= store_frame_title ("", minendcol
, maxendcol
);
4444 hpos
= display_string (w
, vpos
, "", 0, hpos
,
4445 0, 1, minendcol
, maxendcol
, 0);
4449 /* Write a null-terminated, right justified decimal representation of
4450 the positive integer D to BUF using a minimal field width WIDTH. */
4453 pint2str (buf
, width
, d
)
4458 register char *p
= buf
;
4465 *p
++ = d
% 10 + '0';
4468 for (width
-= (int) (p
- buf
); width
> 0; --width
) *p
++ = ' ';
4478 /* Set a mnemonic character for CODING_SYSTEM (Lisp symbol) in BUF.
4479 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
4480 type of CODING_SYSTEM. Return updated pointer into BUF. */
4483 decode_mode_spec_coding (coding_system
, buf
, eol_flag
)
4484 Lisp_Object coding_system
;
4489 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
4491 val
= coding_system
;
4493 if (NILP (val
)) /* Not yet decided. */
4498 *buf
++ = eol_mnemonic_undecided
;
4499 /* Don't mention EOL conversion if it isn't decided. */
4503 Lisp_Object eolvalue
;
4505 eolvalue
= Fget (coding_system
, Qeol_type
);
4507 while (!NILP (val
) && SYMBOLP (val
))
4509 val
= Fget (val
, Qcoding_system
);
4510 if (NILP (eolvalue
))
4511 eolvalue
= Fget (val
, Qeol_type
);
4515 *buf
++ = XFASTINT (XVECTOR (val
)->contents
[1]);
4519 /* The EOL conversion we are using. */
4521 /* The EOL conversion that is normal on this system. */
4523 if (NILP (eolvalue
)) /* Not yet decided. */
4524 eoltype
= eol_mnemonic_undecided
;
4525 else if (VECTORP (eolvalue
)) /* Not yet decided. */
4526 eoltype
= eol_mnemonic_undecided
;
4527 else /* INTEGERP (eolvalue) -- 0:LF, 1:CRLF, 2:CR */
4528 eoltype
= (XFASTINT (eolvalue
) == 0
4530 : (XFASTINT (eolvalue
) == 1
4531 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
4533 /* Mention the EOL conversion if it is not the usual one. */
4540 /* Return a string for the output of a mode line %-spec for window W,
4541 generated by character C. SPEC_WIDTH is the field width when
4542 padding to the left (%c, %l). The value returned from this
4543 function will later be truncated to width MAXWIDTH. */
4545 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
4548 decode_mode_spec (w
, c
, spec_width
, maxwidth
)
4551 register int spec_width
;
4552 register int maxwidth
;
4555 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4556 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
4557 struct buffer
*b
= XBUFFER (w
->buffer
);
4560 if (maxwidth
> FRAME_WIDTH (f
))
4561 maxwidth
= FRAME_WIDTH (f
);
4566 if (!NILP (b
->read_only
))
4568 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4573 /* This differs from %* only for a modified read-only buffer. */
4574 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4576 if (!NILP (b
->read_only
))
4581 /* This differs from %* in ignoring read-only-ness. */
4582 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4594 if (command_loop_level
> 5)
4596 p
= decode_mode_spec_buf
;
4597 for (i
= 0; i
< command_loop_level
; i
++)
4600 return decode_mode_spec_buf
;
4608 if (command_loop_level
> 5)
4610 p
= decode_mode_spec_buf
;
4611 for (i
= 0; i
< command_loop_level
; i
++)
4614 return decode_mode_spec_buf
;
4622 if (maxwidth
< sizeof (lots_of_dashes
))
4623 return lots_of_dashes
;
4626 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
4630 return decode_mode_spec_buf
;
4636 if (maxwidth
>= 3 && STRING_BYTES (XSTRING (obj
)) > maxwidth
)
4638 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
4639 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
4640 decode_mode_spec_buf
[maxwidth
] = '\0';
4641 return decode_mode_spec_buf
;
4648 int col
= current_column ();
4649 XSETFASTINT (w
->column_number_displayed
, col
);
4650 pint2str (decode_mode_spec_buf
, spec_width
, col
);
4651 return decode_mode_spec_buf
;
4655 /* %F displays the frame name. */
4656 /* Systems that can only display a single frame at a time should
4657 NOT replace the frame name with the (constant) frame title,
4658 since then they won't be able to tell which frame is that. */
4659 if (FRAME_WINDOW_P (f
) && !NILP (f
->title
))
4660 return (char *) XSTRING (f
->title
)->data
;
4661 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
4662 return (char *) XSTRING (f
->name
)->data
;
4670 else if (STRINGP (obj
) && STRING_BYTES (XSTRING (obj
)) > maxwidth
)
4672 bcopy ("...", decode_mode_spec_buf
, 3);
4673 bcopy (XSTRING (obj
)->data
+ STRING_BYTES (XSTRING (obj
)) - maxwidth
+ 3,
4674 decode_mode_spec_buf
+ 3, maxwidth
- 3);
4675 return decode_mode_spec_buf
;
4682 int startpos
= XMARKER (w
->start
)->charpos
;
4683 int startpos_byte
= marker_byte_position (w
->start
);
4684 int line
, linepos
, linepos_byte
, topline
;
4687 int height
= XFASTINT (w
->height
);
4689 /* If we decided that this buffer isn't suitable for line numbers,
4690 don't forget that too fast. */
4691 if (EQ (w
->base_line_pos
, w
->buffer
))
4693 /* But do forget it, if the window shows a different buffer now. */
4694 else if (BUFFERP (w
->base_line_pos
))
4695 w
->base_line_pos
= Qnil
;
4697 /* If the buffer is very big, don't waste time. */
4698 if (BUF_ZV (b
) - BUF_BEGV (b
) > line_number_display_limit
)
4700 w
->base_line_pos
= Qnil
;
4701 w
->base_line_number
= Qnil
;
4705 if (!NILP (w
->base_line_number
)
4706 && !NILP (w
->base_line_pos
)
4707 && XFASTINT (w
->base_line_pos
) <= startpos
)
4709 line
= XFASTINT (w
->base_line_number
);
4710 linepos
= XFASTINT (w
->base_line_pos
);
4711 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
4716 linepos
= BUF_BEGV (b
);
4717 linepos_byte
= BUF_BEGV_BYTE (b
);
4720 /* Count lines from base line to window start position. */
4721 nlines
= display_count_lines (linepos
, linepos_byte
,
4725 topline
= nlines
+ line
;
4727 /* Determine a new base line, if the old one is too close
4728 or too far away, or if we did not have one.
4729 "Too close" means it's plausible a scroll-down would
4731 if (startpos
== BUF_BEGV (b
))
4733 XSETFASTINT (w
->base_line_number
, topline
);
4734 XSETFASTINT (w
->base_line_pos
, BUF_BEGV (b
));
4736 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
4737 || linepos
== BUF_BEGV (b
))
4739 int limit
= BUF_BEGV (b
);
4740 int limit_byte
= BUF_BEGV_BYTE (b
);
4742 int distance
= (height
* 2 + 30) * 200;
4744 if (startpos
- distance
> limit
)
4746 limit
= startpos
- distance
;
4747 limit_byte
= CHAR_TO_BYTE (limit
);
4750 nlines
= display_count_lines (startpos
, startpos_byte
,
4752 - (height
* 2 + 30),
4754 /* If we couldn't find the lines we wanted within
4756 give up on line numbers for this window. */
4757 if (position
== limit_byte
&& limit
== startpos
- distance
)
4759 w
->base_line_pos
= w
->buffer
;
4760 w
->base_line_number
= Qnil
;
4764 XSETFASTINT (w
->base_line_number
, topline
- nlines
);
4765 XSETFASTINT (w
->base_line_pos
, BYTE_TO_CHAR (position
));
4768 /* Now count lines from the start pos to point. */
4769 nlines
= display_count_lines (startpos
, startpos_byte
,
4770 PT_BYTE
, PT
, &junk
);
4772 /* Record that we did display the line number. */
4773 line_number_displayed
= 1;
4775 /* Make the string to show. */
4776 pint2str (decode_mode_spec_buf
, spec_width
, topline
+ nlines
);
4777 return decode_mode_spec_buf
;
4780 char* p
= decode_mode_spec_buf
;
4781 for (spec_width
-= 2; spec_width
> 0; --spec_width
) *p
++ = ' ';
4783 return decode_mode_spec_buf
;
4793 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
4799 int pos
= marker_position (w
->start
);
4800 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
4802 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
4804 if (pos
<= BUF_BEGV (b
))
4809 else if (pos
<= BUF_BEGV (b
))
4813 if (total
> 1000000)
4814 /* Do it differently for a large value, to avoid overflow. */
4815 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
4817 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
4818 /* We can't normally display a 3-digit number,
4819 so get us a 2-digit number that is close. */
4822 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
4823 return decode_mode_spec_buf
;
4827 /* Display percentage of size above the bottom of the screen. */
4830 int toppos
= marker_position (w
->start
);
4831 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
4832 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
4834 if (botpos
>= BUF_ZV (b
))
4836 if (toppos
<= BUF_BEGV (b
))
4843 if (total
> 1000000)
4844 /* Do it differently for a large value, to avoid overflow. */
4845 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
4847 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
4848 /* We can't normally display a 3-digit number,
4849 so get us a 2-digit number that is close. */
4852 if (toppos
<= BUF_BEGV (b
))
4853 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
4855 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
4856 return decode_mode_spec_buf
;
4861 /* status of process */
4862 obj
= Fget_buffer_process (w
->buffer
);
4864 return "no process";
4866 obj
= Fsymbol_name (Fprocess_status (obj
));
4870 case 't': /* indicate TEXT or BINARY */
4871 #ifdef MODE_LINE_BINARY_TEXT
4872 return MODE_LINE_BINARY_TEXT (b
);
4878 /* coding-system (not including end-of-line format) */
4880 /* coding-system (including end-of-line type) */
4882 int eol_flag
= (c
== 'Z');
4883 char *p
= decode_mode_spec_buf
;
4885 if (! FRAME_WINDOW_P (f
))
4887 /* No need to mention EOL here--the terminal never needs
4888 to do EOL conversion. */
4889 p
= decode_mode_spec_coding (keyboard_coding
.symbol
, p
, 0);
4890 p
= decode_mode_spec_coding (terminal_coding
.symbol
, p
, 0);
4892 p
= decode_mode_spec_coding (b
->buffer_file_coding_system
,
4895 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
4897 obj
= Fget_buffer_process (Fcurrent_buffer ());
4900 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
4902 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
4905 #endif /* subprocesses */
4908 return decode_mode_spec_buf
;
4913 return (char *) XSTRING (obj
)->data
;
4918 /* Count up to COUNT lines starting from START / START_BYTE.
4919 But don't go beyond LIMIT_BYTE.
4920 Return the number of lines thus found (always nonnegative).
4922 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
4925 display_count_lines (start
, start_byte
, limit_byte
, count
, byte_pos_ptr
)
4926 int start
, start_byte
, limit_byte
, count
;
4929 register unsigned char *cursor
;
4930 unsigned char *base
;
4932 register int ceiling
;
4933 register unsigned char *ceiling_addr
;
4934 int orig_count
= count
;
4936 /* If we are not in selective display mode,
4937 check only for newlines. */
4938 int selective_display
= (!NILP (current_buffer
->selective_display
)
4939 && !INTEGERP (current_buffer
->selective_display
));
4943 while (start_byte
< limit_byte
)
4945 ceiling
= BUFFER_CEILING_OF (start_byte
);
4946 ceiling
= min (limit_byte
- 1, ceiling
);
4947 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
4948 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
4951 if (selective_display
)
4952 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
4955 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
4958 if (cursor
!= ceiling_addr
)
4962 start_byte
+= cursor
- base
+ 1;
4963 *byte_pos_ptr
= start_byte
;
4967 if (++cursor
== ceiling_addr
)
4973 start_byte
+= cursor
- base
;
4978 while (start_byte
> limit_byte
)
4980 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
4981 ceiling
= max (limit_byte
, ceiling
);
4982 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
4983 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
4986 if (selective_display
)
4987 while (--cursor
!= ceiling_addr
4988 && *cursor
!= '\n' && *cursor
!= 015)
4991 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
4994 if (cursor
!= ceiling_addr
)
4998 start_byte
+= cursor
- base
+ 1;
4999 *byte_pos_ptr
= start_byte
;
5000 /* When scanning backwards, we should
5001 not count the newline posterior to which we stop. */
5002 return - orig_count
- 1;
5008 /* Here we add 1 to compensate for the last decrement
5009 of CURSOR, which took it past the valid range. */
5010 start_byte
+= cursor
- base
+ 1;
5014 *byte_pos_ptr
= limit_byte
;
5017 return - orig_count
+ count
;
5018 return orig_count
- count
;
5022 /* Display STRING on one line of window W, starting at HPOS.
5023 Display at position VPOS. Caller should have done get_display_line.
5024 If VPOS == -1, display it as the current frame's title.
5025 LENGTH is the length of STRING, or -1 meaning STRING is null-terminated.
5027 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
5029 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
5030 MAXCOL is the last column ok to end at. Truncate here.
5031 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
5032 Both count from the left edge of the frame, as does HPOS.
5033 The right edge of W is an implicit maximum.
5034 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
5036 OBEY_WINDOW_WIDTH says to put spaces or vertical bars
5037 at the place where the current window ends in this line
5038 and not display anything beyond there. Otherwise, only MAXCOL
5039 controls where to stop output.
5041 MULTIBYTE can be 0 meaning do not display multibyte chars,
5042 1 meaning do display them, or -1 meaning obey the current buffer's
5043 value of enable_multibyte_characters.
5045 Returns ending hpos. */
5048 display_string (w
, vpos
, string
, length
, hpos
, truncate
,
5049 obey_window_width
, mincol
, maxcol
, multibyte
)
5051 unsigned char *string
;
5055 int obey_window_width
;
5062 int hscroll
= XINT (w
->hscroll
);
5063 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
5064 register GLYPH
*start
;
5065 register GLYPH
*end
;
5066 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
5067 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
5068 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
5069 int window_width
= XFASTINT (w
->width
);
5071 /* Use the standard display table, not the window's display table.
5072 We don't want the mode line in rot13. */
5073 register struct Lisp_Char_Table
*dp
= 0;
5076 if (multibyte
== -1)
5077 multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
5078 /* Now multibyte is 1 if we should display multibyte characters. */
5080 if (DISP_TABLE_P (Vstandard_display_table
))
5081 dp
= XCHAR_TABLE (Vstandard_display_table
);
5083 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
5086 start
= desired_glyphs
->glyphs
[vpos
];
5088 if (obey_window_width
)
5090 start
+= XFASTINT (w
->left
);
5091 end
= start
+ window_width
- (truncate
!= 0);
5093 if (!WINDOW_RIGHTMOST_P (w
))
5095 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
5099 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
5102 else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5107 if (! obey_window_width
5108 || (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
))
5109 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
5111 /* Store 0 in charstart for these columns. */
5112 for (i
= (hpos
>= 0 ? hpos
: 0); i
< end
- p1start
+ hpos
; i
++)
5113 desired_glyphs
->charstarts
[vpos
][i
] = 0;
5115 if (maxcol
>= 0 && mincol
> maxcol
)
5119 /* We need this value for multibyte characters. */
5120 length
= strlen (string
);
5122 /* We set truncated to 1 if we get stopped by trying to pass END
5123 (that is, trying to pass MAXCOL.) */
5132 c
= STRING_CHAR_AND_LENGTH (string
, length
, len
);
5134 c
= *string
, len
= 1;
5136 string
+= len
, length
-= len
;
5144 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
5146 p1
= copy_part_of_rope (f
, p1
, start
,
5147 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
5148 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
5151 else if (c
>= 040 && c
< 0177)
5161 if (p1
>= start
&& p1
< end
)
5165 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
5167 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
5171 (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
5172 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp
)))
5173 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
5176 if (p1
>= start
&& p1
< end
)
5182 /* C is a control character or a binary byte data. */
5185 (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
5186 && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp
)))
5187 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
5190 if (p1
>= start
&& p1
< end
)
5191 *p1
= (c
>> 6) + '0';
5193 if (p1
>= start
&& p1
< end
)
5194 *p1
= (7 & (c
>> 3)) + '0';
5196 if (p1
>= start
&& p1
< end
)
5197 *p1
= (7 & c
) + '0';
5202 /* C is a multibyte character. */
5203 int charset
= CHAR_CHARSET (c
);
5204 int columns
= (charset
== CHARSET_COMPOSITION
5205 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
5206 : CHARSET_WIDTH (charset
));
5210 /* Since we can't show the left part of C, fill all
5211 columns with spaces. */
5212 columns
-= start
- p1
;
5221 else if (p1
+ columns
> end
)
5223 /* Since we can't show the right part of C, fill all
5224 columns with TRUNCATE if TRUNCATE is specified. */
5228 *p1
++ = fix_glyph (f
, truncate
, 0);
5229 /* And tell the line is truncated. */
5236 /* We can show the whole glyph of C. */
5239 *p1
++ = c
| GLYPH_MASK_PADDING
;
5247 if (truncate
) *p1
++ = fix_glyph (f
, truncate
, 0);
5249 else if (mincol
>= 0)
5251 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
5257 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
5259 if (len
> desired_glyphs
->used
[vpos
])
5260 desired_glyphs
->used
[vpos
] = len
;
5261 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
5267 /* This is like a combination of memq and assq.
5268 Return 1 if PROPVAL appears as an element of LIST
5269 or as the car of an element of LIST.
5270 If PROPVAL is a list, compare each element against LIST
5271 in that way, and return 1 if any element of PROPVAL is found in LIST.
5273 This function cannot quit. */
5276 invisible_p (propval
, list
)
5277 register Lisp_Object propval
;
5280 register Lisp_Object tail
, proptail
;
5281 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5283 register Lisp_Object tem
;
5284 tem
= XCONS (tail
)->car
;
5285 if (EQ (propval
, tem
))
5287 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
5290 if (CONSP (propval
))
5291 for (proptail
= propval
; CONSP (proptail
);
5292 proptail
= XCONS (proptail
)->cdr
)
5294 Lisp_Object propelt
;
5295 propelt
= XCONS (proptail
)->car
;
5296 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5298 register Lisp_Object tem
;
5299 tem
= XCONS (tail
)->car
;
5300 if (EQ (propelt
, tem
))
5302 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
5309 /* Return 1 if PROPVAL appears as the car of an element of LIST
5310 and the cdr of that element is non-nil.
5311 If PROPVAL is a list, check each element of PROPVAL in that way,
5312 and the first time some element is found,
5313 return 1 if the cdr of that element is non-nil.
5315 This function cannot quit. */
5318 invisible_ellipsis_p (propval
, list
)
5319 register Lisp_Object propval
;
5322 register Lisp_Object tail
, proptail
;
5323 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5325 register Lisp_Object tem
;
5326 tem
= XCONS (tail
)->car
;
5327 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
5328 return ! NILP (XCONS (tem
)->cdr
);
5330 if (CONSP (propval
))
5331 for (proptail
= propval
; CONSP (proptail
);
5332 proptail
= XCONS (proptail
)->cdr
)
5334 Lisp_Object propelt
;
5335 propelt
= XCONS (proptail
)->car
;
5336 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5338 register Lisp_Object tem
;
5339 tem
= XCONS (tail
)->car
;
5340 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
5341 return ! NILP (XCONS (tem
)->cdr
);
5350 staticpro (&Qmenu_bar_update_hook
);
5351 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
5353 staticpro (&Qoverriding_terminal_local_map
);
5354 Qoverriding_terminal_local_map
= intern ("overriding-terminal-local-map");
5356 staticpro (&Qoverriding_local_map
);
5357 Qoverriding_local_map
= intern ("overriding-local-map");
5359 staticpro (&Qwindow_scroll_functions
);
5360 Qwindow_scroll_functions
= intern ("window-scroll-functions");
5362 staticpro (&Qredisplay_end_trigger_functions
);
5363 Qredisplay_end_trigger_functions
= intern ("redisplay-end-trigger-functions");
5365 staticpro (&last_arrow_position
);
5366 staticpro (&last_arrow_string
);
5367 last_arrow_position
= Qnil
;
5368 last_arrow_string
= Qnil
;
5370 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
5371 "String (or mode line construct) included (normally) in `mode-line-format'.");
5372 Vglobal_mode_string
= Qnil
;
5374 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
5375 "Marker for where to display an arrow on top of the buffer text.\n\
5376 This must be the beginning of a line in order to work.\n\
5377 See also `overlay-arrow-string'.");
5378 Voverlay_arrow_position
= Qnil
;
5380 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
5381 "String to display as an arrow. See also `overlay-arrow-position'.");
5382 Voverlay_arrow_string
= Qnil
;
5384 DEFVAR_INT ("scroll-step", &scroll_step
,
5385 "*The number of lines to try scrolling a window by when point moves out.\n\
5386 If that fails to bring point back on frame, point is centered instead.\n\
5387 If this is zero, point is always centered after it moves off frame.");
5389 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively
,
5390 "*Scroll up to this many lines, to bring point back on screen.");
5391 scroll_conservatively
= 0;
5393 DEFVAR_INT ("scroll-margin", &scroll_margin
,
5394 "*Number of lines of margin at the top and bottom of a window.\n\
5395 Recenter the window whenever point gets within this many lines\n\
5396 of the top or bottom of the window.");
5399 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
5401 DEFVAR_BOOL ("truncate-partial-width-windows",
5402 &truncate_partial_width_windows
,
5403 "*Non-nil means truncate lines in all windows less than full frame wide.");
5404 truncate_partial_width_windows
= 1;
5406 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
5407 "*Non-nil means use inverse video for the mode line.");
5408 mode_line_inverse_video
= 1;
5410 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
5411 "*Maximum buffer size (in characters) for line number display\n\
5412 If the buffer is bigger than this, the line number does not appear\n\
5413 in the mode line..");
5414 line_number_display_limit
= 1000000;
5416 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
5417 "*Non-nil means highlight region even in nonselected windows.");
5418 highlight_nonselected_windows
= 0;
5420 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
5421 "Non-nil if more than one frame is visible on this display.\n\
5422 Minibuffer-only frames don't count, but iconified frames do.\n\
5423 This variable is not guaranteed to be accurate except while processing\n\
5424 `frame-title-format' and `icon-title-format'.");
5426 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
5427 "Template for displaying the titlebar of visible frames.\n\
5428 \(Assuming the window manager supports this feature.)\n\
5429 This variable has the same structure as `mode-line-format' (which see),\n\
5430 and is used only on frames for which no explicit name has been set\n\
5431 \(see `modify-frame-parameters').");
5432 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
5433 "Template for displaying the titlebar of an iconified frame.\n\
5434 \(Assuming the window manager supports this feature.)\n\
5435 This variable has the same structure as `mode-line-format' (which see),\n\
5436 and is used only on frames for which no explicit name has been set\n\
5437 \(see `modify-frame-parameters').");
5439 = Vframe_title_format
5440 = Fcons (intern ("multiple-frames"),
5441 Fcons (build_string ("%b"),
5442 Fcons (Fcons (build_string (""),
5443 Fcons (intern ("invocation-name"),
5444 Fcons (build_string ("@"),
5445 Fcons (intern ("system-name"),
5449 DEFVAR_LISP ("message-log-max", &Vmessage_log_max
,
5450 "Maximum number of lines to keep in the message log buffer.\n\
5451 If nil, disable message logging. If t, log messages but don't truncate\n\
5452 the buffer when it becomes large.");
5453 XSETFASTINT (Vmessage_log_max
, 50);
5455 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions
,
5456 "Functions called before redisplay, if window sizes have changed.\n\
5457 The value should be a list of functions that take one argument.\n\
5458 Just before redisplay, for each frame, if any of its windows have changed\n\
5459 size since the last redisplay, or have been split or deleted,\n\
5460 all the functions in the list are called, with the frame as argument.");
5461 Vwindow_size_change_functions
= Qnil
;
5463 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions
,
5464 "List of functions to call before redisplaying a window with scrolling.\n\
5465 Each function is called with two arguments, the window\n\
5466 and its new display-start position. Note that the value of `window-end'\n\
5467 is not valid when these functions are called.");
5468 Vwindow_scroll_functions
= Qnil
;
5470 DEFVAR_INT ("minibuffer-scroll-overlap", &minibuffer_scroll_overlap
,
5471 "*Number of characters of overlap when scrolling a one-line window.\n\
5472 This commonly affects the minibuffer window, hence the name of the variable.");
5473 minibuffer_scroll_overlap
= 20;
5476 /* initialize the window system */
5479 Lisp_Object root_window
;
5480 #ifndef COMPILER_REGISTER_BUG
5482 #endif /* COMPILER_REGISTER_BUG */
5483 struct window
*mini_w
;
5485 this_line_bufpos
= 0;
5487 mini_w
= XWINDOW (minibuf_window
);
5488 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
5490 echo_area_glyphs
= 0;
5491 previous_echo_glyphs
= 0;
5493 if (!noninteractive
)
5495 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
5496 XSETFASTINT (XWINDOW (root_window
)->top
, FRAME_MENU_BAR_LINES (f
));
5497 set_window_height (root_window
,
5498 FRAME_HEIGHT (f
) - 1 - FRAME_MENU_BAR_LINES (f
),
5500 XSETFASTINT (mini_w
->top
, FRAME_HEIGHT (f
) - 1);
5501 set_window_height (minibuf_window
, 1, 0);
5503 XSETFASTINT (XWINDOW (root_window
)->width
, FRAME_WIDTH (f
));
5504 XSETFASTINT (mini_w
->width
, FRAME_WIDTH (f
));