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;
294 oldbuf
= current_buffer
;
295 Fset_buffer (Fget_buffer_create (build_string ("*Messages*")));
296 current_buffer
->undo_list
= Qt
;
298 oldpoint
= Fpoint_marker ();
299 oldbegv
= Fpoint_min_marker ();
300 oldzv
= Fpoint_max_marker ();
308 BEGV_BYTE
= BEG_BYTE
;
311 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
313 /* Insert the string--maybe converting multibyte to single byte
314 or vice versa, so that all the text fits the buffer. */
316 && NILP (current_buffer
->enable_multibyte_characters
))
318 int c
, i
= 0, nbytes
;
319 /* Convert a multibyte string to single-byte
320 for the *Message* buffer. */
323 c
= STRING_CHAR (m
+ i
, len
- i
);
324 i
+= XFASTINT (Fchar_bytes (make_number (c
)));
325 /* Truncate the character to its last byte--we can only hope
326 the user is happy with the character he gets,
327 since if it isn't right, there is no way to do it right. */
333 && ! NILP (current_buffer
->enable_multibyte_characters
))
336 unsigned char *msg
= (unsigned char *) m
;
337 /* Convert a single-byte string to multibyte
338 for the *Message* buffer. */
341 int c
= unibyte_char_to_multibyte (msg
[i
++]);
346 insert_1 (m
, len
, 1, 0, 0);
350 int this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
, dup
;
351 insert_1 ("\n", 1, 1, 0, 0);
353 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
355 this_bol_byte
= PT_BYTE
;
359 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
361 prev_bol_byte
= PT_BYTE
;
363 dup
= message_log_check_duplicate (prev_bol
, prev_bol_byte
,
364 this_bol
, this_bol_byte
);
367 del_range_both (prev_bol
, prev_bol_byte
,
368 this_bol
, this_bol_byte
, 0);
374 /* If you change this format, don't forget to also
375 change message_log_check_duplicate. */
376 sprintf (dupstr
, " [%d times]", dup
);
377 duplen
= strlen (dupstr
);
378 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
379 insert_1 (dupstr
, duplen
, 1, 0, 1);
384 if (NATNUMP (Vmessage_log_max
))
386 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
387 -XFASTINT (Vmessage_log_max
) - 1, 0);
388 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
391 BEGV
= XMARKER (oldbegv
)->charpos
;
392 BEGV_BYTE
= marker_byte_position (oldbegv
);
401 ZV
= XMARKER (oldzv
)->charpos
;
402 ZV_BYTE
= marker_byte_position (oldzv
);
406 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
408 Fgoto_char (oldpoint
);
410 free_marker (oldpoint
);
411 free_marker (oldbegv
);
414 set_buffer_internal (oldbuf
);
415 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
416 message_log_need_newline
= !nlflag
;
420 /* We are at the end of the buffer after just having inserted a newline.
421 (Note: We depend on the fact we won't be crossing the gap.)
422 Check to see if the most recent message looks a lot like the previous one.
423 Return 0 if different, 1 if the new one should just replace it, or a
424 value N > 1 if we should also append " [N times]". */
427 message_log_check_duplicate (prev_bol
, prev_bol_byte
, this_bol
, this_bol_byte
)
428 int prev_bol
, this_bol
;
429 int prev_bol_byte
, this_bol_byte
;
432 int len
= Z
- 1 - this_bol
;
434 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
435 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
437 for (i
= 0; i
< len
; i
++)
439 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.'
448 if (*p1
++ == ' ' && *p1
++ == '[')
451 while (*p1
>= '0' && *p1
<= '9')
452 n
= n
* 10 + *p1
++ - '0';
453 if (strncmp (p1
, " times]\n", 8) == 0)
459 /* Display an echo area message M with a specified length of LEN chars.
460 The string may include null characters. If M is 0, clear out any
461 existing message, and let the minibuffer text show through.
463 The buffer M must continue to exist until after the echo area
464 gets cleared or some other message gets displayed there.
466 Do not pass text that is stored in a Lisp string.
467 Do not pass text in a buffer that was alloca'd. */
470 message2 (m
, len
, multibyte
)
475 /* First flush out any partial line written with print. */
476 message_log_maybe_newline ();
478 message_dolog (m
, len
, 1, multibyte
);
479 message2_nolog (m
, len
, multibyte
);
483 /* The non-logging counterpart of message2. */
486 message2_nolog (m
, len
, multibyte
)
490 message_enable_multibyte
= multibyte
;
494 if (noninteractive_need_newline
)
496 noninteractive_need_newline
= 0;
498 fwrite (m
, len
, 1, stderr
);
499 if (cursor_in_echo_area
== 0)
500 fprintf (stderr
, "\n");
503 /* A null message buffer means that the frame hasn't really been
504 initialized yet. Error messages get reported properly by
505 cmd_error, so this must be just an informative message; toss it. */
506 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
508 Lisp_Object mini_window
;
511 /* Get the frame containing the minibuffer
512 that the selected frame is using. */
513 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
514 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
516 FRAME_SAMPLE_VISIBILITY (f
);
517 if (FRAME_VISIBLE_P (selected_frame
)
518 && ! FRAME_VISIBLE_P (f
))
519 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
523 echo_area_glyphs
= m
;
524 echo_area_glyphs_length
= len
;
526 if (minibuffer_auto_raise
)
527 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
530 echo_area_glyphs
= previous_echo_glyphs
= 0;
532 do_pending_window_change ();
533 echo_area_display ();
534 update_frame (f
, 1, 1);
535 do_pending_window_change ();
536 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
537 (*frame_up_to_date_hook
) (f
);
541 /* Display in echo area the null-terminated ASCII-only string M.
542 If M is 0, clear out any existing message,
543 and let the minibuffer text show through.
545 The string M must continue to exist until after the echo area
546 gets cleared or some other message gets displayed there.
548 Do not pass text that is stored in a Lisp string.
549 Do not pass text in a buffer that was alloca'd. */
555 message2 (m
, (m
? strlen (m
) : 0), 0);
562 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
565 /* Display a message M which contains a single %s
566 which gets replaced with STRING. */
569 message_with_string (m
, string
, log
)
578 if (noninteractive_need_newline
)
580 noninteractive_need_newline
= 0;
581 fprintf (stderr
, m
, XSTRING (string
)->data
);
582 if (cursor_in_echo_area
== 0)
583 fprintf (stderr
, "\n");
587 else if (INTERACTIVE
)
589 /* The frame whose minibuffer we're going to display the message on.
590 It may be larger than the selected frame, so we need
591 to use its buffer, not the selected frame's buffer. */
592 Lisp_Object mini_window
;
595 /* Get the frame containing the minibuffer
596 that the selected frame is using. */
597 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
598 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
600 /* A null message buffer means that the frame hasn't really been
601 initialized yet. Error messages get reported properly by
602 cmd_error, so this must be just an informative message; toss it. */
603 if (FRAME_MESSAGE_BUF (f
))
607 a
[0] = (char *) XSTRING (string
)->data
;
609 len
= doprnt (FRAME_MESSAGE_BUF (f
),
610 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
613 message2 (FRAME_MESSAGE_BUF (f
), len
,
614 STRING_MULTIBYTE (string
));
616 message2_nolog (FRAME_MESSAGE_BUF (f
), len
,
617 STRING_MULTIBYTE (string
));
619 /* Print should start at the beginning of the message
621 message_buf_print
= 0;
626 /* Truncate what will be displayed in the echo area
627 the next time we display it--but don't redisplay it now. */
630 truncate_echo_area (len
)
633 /* A null message buffer means that the frame hasn't really been
634 initialized yet. Error messages get reported properly by
635 cmd_error, so this must be just an informative message; toss it. */
636 if (!noninteractive
&& INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
637 echo_area_glyphs_length
= len
;
640 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
641 zero if being used by message. */
642 int message_buf_print
;
644 /* Dump an informative message to the minibuf. If M is 0, clear out
645 any existing message, and let the minibuffer text show through. */
649 message (m
, a1
, a2
, a3
)
651 EMACS_INT a1
, a2
, a3
;
657 if (noninteractive_need_newline
)
659 noninteractive_need_newline
= 0;
660 fprintf (stderr
, m
, a1
, a2
, a3
);
661 if (cursor_in_echo_area
== 0)
662 fprintf (stderr
, "\n");
666 else if (INTERACTIVE
)
668 /* The frame whose minibuffer we're going to display the message on.
669 It may be larger than the selected frame, so we need
670 to use its buffer, not the selected frame's buffer. */
671 Lisp_Object mini_window
;
674 /* Get the frame containing the minibuffer
675 that the selected frame is using. */
676 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
677 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
679 /* A null message buffer means that the frame hasn't really been
680 initialized yet. Error messages get reported properly by
681 cmd_error, so this must be just an informative message; toss it. */
682 if (FRAME_MESSAGE_BUF (f
))
693 len
= doprnt (FRAME_MESSAGE_BUF (f
),
694 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
696 len
= doprnt (FRAME_MESSAGE_BUF (f
),
697 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3,
699 #endif /* NO_ARG_ARRAY */
701 message2 (FRAME_MESSAGE_BUF (f
), len
, 0);
706 /* Print should start at the beginning of the message
708 message_buf_print
= 0;
713 /* The non-logging version of message. */
715 message_nolog (m
, a1
, a2
, a3
)
717 EMACS_INT a1
, a2
, a3
;
719 Lisp_Object old_log_max
;
720 old_log_max
= Vmessage_log_max
;
721 Vmessage_log_max
= Qnil
;
722 message (m
, a1
, a2
, a3
);
723 Vmessage_log_max
= old_log_max
;
729 message2 (echo_area_glyphs
, echo_area_glyphs_length
,
730 ! NILP (current_buffer
->enable_multibyte_characters
));
738 Lisp_Object mini_window
;
740 /* Choose the minibuffer window for this display.
741 It is the minibuffer window used by the selected frame. */
742 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
743 /* This is the frame that window is in. */
744 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
746 if (! FRAME_VISIBLE_P (f
))
751 redraw_garbaged_frames ();
755 if (echo_area_glyphs
|| minibuf_level
== 0)
759 echo_area_window
= mini_window
;
761 vpos
= XFASTINT (XWINDOW (mini_window
)->top
);
762 get_display_line (f
, vpos
, 0);
764 /* Make sure the columns that overlap a left-hand scroll bar
766 for (i
= 0; i
< FRAME_LEFT_SCROLL_BAR_WIDTH (f
); i
++)
767 f
->desired_glyphs
->glyphs
[vpos
][i
] = SPACEGLYPH
;
769 display_string (XWINDOW (mini_window
), vpos
,
770 echo_area_glyphs
? echo_area_glyphs
: "",
771 echo_area_glyphs
? echo_area_glyphs_length
: -1,
772 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
774 FRAME_WIDTH (f
) + FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
775 message_enable_multibyte
);
777 #if 0 /* This just gets in the way. update_frame does the job. */
778 /* If desired cursor location is on this line, put it at end of text */
779 if (cursor_in_echo_area
)
780 FRAME_CURSOR_Y (f
) = vpos
;
781 if (FRAME_CURSOR_Y (f
) == vpos
)
782 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
785 /* Fill the rest of the minibuffer window with blank lines. */
790 i
< vpos
+ XFASTINT (XWINDOW (mini_window
)->height
); i
++)
792 get_display_line (f
, i
, 0);
793 /* We don't use FRAME_SCROLL_BAR_WIDTH (f) as the starting
794 hpos, because it is good to clear whatever is behind the
795 scroll bar. This does not affect the scroll bar itself. */
796 display_string (XWINDOW (mini_window
), i
,
799 0, FRAME_WIDTH (f
) + FRAME_SCROLL_BAR_WIDTH (f
),
804 else if (!EQ (mini_window
, selected_window
))
805 windows_or_buffers_changed
++;
807 if (EQ (mini_window
, selected_window
))
808 this_line_bufpos
= 0;
810 previous_echo_glyphs
= echo_area_glyphs
;
813 /* Update frame titles. */
815 #ifdef HAVE_WINDOW_SYSTEM
816 static char frame_title_buf
[512];
817 static char *frame_title_ptr
;
820 store_frame_title (str
, mincol
, maxcol
)
825 if (maxcol
< 0 || maxcol
>= sizeof(frame_title_buf
))
826 maxcol
= sizeof (frame_title_buf
);
827 limit
= &frame_title_buf
[maxcol
];
828 while (*str
!= '\0' && frame_title_ptr
< limit
)
829 *frame_title_ptr
++ = *str
++;
830 while (frame_title_ptr
< &frame_title_buf
[mincol
])
831 *frame_title_ptr
++ = ' ';
832 return frame_title_ptr
- frame_title_buf
;
836 x_consider_frame_title (frame
)
842 FRAME_PTR f
= XFRAME (frame
);
844 if (!(FRAME_WINDOW_P (f
) || FRAME_MINIBUF_ONLY_P (f
) || f
->explicit_name
))
847 /* Do we have more than one visible frame on this X display? */
851 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
853 FRAME_PTR tf
= XFRAME (XCONS (tail
)->car
);
855 if (tf
!= f
&& FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
856 && !FRAME_MINIBUF_ONLY_P (tf
)
857 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
861 multiple_frames
= CONSP (tail
);
864 obuf
= current_buffer
;
865 Fset_buffer (XWINDOW (f
->selected_window
)->buffer
);
866 fmt
= (FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
);
867 frame_title_ptr
= frame_title_buf
;
868 len
= display_mode_element (XWINDOW (f
->selected_window
), 0, 0, 0,
869 0, sizeof (frame_title_buf
), fmt
);
871 set_buffer_internal (obuf
);
872 /* Set the name only if it's changed. This avoids consing
873 in the common case where it hasn't. (If it turns out that we've
874 already wasted too much time by walking through the list with
875 display_mode_element, then we might need to optimize at a higher
877 if (! STRINGP (f
->name
) || XSTRING (f
->name
)->size_byte
!= len
878 || bcmp (frame_title_buf
, XSTRING (f
->name
)->data
, len
) != 0)
879 x_implicitly_set_name (f
, make_string (frame_title_buf
, len
), Qnil
);
882 #define frame_title_ptr ((char *)0)
883 #define store_frame_title(str, mincol, maxcol) 0
886 /* Prepare for redisplay by updating menu-bar item lists when appropriate.
887 This can call eval. */
892 register struct window
*w
= XWINDOW (selected_window
);
894 struct gcpro gcpro1
, gcpro2
;
896 all_windows
= (update_mode_lines
|| buffer_shared
> 1
897 || windows_or_buffers_changed
);
899 /* Update all frame titles based on their buffer names, etc.
900 We do this before the menu bars so that the buffer-menu
901 will show the up-to-date frame titles.
903 This used to be done after the menu bars, for a reason that
904 was stated as follows but which I do not understand:
905 "We do this after the menu bars so that the frame will first
906 create its menu bar using the name `emacs' if no other name
907 has yet been specified."
908 I think that is no longer a concern. */
909 #ifdef HAVE_WINDOW_SYSTEM
910 if (windows_or_buffers_changed
|| update_mode_lines
)
912 Lisp_Object tail
, frame
;
914 FOR_EACH_FRAME (tail
, frame
)
915 if (FRAME_VISIBLE_P (XFRAME (frame
))
916 || FRAME_ICONIFIED_P (XFRAME (frame
)))
917 x_consider_frame_title (frame
);
921 /* Update the menu bar item lists, if appropriate.
922 This has to be done before any actual redisplay
923 or generation of display lines. */
926 Lisp_Object tail
, frame
;
927 int count
= specpdl_ptr
- specpdl
;
929 record_unwind_protect (Fstore_match_data
, Fmatch_data (Qnil
, Qnil
));
931 FOR_EACH_FRAME (tail
, frame
)
933 /* If a window on this frame changed size,
934 report that to the user and clear the size-change flag. */
935 if (FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)))
937 Lisp_Object functions
;
938 /* Clear flag first in case we get error below. */
939 FRAME_WINDOW_SIZES_CHANGED (XFRAME (frame
)) = 0;
940 functions
= Vwindow_size_change_functions
;
941 GCPRO2 (tail
, functions
);
942 while (CONSP (functions
))
944 call1 (XCONS (functions
)->car
, frame
);
945 functions
= XCONS (functions
)->cdr
;
950 update_menu_bar (XFRAME (frame
), 0);
954 unbind_to (count
, Qnil
);
957 update_menu_bar (selected_frame
, 1);
959 /* Motif needs this. See comment in xmenu.c.
960 Turn it off when pending_menu_activation is not defined. */
962 pending_menu_activation
= 0;
966 /* Do a frame update, taking possible shortcuts into account.
967 This is the main external entry point for redisplay.
969 If the last redisplay displayed an echo area message and that
970 message is no longer requested, we clear the echo area
971 or bring back the minibuffer if that is in use.
973 Do not call eval from within this function.
974 Calls to eval after the call to echo_area_display would confuse
975 the display_line mechanism and would cause a crash.
976 Calls to eval before that point will work most of the time,
977 but can still lose, because this function
978 can be called from signal handlers; with alarms set up;
979 or with synchronous processes running.
981 See Fcall_process; if you called it from here, it could be
982 entered recursively. */
984 static int do_verify_charstarts
;
986 /* Counter is used to clear the face cache
987 no more than once ever 1000 redisplays. */
988 static int clear_face_cache_count
;
990 /* Record the previous terminal frame we displayed. */
991 static FRAME_PTR previous_terminal_frame
;
996 redisplay_internal (0);
999 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay
1000 is not in response to any user action; therefore, we should
1001 preserve the echo area. (Actually, our caller does that job.)
1002 Perhaps in the future avoid recentering windows
1003 if it is not necessary; currently that causes some problems. */
1006 redisplay_internal (preserve_echo_area
)
1007 int preserve_echo_area
;
1009 register struct window
*w
= XWINDOW (selected_window
);
1011 int must_finish
= 0;
1013 register int tlbufpos
, tlendpos
;
1014 struct position pos
;
1015 int number_of_visible_frames
;
1020 #ifdef USE_X_TOOLKIT
1021 if (popup_activated ())
1027 if (! FRAME_WINDOW_P (selected_frame
)
1028 && previous_terminal_frame
!= selected_frame
)
1030 /* Since frames on an ASCII terminal share the same display area,
1031 displaying a different frame means redisplay the whole thing. */
1032 windows_or_buffers_changed
++;
1033 SET_FRAME_GARBAGED (selected_frame
);
1034 XSETFRAME (Vterminal_frame
, selected_frame
);
1036 previous_terminal_frame
= selected_frame
;
1038 /* Set the visible flags for all frames.
1039 Do this before checking for resized or garbaged frames; they want
1040 to know if their frames are visible.
1041 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
1043 Lisp_Object tail
, frame
;
1045 number_of_visible_frames
= 0;
1047 FOR_EACH_FRAME (tail
, frame
)
1049 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1051 if (FRAME_VISIBLE_P (XFRAME (frame
)))
1052 number_of_visible_frames
++;
1054 /* Clear out all the display lines in which we will generate the
1055 glyphs to display. */
1056 init_desired_glyphs (XFRAME (frame
));
1060 /* Notice any pending interrupt request to change frame size. */
1061 do_pending_window_change ();
1065 redraw_garbaged_frames ();
1069 prepare_menu_bars ();
1071 if (windows_or_buffers_changed
)
1072 update_mode_lines
++;
1074 /* Detect case that we need to write or remove a star in the mode line. */
1075 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
1077 w
->update_mode_line
= Qt
;
1078 if (buffer_shared
> 1)
1079 update_mode_lines
++;
1082 /* If %c is in use, update it if needed. */
1083 if (!NILP (w
->column_number_displayed
)
1084 /* This alternative quickly identifies a common case
1085 where no change is needed. */
1086 && !(PT
== XFASTINT (w
->last_point
)
1087 && XFASTINT (w
->last_modified
) >= MODIFF
1088 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
1089 && XFASTINT (w
->column_number_displayed
) != current_column ())
1090 w
->update_mode_line
= Qt
;
1092 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
1094 all_windows
= update_mode_lines
|| buffer_shared
> 1;
1096 /* If specs for an arrow have changed, do thorough redisplay
1097 to ensure we remove any arrow that should no longer exist. */
1098 if (! EQ (COERCE_MARKER (Voverlay_arrow_position
), last_arrow_position
)
1099 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
1102 /* Normally the message* functions will have already displayed and
1103 updated the echo area, but the frame may have been trashed, or
1104 the update may have been preempted, so display the echo area
1106 if (echo_area_glyphs
|| previous_echo_glyphs
)
1108 echo_area_display ();
1112 /* If showing region, and mark has changed, must redisplay whole window. */
1113 if (((!NILP (Vtransient_mark_mode
)
1114 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
1115 != !NILP (w
->region_showing
))
1116 || (!NILP (w
->region_showing
)
1117 && !EQ (w
->region_showing
,
1118 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
1119 this_line_bufpos
= -1;
1121 tlbufpos
= this_line_bufpos
;
1122 tlendpos
= this_line_endpos
;
1123 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
1124 && !current_buffer
->clip_changed
1125 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
1126 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
1127 /* Make sure recorded data applies to current buffer, etc */
1128 && this_line_buffer
== current_buffer
1129 && current_buffer
== XBUFFER (w
->buffer
)
1130 && NILP (w
->force_start
)
1131 /* Point must be on the line that we have info recorded about */
1133 && PT
<= Z
- tlendpos
1134 /* All text outside that line, including its final newline,
1135 must be unchanged */
1136 && ((XFASTINT (w
->last_modified
) >= MODIFF
1137 && (XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
))
1138 || (beg_unchanged
>= tlbufpos
- 1
1140 /* If selective display, can't optimize
1141 if the changes start at the beginning of the line. */
1142 && ((INTEGERP (current_buffer
->selective_display
)
1143 && XINT (current_buffer
->selective_display
) > 0
1144 ? (beg_unchanged
>= tlbufpos
1147 && end_unchanged
>= tlendpos
1148 && Z
- GPT
>= tlendpos
)))
1150 int tlbufpos_byte
= CHAR_TO_BYTE (tlbufpos
);
1151 if (tlbufpos
> BEGV
&& FETCH_BYTE (tlbufpos_byte
- 1) != '\n'
1153 || FETCH_BYTE (tlbufpos_byte
) == '\n'))
1154 /* Former continuation line has disappeared by becoming empty */
1156 else if (XFASTINT (w
->last_modified
) < MODIFF
1157 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
1158 || MINI_WINDOW_P (w
))
1160 /* We have to handle the case of continuation around a
1161 wide-column character (See the comment in indent.c around
1164 For instance, in the following case:
1166 -------- Insert --------
1167 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
1168 J_I_ ==> J_I_ `^^' are cursors.
1172 As we have to redraw the line above, we should goto cancel. */
1174 struct position val
;
1176 int opoint
= PT
, opoint_byte
= PT_BYTE
;
1178 scan_newline (tlbufpos
, tlbufpos_byte
, BEGV
, BEGV_BYTE
, -1, 1);
1180 val
= *compute_motion (PT
, 0,
1181 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1184 1 << (BITS_PER_SHORT
- 1),
1185 1 << (BITS_PER_SHORT
- 1),
1186 window_internal_width (w
) - 1,
1187 XINT (w
->hscroll
), 0, w
);
1188 SET_PT_BOTH (opoint
, opoint_byte
);
1189 if (val
.hpos
!= this_line_start_hpos
)
1193 overlay_arrow_seen
= 0;
1194 zv_strings_seen
= 0;
1195 display_text_line (w
, tlbufpos
, tlbufpos_byte
,
1196 this_line_vpos
, this_line_start_hpos
,
1197 pos_tab_offset (w
, tlbufpos
, tlbufpos_byte
), 0);
1198 /* If line contains point, is not continued,
1199 and ends at same distance from eob as before, we win */
1200 if (cursor_vpos
>= 0 && this_line_bufpos
1201 && this_line_endpos
== tlendpos
)
1203 /* If this is not the window's last line,
1204 we must adjust the charstarts of the lines below. */
1205 if (this_line_vpos
+ 1
1206 < XFASTINT (w
->top
) + window_internal_height (w
))
1208 int left
= WINDOW_LEFT_MARGIN (w
);
1209 int *charstart_next_line
1210 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[this_line_vpos
+ 1];
1213 if (Z
- tlendpos
== ZV
)
1214 /* This line ends at end of (accessible part of) buffer.
1215 There is no newline to count. */
1216 adjust
= Z
- tlendpos
- charstart_next_line
[left
];
1218 /* This line ends in a newline.
1219 Must take account of the newline and the rest of the
1220 text that follows. */
1221 adjust
= Z
- tlendpos
+ 1 - charstart_next_line
[left
];
1223 adjust_window_charstarts (w
, this_line_vpos
, adjust
);
1226 if (!WINDOW_FULL_WIDTH_P (w
))
1227 preserve_other_columns (w
);
1233 else if (PT
== XFASTINT (w
->last_point
)
1234 /* Make sure the cursor was last displayed
1235 in this window. Otherwise we have to reposition it. */
1236 && XINT (w
->top
) <= FRAME_CURSOR_Y (selected_frame
)
1237 && (XINT (w
->top
) + XINT (w
->height
)
1238 > FRAME_CURSOR_Y (selected_frame
)))
1242 do_pending_window_change ();
1247 /* If highlighting the region, or if the cursor is in the echo area,
1248 then we can't just move the cursor. */
1249 else if (! (!NILP (Vtransient_mark_mode
)
1250 && !NILP (current_buffer
->mark_active
))
1251 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1252 || highlight_nonselected_windows
)
1253 && NILP (w
->region_showing
)
1254 && !cursor_in_echo_area
)
1256 pos
= *compute_motion (tlbufpos
, 0,
1257 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
1259 PT
, 2, - (1 << (BITS_PER_SHORT
- 1)),
1260 window_internal_width (w
) - 1,
1262 pos_tab_offset (w
, tlbufpos
, tlbufpos_byte
),
1266 int width
= window_internal_width (w
) - 1;
1267 FRAME_CURSOR_X (selected_frame
)
1268 = WINDOW_LEFT_MARGIN (w
) + minmax (0, pos
.hpos
, width
);
1269 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
1276 /* Text changed drastically or point moved off of line */
1277 cancel_line (this_line_vpos
, selected_frame
);
1280 this_line_bufpos
= 0;
1281 all_windows
|= buffer_shared
> 1;
1283 clear_face_cache_count
++;
1287 Lisp_Object tail
, frame
;
1290 /* Clear the face cache, only when we do a full redisplay
1291 and not too often either. */
1292 if (clear_face_cache_count
> 1000)
1294 clear_face_cache ();
1295 clear_face_cache_count
= 0;
1299 /* Recompute # windows showing selected buffer.
1300 This will be incremented each time such a window is displayed. */
1303 FOR_EACH_FRAME (tail
, frame
)
1305 FRAME_PTR f
= XFRAME (frame
);
1306 if (FRAME_WINDOW_P (f
) || f
== selected_frame
)
1309 /* Mark all the scroll bars to be removed; we'll redeem the ones
1310 we want when we redisplay their windows. */
1311 if (condemn_scroll_bars_hook
)
1312 (*condemn_scroll_bars_hook
) (f
);
1314 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
1315 redisplay_windows (FRAME_ROOT_WINDOW (f
), preserve_echo_area
);
1317 /* Any scroll bars which redisplay_windows should have nuked
1318 should now go away. */
1319 if (judge_scroll_bars_hook
)
1320 (*judge_scroll_bars_hook
) (f
);
1324 else if (FRAME_VISIBLE_P (selected_frame
) && !FRAME_OBSCURED_P (selected_frame
))
1326 redisplay_window (selected_window
, 1, preserve_echo_area
);
1327 if (!WINDOW_FULL_WIDTH_P (w
))
1328 preserve_other_columns (w
);
1332 /* Prevent various kinds of signals during display update.
1333 stdio is not robust about handling signals,
1334 which can cause an apparent I/O error. */
1335 if (interrupt_input
)
1345 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1349 if (!FRAMEP (XCONS (tail
)->car
))
1352 f
= XFRAME (XCONS (tail
)->car
);
1354 if ((FRAME_WINDOW_P (f
) || f
== selected_frame
)
1355 && FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
1357 pause
|= update_frame (f
, 0, 0);
1360 mark_window_display_accurate (f
->root_window
, 1);
1361 if (frame_up_to_date_hook
!= 0)
1362 (*frame_up_to_date_hook
) (f
);
1369 if (FRAME_VISIBLE_P (selected_frame
) && !FRAME_OBSCURED_P (selected_frame
))
1370 pause
= update_frame (selected_frame
, 0, 0);
1374 /* We may have called echo_area_display at the top of this
1375 function. If the echo area is on another frame, that may
1376 have put text on a frame other than the selected one, so the
1377 above call to update_frame would not have caught it. Catch
1380 Lisp_Object mini_window
;
1381 FRAME_PTR mini_frame
;
1383 mini_window
= FRAME_MINIBUF_WINDOW (selected_frame
);
1384 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
1386 if (mini_frame
!= selected_frame
&& FRAME_WINDOW_P (mini_frame
))
1387 pause
|= update_frame (mini_frame
, 0, 0);
1391 /* If frame does not match, prevent doing single-line-update next time.
1392 Also, don't forget to check every line to update the arrow. */
1395 this_line_bufpos
= 0;
1396 if (!NILP (last_arrow_position
))
1398 last_arrow_position
= Qt
;
1399 last_arrow_string
= Qt
;
1401 /* If we pause after scrolling, some lines in current_frame
1402 may be null, so preserve_other_columns won't be able to
1403 preserve all the vertical-bar separators. So, avoid using it
1405 if (!WINDOW_FULL_WIDTH_P (w
))
1406 update_mode_lines
= 1;
1409 /* Now text on frame agrees with windows, so
1410 put info into the windows for partial redisplay to follow */
1414 register struct buffer
*b
= XBUFFER (w
->buffer
);
1416 blank_end_of_window
= 0;
1417 unchanged_modified
= BUF_MODIFF (b
);
1418 overlay_unchanged_modified
= BUF_OVERLAY_MODIFF (b
);
1419 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
1420 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
1422 XSETFASTINT (w
->last_point
, BUF_PT (b
));
1423 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (selected_frame
));
1424 XSETFASTINT (w
->last_point_y
, FRAME_CURSOR_Y (selected_frame
));
1427 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
1430 b
->clip_changed
= 0;
1431 w
->update_mode_line
= Qnil
;
1432 XSETFASTINT (w
->last_modified
, BUF_MODIFF (b
));
1433 XSETFASTINT (w
->last_overlay_modified
, BUF_OVERLAY_MODIFF (b
));
1435 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1438 /* Record if we are showing a region, so can make sure to
1439 update it fully at next redisplay. */
1440 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
1441 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1442 || highlight_nonselected_windows
)
1443 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
1444 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
1447 w
->window_end_valid
= w
->buffer
;
1448 last_arrow_position
= COERCE_MARKER (Voverlay_arrow_position
);
1449 last_arrow_string
= Voverlay_arrow_string
;
1450 if (do_verify_charstarts
)
1451 verify_charstarts (w
);
1452 if (frame_up_to_date_hook
!= 0)
1453 (*frame_up_to_date_hook
) (selected_frame
);
1455 update_mode_lines
= 0;
1456 windows_or_buffers_changed
= 0;
1459 /* Start SIGIO interrupts coming again.
1460 Having them off during the code above
1461 makes it less likely one will discard output,
1462 but not impossible, since there might be stuff
1463 in the system buffer here.
1464 But it is much hairier to try to do anything about that. */
1466 if (interrupt_input
)
1470 /* If something has become visible now which was not before,
1471 redisplay again, so that we get them. */
1474 Lisp_Object tail
, frame
;
1477 FOR_EACH_FRAME (tail
, frame
)
1479 int this_is_visible
= 0;
1481 if (XFRAME (frame
)->visible
)
1482 this_is_visible
= 1;
1483 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1484 if (XFRAME (frame
)->visible
)
1485 this_is_visible
= 1;
1487 if (this_is_visible
)
1491 if (new_count
!= number_of_visible_frames
)
1492 windows_or_buffers_changed
++;
1495 /* Change frame size now if a change is pending. */
1496 do_pending_window_change ();
1498 /* If we just did a pending size change, or have additional
1499 visible frames, redisplay again. */
1500 if (windows_or_buffers_changed
&& !pause
)
1504 /* Redisplay, but leave alone any recent echo area message
1505 unless another message has been requested in its place.
1507 This is useful in situations where you need to redisplay but no
1508 user action has occurred, making it inappropriate for the message
1509 area to be cleared. See tracking_off and
1510 wait_reading_process_input for examples of these situations. */
1513 redisplay_preserve_echo_area ()
1515 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
1517 echo_area_glyphs
= previous_echo_glyphs
;
1518 redisplay_internal (1);
1519 echo_area_glyphs
= 0;
1522 redisplay_internal (1);
1526 mark_window_display_accurate (window
, flag
)
1530 register struct window
*w
;
1532 for (;!NILP (window
); window
= w
->next
)
1534 if (!WINDOWP (window
)) abort ();
1535 w
= XWINDOW (window
);
1537 if (!NILP (w
->buffer
))
1539 XSETFASTINT (w
->last_modified
,
1540 !flag
? 0 : BUF_MODIFF (XBUFFER (w
->buffer
)));
1541 XSETFASTINT (w
->last_overlay_modified
,
1542 !flag
? 0 : BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
)));
1544 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1547 /* Record if we are showing a region, so can make sure to
1548 update it fully at next redisplay. */
1549 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
1550 && (w
== XWINDOW (current_buffer
->last_selected_window
)
1551 || highlight_nonselected_windows
)
1552 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
1553 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
1557 w
->window_end_valid
= w
->buffer
;
1558 w
->update_mode_line
= Qnil
;
1559 if (!NILP (w
->buffer
) && flag
)
1560 XBUFFER (w
->buffer
)->clip_changed
= 0;
1562 if (!NILP (w
->vchild
))
1563 mark_window_display_accurate (w
->vchild
, flag
);
1564 if (!NILP (w
->hchild
))
1565 mark_window_display_accurate (w
->hchild
, flag
);
1570 last_arrow_position
= COERCE_MARKER (Voverlay_arrow_position
);
1571 last_arrow_string
= Voverlay_arrow_string
;
1575 /* t is unequal to any useful value of Voverlay_arrow_... */
1576 last_arrow_position
= Qt
;
1577 last_arrow_string
= Qt
;
1581 /* Update the menu bar item list for frame F.
1582 This has to be done before we start to fill in any display lines,
1583 because it can call eval.
1585 If SAVE_MATCH_DATA is 1, we must save and restore it here. */
1588 update_menu_bar (f
, save_match_data
)
1590 int save_match_data
;
1592 struct buffer
*old
= current_buffer
;
1594 register struct window
*w
;
1596 window
= FRAME_SELECTED_WINDOW (f
);
1597 w
= XWINDOW (window
);
1599 if (update_mode_lines
)
1600 w
->update_mode_line
= Qt
;
1602 if (FRAME_WINDOW_P (f
)
1604 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1605 FRAME_EXTERNAL_MENU_BAR (f
)
1607 FRAME_MENU_BAR_LINES (f
) > 0
1609 : FRAME_MENU_BAR_LINES (f
) > 0)
1611 /* If the user has switched buffers or windows, we need to
1612 recompute to reflect the new bindings. But we'll
1613 recompute when update_mode_lines is set too; that means
1614 that people can use force-mode-line-update to request
1615 that the menu bar be recomputed. The adverse effect on
1616 the rest of the redisplay algorithm is about the same as
1617 windows_or_buffers_changed anyway. */
1618 if (windows_or_buffers_changed
1619 || !NILP (w
->update_mode_line
)
1620 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
1621 < BUF_MODIFF (XBUFFER (w
->buffer
)))
1622 != !NILP (w
->last_had_star
))
1623 || ((!NILP (Vtransient_mark_mode
)
1624 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
1625 != !NILP (w
->region_showing
)))
1627 struct buffer
*prev
= current_buffer
;
1628 int count
= specpdl_ptr
- specpdl
;
1630 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1631 if (save_match_data
)
1632 record_unwind_protect (Fstore_match_data
, Fmatch_data (Qnil
, Qnil
));
1633 if (NILP (Voverriding_local_map_menu_flag
))
1635 specbind (Qoverriding_terminal_local_map
, Qnil
);
1636 specbind (Qoverriding_local_map
, Qnil
);
1639 /* Run the Lucid hook. */
1640 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1641 /* If it has changed current-menubar from previous value,
1642 really recompute the menubar from the value. */
1643 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1644 call0 (Qrecompute_lucid_menubar
);
1645 safe_run_hooks (Qmenu_bar_update_hook
);
1646 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1647 /* Redisplay the menu bar in case we changed it. */
1648 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1649 if (FRAME_WINDOW_P (f
))
1650 set_frame_menubar (f
, 0, 0);
1652 /* On a terminal screen, the menu bar is an ordinary screen
1653 line, and this makes it get updated. */
1654 w
->update_mode_line
= Qt
;
1655 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
1656 /* In the non-toolkit version, the menu bar is an ordinary screen
1657 line, and this makes it get updated. */
1658 w
->update_mode_line
= Qt
;
1659 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
1661 unbind_to (count
, Qnil
);
1662 set_buffer_internal_1 (prev
);
1669 /* Redisplay WINDOW and its subwindows and siblings. */
1672 redisplay_windows (window
, preserve_echo_area
)
1674 int preserve_echo_area
;
1676 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
1677 redisplay_window (window
, 0, preserve_echo_area
);
1680 /* Return value in display table DP (Lisp_Char_Table *) for character
1681 C. Since a display table doesn't have any parent, we don't have to
1682 follow parent. Do not call this function directly but use the
1683 macro DISP_CHAR_VECTOR. */
1685 disp_char_vector (dp
, c
)
1686 struct Lisp_Char_Table
*dp
;
1692 if (SINGLE_BYTE_CHAR_P (c
)) return (dp
->contents
[c
]);
1694 SPLIT_NON_ASCII_CHAR (c
, code
[0], code
[1], code
[2]);
1695 if (code
[0] != CHARSET_COMPOSITION
)
1697 if (code
[1] < 32) code
[1] = -1;
1698 else if (code
[2] < 32) code
[2] = -1;
1700 /* Here, the possible range of CODE[0] (== charset ID) is
1701 128..MAX_CHARSET. Since the top level char table contains data
1702 for multibyte characters after 256th element, we must increment
1703 CODE[0] by 128 to get a correct index. */
1705 code
[3] = -1; /* anchor */
1707 for (i
= 0; code
[i
] >= 0; i
++, dp
= XCHAR_TABLE (val
))
1709 val
= dp
->contents
[code
[i
]];
1710 if (!SUB_CHAR_TABLE_P (val
))
1711 return (NILP (val
) ? dp
->defalt
: val
);
1713 /* Here, VAL is a sub char table. We return the default value of it. */
1714 return (dp
->defalt
);
1717 /* Redisplay window WINDOW and its subwindows. */
1720 redisplay_window (window
, just_this_one
, preserve_echo_area
)
1722 int just_this_one
, preserve_echo_area
;
1724 register struct window
*w
= XWINDOW (window
);
1725 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1728 int lpoint_byte
= PT_BYTE
;
1729 struct buffer
*old
= current_buffer
;
1730 register int width
= window_internal_width (w
) - 1;
1731 register int startp
, startp_byte
;
1732 register int hscroll
= XINT (w
->hscroll
);
1733 struct position pos
;
1735 int opoint_byte
= PT_BYTE
;
1737 int update_mode_line
;
1738 struct Lisp_Char_Table
*dp
= window_display_table (w
);
1740 if (Z
== Z_BYTE
&& lpoint
!= lpoint_byte
)
1742 if (lpoint_byte
< lpoint
)
1745 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1747 /* If this is a combination window, do its children; that's all. */
1749 if (!NILP (w
->vchild
))
1751 redisplay_windows (w
->vchild
, preserve_echo_area
);
1754 if (!NILP (w
->hchild
))
1756 redisplay_windows (w
->hchild
, preserve_echo_area
);
1759 if (NILP (w
->buffer
))
1762 height
= window_internal_height (w
);
1763 update_mode_line
= (!NILP (w
->update_mode_line
) || update_mode_lines
);
1764 if (XBUFFER (w
->buffer
)->clip_changed
)
1765 update_mode_line
= 1;
1767 if (MINI_WINDOW_P (w
))
1769 if (w
== XWINDOW (echo_area_window
) && echo_area_glyphs
)
1770 /* We've already displayed the echo area glyphs in this window. */
1771 goto finish_scroll_bars
;
1772 else if (w
!= XWINDOW (minibuf_window
))
1774 /* This is a minibuffer, but it's not the currently active one,
1776 int vpos
= XFASTINT (w
->top
);
1779 for (i
= 0; i
< height
; i
++)
1781 get_display_line (f
, vpos
+ i
, 0);
1782 display_string (w
, vpos
+ i
, "", 0,
1783 FRAME_LEFT_SCROLL_BAR_WIDTH (f
),
1787 goto finish_scroll_bars
;
1791 /* Otherwise set up data on this window; select its buffer and point value */
1793 if (update_mode_line
)
1794 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1796 set_buffer_temp (XBUFFER (w
->buffer
));
1799 opoint_byte
= PT_BYTE
;
1801 if (Z
== Z_BYTE
&& opoint
!= opoint_byte
)
1803 if (opoint_byte
< opoint
)
1806 /* If %c is in mode line, update it if needed. */
1807 if (!NILP (w
->column_number_displayed
)
1808 /* This alternative quickly identifies a common case
1809 where no change is needed. */
1810 && !(PT
== XFASTINT (w
->last_point
)
1811 && XFASTINT (w
->last_modified
) >= MODIFF
1812 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
1813 && XFASTINT (w
->column_number_displayed
) != current_column ())
1814 update_mode_line
= 1;
1816 /* Count number of windows showing the selected buffer.
1817 An indirect buffer counts as its base buffer. */
1821 struct buffer
*current_base
, *window_base
;
1822 current_base
= current_buffer
;
1823 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1824 if (current_base
->base_buffer
)
1825 current_base
= current_base
->base_buffer
;
1826 if (window_base
->base_buffer
)
1827 window_base
= window_base
->base_buffer
;
1828 if (current_base
== window_base
)
1832 /* POINT refers normally to the selected window.
1833 For any other window, set up appropriate value. */
1835 if (!EQ (window
, selected_window
))
1837 int new_pt
= XMARKER (w
->pointm
)->charpos
;
1838 int new_pt_byte
= marker_byte_position (w
->pointm
);
1842 new_pt_byte
= BEGV_BYTE
;
1843 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
1845 else if (new_pt
> (ZV
- 1))
1848 new_pt_byte
= ZV_BYTE
;
1849 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
1851 /* We don't use SET_PT so that the point-motion hooks don't run. */
1852 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
1855 /* If any of the character widths specified in the display table
1856 have changed, invalidate the width run cache. It's true that this
1857 may be a bit late to catch such changes, but the rest of
1858 redisplay goes (non-fatally) haywire when the display table is
1859 changed, so why should we worry about doing any better? */
1860 if (current_buffer
->width_run_cache
)
1862 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
1864 if (! disptab_matches_widthtab (disptab
,
1865 XVECTOR (current_buffer
->width_table
)))
1867 invalidate_region_cache (current_buffer
,
1868 current_buffer
->width_run_cache
,
1870 recompute_width_table (current_buffer
, disptab
);
1874 /* If window-start is screwed up, choose a new one. */
1875 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
1878 startp
= marker_position (w
->start
);
1879 startp_byte
= marker_byte_position (w
->start
);
1881 /* If someone specified a new starting point but did not insist,
1882 check whether it can be used. */
1883 if (!NILP (w
->optional_new_start
))
1885 w
->optional_new_start
= Qnil
;
1886 /* Check whether this start pos is usable given where point is. */
1888 pos
= *compute_motion (startp
, 0,
1889 (((EQ (window
, minibuf_window
)
1891 ? minibuf_prompt_width
: 0)
1892 + (hscroll
? 1 - hscroll
: 0)),
1895 /* BUG FIX: See the comment of
1896 Fpos_visible_in_window_p (window.c). */
1897 - (1 << (BITS_PER_SHORT
- 1)),
1899 pos_tab_offset (w
, startp
, startp_byte
), w
);
1900 /* If PT does fit on the screen, we will use this start pos,
1901 so do so by setting force_start. */
1902 if (pos
.bufpos
== PT
)
1903 w
->force_start
= Qt
;
1906 /* Handle case where place to start displaying has been specified,
1907 unless the specified location is outside the accessible range. */
1908 if (!NILP (w
->force_start
))
1910 w
->force_start
= Qnil
;
1911 /* Forget any recorded base line for line number display. */
1912 w
->base_line_number
= Qnil
;
1913 /* Redisplay the mode line. Select the buffer properly for that.
1914 Also, run the hook window-scroll-functions
1915 because we have scrolled. */
1916 /* Note, we do this after clearing force_start because
1917 if there's an error, it is better to forget about force_start
1918 than to get into an infinite loop calling the hook functions
1919 and having them get more errors. */
1920 if (!update_mode_line
1921 || ! NILP (Vwindow_scroll_functions
))
1923 Lisp_Object temp
[3];
1925 set_buffer_temp (old
);
1926 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1927 update_mode_line
= 1;
1928 w
->update_mode_line
= Qt
;
1929 if (! NILP (Vwindow_scroll_functions
))
1931 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
1932 make_number (startp
));
1933 startp
= marker_position (w
->start
);
1936 XSETFASTINT (w
->last_modified
, 0);
1937 XSETFASTINT (w
->last_overlay_modified
, 0);
1938 if (startp
< BEGV
) startp
= BEGV
, startp_byte
= BEGV_BYTE
;
1939 if (startp
> ZV
) startp
= ZV
, startp
= ZV_BYTE
;
1940 try_window (window
, startp
);
1941 if (cursor_vpos
< 0)
1943 /* If point does not appear, move point so it does appear */
1944 pos
= *compute_motion (startp
, 0,
1945 (((EQ (window
, minibuf_window
)
1947 ? minibuf_prompt_width
: 0)
1948 + (hscroll
? 1 - hscroll
: 0)),
1951 - (1 << (BITS_PER_SHORT
- 1)),
1953 pos_tab_offset (w
, startp
, startp_byte
),
1955 TEMP_SET_PT_BOTH (pos
.bufpos
, pos
.bytepos
);
1956 if (w
!= XWINDOW (selected_window
))
1957 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
1960 if (current_buffer
== old
)
1963 lpoint_byte
= PT_BYTE
;
1965 FRAME_CURSOR_X (f
) = (WINDOW_LEFT_MARGIN (w
)
1966 + minmax (0, pos
.hpos
, width
));
1967 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1969 /* If we are highlighting the region,
1970 then we just changed the region, so redisplay to show it. */
1971 if (!NILP (Vtransient_mark_mode
)
1972 && !NILP (current_buffer
->mark_active
))
1974 cancel_my_columns (XWINDOW (window
));
1975 try_window (window
, startp
);
1981 /* Handle case where text has not changed, only point,
1982 and it has not moved off the frame. */
1984 /* This code is not used for minibuffer for the sake of
1985 the case of redisplaying to replace an echo area message;
1986 since in that case the minibuffer contents per se are usually unchanged.
1987 This code is of no real use in the minibuffer since
1988 the handling of this_line_bufpos, etc.,
1989 in redisplay handles the same cases. */
1991 if (XFASTINT (w
->last_modified
) >= MODIFF
1992 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
1993 && PT
>= startp
&& !current_buffer
->clip_changed
1994 && (just_this_one
|| WINDOW_FULL_WIDTH_P (w
))
1995 /* If force-mode-line-update was called, really redisplay;
1996 that's how redisplay is forced after e.g. changing
1997 buffer-invisibility-spec. */
1998 && NILP (w
->update_mode_line
)
1999 /* Can't use this case if highlighting a region. */
2000 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
2001 && NILP (w
->region_showing
)
2002 /* If end pos is out of date, scroll bar and percentage will be wrong */
2003 && INTEGERP (w
->window_end_vpos
)
2004 && XFASTINT (w
->window_end_vpos
) < XFASTINT (w
->height
)
2005 && !EQ (window
, minibuf_window
)
2006 && (!MARKERP (Voverlay_arrow_position
)
2007 || current_buffer
!= XMARKER (Voverlay_arrow_position
)->buffer
))
2009 /* All positions in this clause are relative to the window edge. */
2011 int this_scroll_margin
= scroll_margin
;
2012 int last_point_y
= XFASTINT (w
->last_point_y
) - XINT (w
->top
);
2013 int last_point_x
= (XFASTINT (w
->last_point_x
) - WINDOW_LEFT_MARGIN (w
));
2015 /* Find where PT is located now on the frame. */
2016 /* Check just_this_one as a way of verifying that the
2017 window edges have not changed. */
2018 if (PT
== XFASTINT (w
->last_point
) && just_this_one
)
2020 pos
.hpos
= last_point_x
;
2021 pos
.vpos
= last_point_y
;
2024 else if (PT
> XFASTINT (w
->last_point
)
2025 && XFASTINT (w
->last_point
) > startp
&& just_this_one
2026 /* We can't use this if point is in the left margin of a
2027 hscrolled window, because w->last_point_x has been
2028 clipped to the window edges. */
2029 && !(last_point_x
<= 0 && hscroll
))
2031 pos
= *compute_motion (XFASTINT (w
->last_point
),
2032 last_point_y
, last_point_x
, 0,
2034 /* BUG FIX: See the comment of
2035 Fpos_visible_in_window_p (window.c). */
2036 - (1 << (BITS_PER_SHORT
- 1)),
2038 pos_tab_offset (w
, startp
, startp_byte
),
2043 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0), 0,
2045 /* BUG FIX: See the comment of
2046 Fpos_visible_in_window_p (window.c). */
2047 - (1 << (BITS_PER_SHORT
- 1)),
2049 pos_tab_offset (w
, startp
, startp_byte
),
2053 /* Don't use a scroll margin that is negative or too large. */
2054 if (this_scroll_margin
< 0)
2055 this_scroll_margin
= 0;
2057 if (XINT (w
->height
) < 4 * scroll_margin
)
2058 this_scroll_margin
= XINT (w
->height
) / 4;
2060 /* If point fits on the screen, and not within the scroll margin,
2062 if (pos
.vpos
< height
- this_scroll_margin
2063 && (pos
.vpos
>= this_scroll_margin
|| startp
== BEGV
))
2065 /* Ok, point is still on frame */
2066 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
2068 /* These variables are supposed to be origin 1 */
2069 FRAME_CURSOR_X (f
) = (WINDOW_LEFT_MARGIN (w
)
2070 + minmax (0, pos
.hpos
, width
));
2071 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
2073 /* This doesn't do the trick, because if a window to the right of
2074 this one must be redisplayed, this does nothing because there
2075 is nothing in DesiredFrame yet, and then the other window is
2076 redisplayed, making likes that are empty in this window's columns.
2077 if (WINDOW_FULL_WIDTH_P (w))
2078 preserve_my_columns (w);
2080 if (current_buffer
->clip_changed
2081 && ! NILP (Vwindow_scroll_functions
))
2082 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2083 make_number (marker_position (w
->start
)));
2087 /* Don't bother trying redisplay with same start;
2088 we already know it will lose */
2090 /* If current starting point was originally the beginning of a line
2091 but no longer is, find a new starting point. */
2092 else if (!NILP (w
->start_at_line_beg
)
2094 || FETCH_BYTE (startp_byte
- 1) == '\n'))
2098 else if (just_this_one
&& !MINI_WINDOW_P (w
)
2100 && XFASTINT (w
->last_modified
)
2101 /* or else vmotion on first line won't work. */
2102 && ! NILP (w
->start_at_line_beg
)
2103 && ! EQ (w
->window_end_valid
, Qnil
)
2104 && do_id
&& !current_buffer
->clip_changed
2105 && !blank_end_of_window
2106 && WINDOW_FULL_WIDTH_P (w
)
2107 /* Can't use this case if highlighting a region. */
2108 && !(!NILP (Vtransient_mark_mode
)
2109 && !NILP (current_buffer
->mark_active
))
2110 /* Don't use try_window_id if newline
2111 doesn't display as the end of a line. */
2112 && !(dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, '\n')))
2113 && NILP (w
->region_showing
)
2114 && EQ (last_arrow_position
, COERCE_MARKER (Voverlay_arrow_position
))
2115 && EQ (last_arrow_string
, Voverlay_arrow_string
)
2116 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
2119 /* tem > 0 means success. tem == -1 means choose new start.
2120 tem == -2 means try again with same start,
2121 and nothing but whitespace follows the changed stuff.
2122 tem == 0 means try again with same start. */
2126 else if (startp
>= BEGV
&& startp
<= ZV
2128 /* Avoid starting at end of buffer. */
2129 #if 0 /* This change causes trouble for M-! finger & RET.
2130 It will have to be considered later. */
2131 || ! EQ (window
, selected_window
)
2132 /* Don't do the recentering if redisplay
2133 is not for no user action. */
2134 || preserve_echo_area
2137 || (XFASTINT (w
->last_modified
) >= MODIFF
2138 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
2140 /* Try to redisplay starting at same place as before */
2141 /* If point has not moved off frame, accept the results */
2142 try_window (window
, startp
);
2143 if (cursor_vpos
>= 0)
2145 if (!just_this_one
|| current_buffer
->clip_changed
2146 || beg_unchanged
< startp
)
2147 /* Forget any recorded base line for line number display. */
2148 w
->base_line_number
= Qnil
;
2150 if (current_buffer
->clip_changed
2151 && ! NILP (Vwindow_scroll_functions
))
2152 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2153 make_number (marker_position (w
->start
)));
2158 cancel_my_columns (w
);
2161 XSETFASTINT (w
->last_modified
, 0);
2162 XSETFASTINT (w
->last_overlay_modified
, 0);
2163 /* Redisplay the mode line. Select the buffer properly for that. */
2164 if (!update_mode_line
)
2166 set_buffer_temp (old
);
2167 set_buffer_internal_1 (XBUFFER (w
->buffer
));
2168 update_mode_line
= 1;
2169 w
->update_mode_line
= Qt
;
2172 /* Try to scroll by specified few lines */
2174 if (scroll_conservatively
&& !current_buffer
->clip_changed
2175 && startp
>= BEGV
&& startp
<= ZV
)
2177 int this_scroll_margin
= scroll_margin
;
2178 int scroll_margin_pos
;
2180 /* Don't use a scroll margin that is negative or too large. */
2181 if (this_scroll_margin
< 0)
2182 this_scroll_margin
= 0;
2184 if (XINT (w
->height
) < 4 * this_scroll_margin
)
2185 this_scroll_margin
= XINT (w
->height
) / 4;
2187 scroll_margin_pos
= Z
- XFASTINT (w
->window_end_pos
);
2188 if (this_scroll_margin
)
2190 pos
= *vmotion (scroll_margin_pos
, -this_scroll_margin
, w
);
2191 scroll_margin_pos
= pos
.bufpos
;
2193 if (PT
>= scroll_margin_pos
)
2195 struct position pos
;
2196 pos
= *compute_motion (scroll_margin_pos
, 0, 0, 0,
2197 PT
, XFASTINT (w
->height
), 0,
2198 XFASTINT (w
->width
), XFASTINT (w
->hscroll
),
2199 pos_tab_offset (w
, startp
, startp_byte
),
2201 if (pos
.vpos
> scroll_conservatively
)
2204 pos
= *vmotion (startp
, pos
.vpos
+ 1, w
);
2206 if (! NILP (Vwindow_scroll_functions
))
2208 set_marker_both (w
->start
, Qnil
, pos
.bufpos
, pos
.bytepos
);
2209 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2210 make_number (pos
.bufpos
));
2211 pos
.bufpos
= marker_position (w
->start
);
2213 try_window (window
, pos
.bufpos
);
2214 if (cursor_vpos
>= 0)
2216 if (!just_this_one
|| current_buffer
->clip_changed
2217 || beg_unchanged
< startp
)
2218 /* Forget any recorded base line for line number display. */
2219 w
->base_line_number
= Qnil
;
2223 cancel_my_columns (w
);
2226 scroll_margin_pos
= startp
;
2227 if (this_scroll_margin
)
2229 pos
= *vmotion (scroll_margin_pos
, this_scroll_margin
, w
);
2230 scroll_margin_pos
= pos
.bufpos
;
2232 if (PT
< scroll_margin_pos
)
2234 struct position pos
;
2235 pos
= *compute_motion (PT
, 0, 0, 0,
2236 scroll_margin_pos
, XFASTINT (w
->height
), 0,
2237 XFASTINT (w
->width
), XFASTINT (w
->hscroll
),
2238 pos_tab_offset (w
, startp
, startp_byte
),
2240 if (pos
.vpos
> scroll_conservatively
)
2243 pos
= *vmotion (startp
, -pos
.vpos
, w
);
2245 if (! NILP (Vwindow_scroll_functions
))
2247 set_marker_both (w
->start
, Qnil
, pos
.bufpos
, pos
.bytepos
);
2248 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2249 make_number (pos
.bufpos
));
2250 pos
.bufpos
= marker_position (w
->start
);
2252 try_window (window
, pos
.bufpos
);
2253 if (cursor_vpos
>= 0)
2255 if (!just_this_one
|| current_buffer
->clip_changed
2256 || beg_unchanged
< startp
)
2257 /* Forget any recorded base line for line number display. */
2258 w
->base_line_number
= Qnil
;
2262 cancel_my_columns (w
);
2267 if (scroll_step
&& !current_buffer
->clip_changed
2268 && startp
>= BEGV
&& startp
<= ZV
)
2272 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), scroll_step
, w
);
2273 if (pos
.vpos
>= height
)
2277 pos
= *vmotion (startp
, (PT
< startp
? - scroll_step
: scroll_step
), w
);
2279 if (PT
>= pos
.bufpos
)
2281 if (! NILP (Vwindow_scroll_functions
))
2283 set_marker_both (w
->start
, Qnil
, pos
.bufpos
, pos
.bytepos
);
2284 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2285 make_number (pos
.bufpos
));
2286 pos
.bufpos
= marker_position (w
->start
);
2288 try_window (window
, pos
.bufpos
);
2289 if (cursor_vpos
>= 0)
2291 if (!just_this_one
|| current_buffer
->clip_changed
2292 || beg_unchanged
< startp
)
2293 /* Forget any recorded base line for line number display. */
2294 w
->base_line_number
= Qnil
;
2298 cancel_my_columns (w
);
2303 /* Finally, just choose place to start which centers point */
2306 /* Forget any previously recorded base line for line number display. */
2307 w
->base_line_number
= Qnil
;
2309 pos
= *vmotion (PT
, - (height
/ 2), w
);
2311 /* The minibuffer is often just one line. Ordinary scrolling
2312 gives little overlap and looks bad. So show 20 chars before point. */
2314 && (pos
.bufpos
>= PT
- minibuffer_scroll_overlap
2315 /* If we scrolled less than 1/2 line forward, we will
2316 get too much overlap, so change to the usual amount. */
2317 || pos
.bufpos
< startp
+ width
/ 2)
2318 && PT
> BEGV
+ minibuffer_scroll_overlap
2319 /* If we scrolled to an actual line boundary,
2320 that's different; don't ignore line boundaries. */
2321 && FETCH_BYTE (pos
.bufpos
- 1) != '\n')
2323 pos
.bufpos
= PT
- minibuffer_scroll_overlap
;
2324 pos
.bytepos
= CHAR_TO_BYTE (pos
.bufpos
);
2327 /* Set startp here explicitly in case that helps avoid an infinite loop
2328 in case the window-scroll-functions functions get errors. */
2329 set_marker_both (w
->start
, Qnil
, pos
.bufpos
, pos
.bytepos
);
2330 if (! NILP (Vwindow_scroll_functions
))
2332 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
2333 make_number (pos
.bufpos
));
2334 pos
.bufpos
= marker_position (w
->start
);
2335 pos
.bytepos
= marker_byte_position (w
->start
);
2337 try_window (window
, pos
.bufpos
);
2339 startp
= marker_position (w
->start
);
2340 startp_byte
= marker_byte_position (w
->start
);
2341 w
->start_at_line_beg
2342 = (startp
== BEGV
|| FETCH_BYTE (startp_byte
- 1) == '\n') ? Qt
: Qnil
;
2345 if ((update_mode_line
2346 /* If window not full width, must redo its mode line
2347 if the window to its side is being redone */
2348 || (!just_this_one
&& !WINDOW_FULL_WIDTH_P (w
))
2349 || INTEGERP (w
->base_line_pos
)
2350 || (!NILP (w
->column_number_displayed
)
2351 && XFASTINT (w
->column_number_displayed
) != current_column ()))
2352 && height
!= XFASTINT (w
->height
))
2353 display_mode_line (w
);
2354 if (! line_number_displayed
2355 && ! BUFFERP (w
->base_line_pos
))
2357 w
->base_line_pos
= Qnil
;
2358 w
->base_line_number
= Qnil
;
2361 /* When we reach a frame's selected window, redo the frame's menu bar. */
2362 if (update_mode_line
2363 && (FRAME_WINDOW_P (f
)
2365 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
2366 FRAME_EXTERNAL_MENU_BAR (f
)
2368 FRAME_MENU_BAR_LINES (f
) > 0
2370 : FRAME_MENU_BAR_LINES (f
) > 0)
2371 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
2372 display_menu_bar (w
);
2375 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2377 int start
, end
, whole
;
2379 /* Calculate the start and end positions for the current window.
2380 At some point, it would be nice to choose between scrollbars
2381 which reflect the whole buffer size, with special markers
2382 indicating narrowing, and scrollbars which reflect only the
2385 Note that minibuffers sometimes aren't displaying any text. */
2386 if (! MINI_WINDOW_P (w
)
2387 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
2390 start
= marker_position (w
->start
) - BEGV
;
2391 /* I don't think this is guaranteed to be right. For the
2392 moment, we'll pretend it is. */
2393 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
2395 if (end
< start
) end
= start
;
2396 if (whole
< (end
- start
)) whole
= end
- start
;
2399 start
= end
= whole
= 0;
2401 /* Indicate what this scroll bar ought to be displaying now. */
2402 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
2404 /* Note that we actually used the scroll bar attached to this window,
2405 so it shouldn't be deleted at the end of redisplay. */
2406 (*redeem_scroll_bar_hook
) (w
);
2409 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
2410 if (update_mode_line
)
2411 set_buffer_internal_1 (old
);
2413 set_buffer_temp (old
);
2414 TEMP_SET_PT_BOTH (lpoint
, lpoint_byte
);
2417 /* Do full redisplay on one window, starting at position `pos'. */
2420 try_window (window
, pos
)
2424 register struct window
*w
= XWINDOW (window
);
2425 register int height
= window_internal_height (w
);
2426 register int vpos
= XFASTINT (w
->top
);
2427 register int last_text_vpos
= vpos
;
2428 FRAME_PTR f
= XFRAME (w
->frame
);
2429 int width
= window_internal_width (w
) - 1;
2430 struct position val
;
2432 /* POS should never be out of range! */
2433 if (pos
< XBUFFER (w
->buffer
)->begv
2434 || pos
> XBUFFER (w
->buffer
)->zv
)
2437 if (XMARKER (w
->start
)->charpos
!= pos
)
2438 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2441 overlay_arrow_seen
= 0;
2442 zv_strings_seen
= 0;
2443 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
2444 val
.ovstring_chars_done
= 0;
2445 val
.bytepos
= marker_byte_position (w
->start
);
2446 val
.tab_offset
= pos_tab_offset (w
, pos
, val
.bytepos
);
2448 while (--height
>= 0)
2450 val
= *display_text_line (w
, pos
, val
.bytepos
, vpos
,
2451 val
.hpos
, val
.tab_offset
,
2452 val
.ovstring_chars_done
);
2453 /* The following code is omitted because we maintain tab_offset
2456 tab_offset
+= width
;
2457 if (val
.vpos
) tab_offset
= 0;
2460 if (pos
!= val
.bufpos
)
2463 #ifdef USE_TEXT_PROPERTIES
2464 Lisp_Object invis_prop
;
2465 invis_prop
= Fget_char_property (val
.bufpos
-1, Qinvisible
, window
);
2466 invis
= TEXT_PROP_MEANS_INVISIBLE (invis_prop
);
2470 /* Next line, unless prev line ended in end of buffer with no cr */
2472 && (FETCH_BYTE (val
.bytepos
- 1) != '\n' || invis
));
2477 /* If last line is continued in middle of character,
2478 include the split character in the text considered on the frame */
2479 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2482 /* If bottom just moved off end of frame, change mode line percentage. */
2483 if (XFASTINT (w
->window_end_pos
) == 0
2485 w
->update_mode_line
= Qt
;
2487 /* Say where last char on frame will be, once redisplay is finished. */
2488 XSETFASTINT (w
->window_end_pos
, Z
- pos
);
2489 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
- XFASTINT (w
->top
));
2490 /* But that is not valid info until redisplay finishes. */
2491 w
->window_end_valid
= Qnil
;
2494 /* Try to redisplay when buffer is modified locally,
2495 computing insert/delete line to preserve text outside
2496 the bounds of the changes.
2497 Return 1 if successful, 0 if if cannot tell what to do,
2498 or -1 to tell caller to find a new window start,
2499 or -2 to tell caller to do normal redisplay with same window start. */
2502 try_window_id (window
)
2506 int opoint
, opoint_byte
;
2507 register struct window
*w
= XWINDOW (window
);
2508 register int height
= window_internal_height (w
);
2509 FRAME_PTR f
= XFRAME (w
->frame
);
2510 int top
= XFASTINT (w
->top
);
2511 int start
= marker_position (w
->start
);
2512 int width
= window_internal_width (w
) - 1;
2513 int hscroll
= XINT (w
->hscroll
);
2514 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
2517 register int i
, tem
;
2518 int last_text_vpos
= 0;
2520 int selective
= (INTEGERP (current_buffer
->selective_display
)
2521 ? XINT (current_buffer
->selective_display
)
2522 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
2523 struct position val
, bp
, ep
, xp
, pp
;
2524 int scroll_amount
= 0;
2528 int start_byte
= marker_byte_position (w
->start
);
2530 if (GPT
- BEG
< beg_unchanged
)
2531 beg_unchanged
= GPT
- BEG
;
2532 if (Z
- GPT
< end_unchanged
)
2533 end_unchanged
= Z
- GPT
;
2535 if (beg_unchanged
+ BEG
< start
)
2536 return 0; /* Give up if changes go above top of window */
2538 /* Find position before which nothing is changed. */
2539 bp
= *compute_motion (start
, 0, lmargin
, 0,
2540 min (ZV
, beg_unchanged
+ BEG
), height
,
2541 /* BUG FIX: See the comment of
2542 Fpos_visible_in_window_p (window.c). */
2543 - (1 << (BITS_PER_SHORT
- 1)),
2545 pos_tab_offset (w
, start
, start_byte
),
2547 if (bp
.vpos
>= height
)
2551 /* All changes are beyond the window end, and point is on the screen.
2552 We don't need to change the text at all.
2553 But we need to update window_end_pos to account for
2554 any change in buffer size. */
2555 bp
= *compute_motion (start
, 0, lmargin
, 0,
2557 /* BUG FIX: See the comment of
2558 Fpos_visible_in_window_p() (window.c). */
2559 - (1 << (BITS_PER_SHORT
- 1)),
2561 pos_tab_offset (w
, start
, start_byte
), w
);
2562 XSETFASTINT (w
->window_end_vpos
, height
);
2563 XSETFASTINT (w
->window_end_pos
, Z
- bp
.bufpos
);
2571 /* Find beginning of that frame line. Must display from there. */
2572 bp
= *vmotion (bp
.bufpos
, 0, w
);
2575 pos_byte
= bp
.bytepos
;
2581 /* If about to start displaying at the beginning of a continuation line,
2582 really start with previous frame line, in case it was not
2583 continued when last redisplayed */
2584 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
2586 /* Likewise if we have to worry about selective display. */
2587 (selective
> 0 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
2589 bp
= *vmotion (bp
.bufpos
, -1, w
);
2592 pos_byte
= bp
.bytepos
;
2594 val
.tab_offset
= bp
.tab_offset
; /* Update tab offset. */
2596 if (bp
.contin
&& bp
.hpos
!= lmargin
)
2598 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
2599 val
.tab_offset
= bp
.tab_offset
+ bp
.prevhpos
- width
;
2601 DEC_BOTH (pos
, pos_byte
);
2606 /* Find first visible newline after which no more is changed. */
2607 opoint
= PT
, opoint_byte
= PT_BYTE
;
2608 SET_PT (Z
- max (end_unchanged
, Z
- ZV
));
2609 scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, 1, 1);
2611 while (PT
< ZV
- 1 && indented_beyond_p (PT
, PT_BYTE
, selective
))
2612 scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, 1, 1);
2614 SET_PT_BOTH (opoint
, opoint_byte
);
2616 /* Compute the cursor position after that newline. */
2617 ep
= *compute_motion (pos
, vpos
, val
.hpos
, did_motion
, tem
,
2618 height
, - (1 << (BITS_PER_SHORT
- 1)),
2620 /* We have tab offset in VAL, use it. */
2623 /* If changes reach past the text available on the frame,
2624 just display rest of frame. */
2625 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
2628 stop_vpos
= ep
.vpos
;
2630 /* If no newline before ep, the line ep is on includes some changes
2631 that must be displayed. Make sure we don't stop before it. */
2632 /* Also, if changes reach all the way until ep.bufpos,
2633 it is possible that something was deleted after the
2634 newline before it, so the following line must be redrawn. */
2635 if (stop_vpos
== ep
.vpos
2636 && (ep
.bufpos
== BEGV
2637 || FETCH_BYTE (ep
.bufpos
- 1) != '\n'
2638 || ep
.bufpos
== Z
- end_unchanged
))
2639 stop_vpos
= ep
.vpos
+ 1;
2642 overlay_arrow_seen
= 0;
2643 zv_strings_seen
= 0;
2645 /* If changes do not reach to bottom of window,
2646 figure out how much to scroll the rest of the window */
2647 if (stop_vpos
< height
)
2649 /* Now determine how far up or down the rest of the window has moved */
2650 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2651 Z
- XFASTINT (w
->window_end_pos
),
2652 /* Don't care for VPOS... */
2653 1 << (BITS_PER_SHORT
- 1),
2655 1 << (BITS_PER_SHORT
- 1),
2656 width
, hscroll
, ep
.tab_offset
, w
);
2657 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
2659 /* Is everything on frame below the changes whitespace?
2660 If so, no scrolling is really necessary. */
2661 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
2663 tem
= FETCH_BYTE (i
);
2664 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
2670 XSETFASTINT (w
->window_end_vpos
,
2671 XFASTINT (w
->window_end_vpos
) + scroll_amount
);
2673 /* Before doing any scrolling, verify that point will be on frame. */
2674 if (PT
> ep
.bufpos
&& !(PT
<= xp
.bufpos
&& xp
.vpos
< height
))
2676 if (PT
<= xp
.bufpos
)
2678 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
, 1,
2679 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2681 /* We have tab offset in EP, use it. */
2686 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
, 1,
2687 PT
, height
, - (1 << (BITS_PER_SHORT
- 1)),
2689 /* We have tab offset in XP, use it. */
2692 if (pp
.bufpos
< PT
|| pp
.vpos
== height
)
2694 cursor_vpos
= pp
.vpos
+ top
;
2695 cursor_hpos
= WINDOW_LEFT_MARGIN (w
) + minmax (0, pp
.hpos
, width
);
2698 if (stop_vpos
- scroll_amount
>= height
2699 || ep
.bufpos
== xp
.bufpos
)
2701 if (scroll_amount
< 0)
2702 stop_vpos
-= scroll_amount
;
2704 /* In this path, we have altered window_end_vpos
2705 and not left it negative.
2706 We must make sure that, in case display is preempted
2707 before the frame changes to reflect what we do here,
2708 further updates will not come to try_window_id
2709 and assume the frame and window_end_vpos match. */
2710 blank_end_of_window
= 1;
2712 else if (!scroll_amount
)
2714 /* Even if we don't need to scroll, we must adjust the
2715 charstarts of subsequent lines (that we won't redisplay)
2716 according to the amount of text inserted or deleted. */
2717 int oldpos
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2718 int adjust
= ep
.bufpos
- oldpos
;
2719 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1, adjust
);
2721 else if (bp
.bufpos
== Z
- end_unchanged
)
2723 /* If reprinting everything is nearly as fast as scrolling,
2724 don't bother scrolling. Can happen if lines are short. */
2725 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
2726 top
+ height
- max (0, scroll_amount
),
2728 > xp
.bufpos
- bp
.bufpos
- 20)
2729 /* Return "try normal display with same window-start."
2730 Too bad we can't prevent further scroll-thinking. */
2732 /* If pure deletion, scroll up as many lines as possible.
2733 In common case of killing a line, this can save the
2734 following line from being overwritten by scrolling
2735 and therefore having to be redrawn. */
2736 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
2737 top
+ height
- max (0, scroll_amount
),
2738 scroll_amount
, bp
.bufpos
);
2743 /* scroll_frame_lines did not properly adjust subsequent
2744 lines' charstarts in the case where the text of the
2745 screen line at bp.vpos has changed.
2746 (This can happen in a deletion that ends in mid-line.)
2747 To adjust properly, we need to make things consistent
2749 So do a second adjust to make that happen.
2750 Note that stop_vpos >= ep.vpos, so it is sufficient
2751 to update the charstarts for lines at ep.vpos and below. */
2753 = FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
2754 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1,
2755 ep
.bufpos
- oldstart
);
2758 else if (scroll_amount
)
2760 /* If reprinting everything is nearly as fast as scrolling,
2761 don't bother scrolling. Can happen if lines are short. */
2762 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
2763 overestimate of cost of reprinting, since xp.bufpos
2764 would end up below the bottom of the window. */
2765 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
2766 top
+ height
- max (0, scroll_amount
),
2768 > xp
.bufpos
- ep
.bufpos
- 20)
2769 /* Return "try normal display with same window-start."
2770 Too bad we can't prevent further scroll-thinking. */
2772 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
2773 top
+ height
- max (0, scroll_amount
),
2774 scroll_amount
, ep
.bufpos
);
2775 if (!tem
) stop_vpos
= height
;
2779 /* In any case, do not display past bottom of window */
2780 if (stop_vpos
>= height
)
2786 /* Handle case where pos is before w->start --
2787 can happen if part of line had been clipped and is not clipped now */
2788 if (vpos
== 0 && pos
< marker_position (w
->start
))
2789 Fset_marker (w
->start
, make_number (pos
), Qnil
);
2791 val
.bytepos
= pos_byte
;
2793 /* Redisplay the lines where the text was changed */
2794 last_text_vpos
= vpos
;
2795 /* The following code is omitted because we maintain tab offset in
2798 tab_offset
= pos_tab_offset (w
, pos
, pos_byte
);
2799 /* If we are starting display in mid-character, correct tab_offset
2800 to account for passing the line that that character really starts in. */
2801 if (val
.hpos
< lmargin
)
2802 tab_offset
+= width
;
2805 while (vpos
< stop_vpos
)
2807 val
= *display_text_line (w
, pos
, val
.bytepos
, top
+ vpos
++,
2808 val
.hpos
, val
.tab_offset
,
2809 val
.ovstring_chars_done
);
2810 /* If display_text_line ran a hook and changed some text,
2811 redisplay all the way to bottom of buffer
2812 So that we show the changes. */
2813 if (old_tick
!= MODIFF
)
2815 /* The following code is omitted because we maintain tab offset
2816 in val.tab_offset. */
2818 tab_offset
+= width
;
2819 if (val
.vpos
) tab_offset
= 0;
2821 if (pos
!= val
.bufpos
)
2823 /* Next line, unless prev line ended in end of buffer with no cr */
2824 = vpos
- (val
.vpos
&& FETCH_BYTE (val
.bufpos
- 1) != '\n');
2828 /* There are two cases:
2829 1) we have displayed down to the bottom of the window
2830 2) we have scrolled lines below stop_vpos by scroll_amount */
2834 /* If last line is continued in middle of character,
2835 include the split character in the text considered on the frame */
2836 if (val
.hpos
< lmargin
)
2838 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
);
2839 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2842 /* If scrolling made blank lines at window bottom,
2843 redisplay to fill those lines */
2844 if (scroll_amount
< 0)
2846 /* Don't consider these lines for general-purpose scrolling.
2847 That will save time in the scrolling computation. */
2848 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
2851 pos_byte
= xp
.bytepos
;
2853 val
.tab_offset
= xp
.tab_offset
;
2855 { /* Display from next line */
2856 vpos
= height
+ scroll_amount
;
2860 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
2862 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
2863 val
.tab_offset
= xp
.tab_offset
+ bp
.prevhpos
- width
;
2864 DEC_BOTH (pos
, pos_byte
);
2867 blank_end_of_window
= 1;
2868 /* The following code is omitted because we maintain tab offset
2869 in val.tab_offset. */
2871 tab_offset
= pos_tab_offset (w
, pos
, pos_byte
);
2872 /* If we are starting display in mid-character, correct tab_offset
2873 to account for passing the line that that character starts in. */
2874 if (val
.hpos
< lmargin
)
2875 tab_offset
+= width
;
2878 while (vpos
< height
)
2880 val
= *display_text_line (w
, pos
, val
.bytepos
,
2881 top
+ vpos
++, val
.hpos
,
2882 val
.tab_offset
, val
.ovstring_chars_done
);
2883 /* The following code is omitted because we maintain tab
2884 offset in val.tab_offset. */
2886 tab_offset
+= width
;
2887 if (val
.vpos
) tab_offset
= 0;
2892 /* Here is a case where display_text_line sets cursor_vpos wrong.
2893 Make it be fixed up, below. */
2899 /* If bottom just moved off end of frame, change mode line percentage. */
2900 if (XFASTINT (w
->window_end_pos
) == 0
2902 w
->update_mode_line
= Qt
;
2904 /* Attempt to adjust end-of-text positions to new bottom line */
2907 delta
= height
- xp
.vpos
;
2909 || (delta
> 0 && xp
.bufpos
<= ZV
)
2910 || (delta
== 0 && xp
.hpos
))
2912 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
), delta
, w
);
2913 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
2914 XSETFASTINT (w
->window_end_vpos
,
2915 XFASTINT (w
->window_end_vpos
) + val
.vpos
);
2919 w
->window_end_valid
= Qnil
;
2921 /* If point was not in a line that was displayed, find it */
2922 if (cursor_vpos
< 0)
2925 val
= *compute_motion (start
, 0, lmargin
, 0, PT
,
2926 /* Don't care for VPOS... */
2927 1 << (BITS_PER_SHORT
- 1),
2929 1 << (BITS_PER_SHORT
- 1),
2931 pos_tab_offset (w
, start
, start_byte
),
2933 /* Admit failure if point is off frame now */
2934 if (val
.vpos
>= height
)
2936 for (vpos
= 0; vpos
< height
; vpos
++)
2937 cancel_line (vpos
+ top
, f
);
2940 cursor_vpos
= val
.vpos
+ top
;
2941 cursor_hpos
= WINDOW_LEFT_MARGIN (w
) + minmax (0, val
.hpos
, width
);
2944 FRAME_CURSOR_X (f
) = cursor_hpos
;
2945 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2949 val
= *compute_motion (start
, 0, lmargin
, 0, ZV
,
2950 height
, - (1 << (BITS_PER_SHORT
- 1)),
2952 pos_tab_offset (w
, start
, start_byte
),
2954 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
2956 if (XFASTINT (w
->window_end_pos
)
2964 /* Copy LEN glyphs starting address FROM to the rope TO.
2965 But don't actually copy the parts that would come in before S.
2966 Value is TO, advanced past the copied data.
2967 F is the frame we are displaying in. */
2970 copy_part_of_rope (f
, to
, s
, from
, len
, face
)
2972 register GLYPH
*to
; /* Copy to here. */
2973 register GLYPH
*s
; /* Starting point. */
2974 Lisp_Object
*from
; /* Data to copy. */
2976 int face
; /* Face to apply to glyphs which don't specify one. */
2979 register Lisp_Object
*fp
= from
;
2980 /* These cache the results of the last call to compute_glyph_face. */
2982 int last_merged
= 0;
2985 if (! FRAME_TERMCAP_P (f
))
2988 GLYPH glyph
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
2990 unsigned int c
= FAST_GLYPH_CHAR (glyph
);
2993 /* For an invalid character code, use space. */
2996 if (FAST_GLYPH_FACE (glyph
) == 0)
2997 /* If GLYPH has no face code, use FACE. */
2999 else if (FAST_GLYPH_FACE (glyph
) == last_code
)
3000 /* If it's same as previous glyph, use same result. */
3001 facecode
= last_merged
;
3004 /* Merge this glyph's face and remember the result. */
3005 last_code
= FAST_GLYPH_FACE (glyph
);
3006 last_merged
= facecode
= compute_glyph_face (f
, last_code
, face
);
3010 *to
= FAST_MAKE_GLYPH (c
, facecode
);
3018 if (to
>= s
) *to
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
3025 /* Correct a glyph by replacing its specified user-level face code
3026 with a displayable computed face code. */
3029 fix_glyph (f
, glyph
, cface
)
3035 if (! FRAME_TERMCAP_P (f
))
3037 if (FAST_GLYPH_FACE (glyph
) != 0)
3038 cface
= compute_glyph_face (f
, FAST_GLYPH_FACE (glyph
), cface
);
3039 glyph
= FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph
), cface
);
3045 /* Return the column of position POS / POS_BYTE in window W's buffer.
3046 The result is rounded down to a multiple of the internal width of W.
3047 This is the amount of indentation of position POS
3048 that is not visible in its horizontal position in the window. */
3051 pos_tab_offset (w
, pos
, pos_byte
)
3053 register int pos
, pos_byte
;
3056 int opoint_byte
= PT_BYTE
;
3058 int width
= window_internal_width (w
) - 1;
3061 return MINI_WINDOW_P (w
) ? -minibuf_prompt_width
: 0;
3063 if (FETCH_BYTE (pos_byte
- 1) == '\n')
3066 TEMP_SET_PT_BOTH (pos
, pos_byte
);
3067 col
= current_column ();
3068 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
3073 /* Display one line of window W, starting at char position START in W's buffer.
3074 START_BYTE is the corresponding byte position.
3076 Display starting at horizontal position HPOS, expressed relative to
3077 W's left edge. In situations where the text at START shouldn't
3078 start at the left margin (i.e. when the window is hscrolled, or
3079 we're continuing a line which left off in the midst of a
3080 multi-column character), HPOS should be negative; we throw away
3081 characters up 'til hpos = 0. So, HPOS must take hscrolling into
3084 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
3086 OVSTR_DONE is the number of chars of overlay before/after strings
3087 at this position which have already been processed.
3089 Display on position VPOS on the frame. It is origin 0, relative to
3090 the top of the frame, not W.
3092 Returns a STRUCT POSITION giving character to start next line with
3093 and where to display it, including a zero or negative hpos.
3094 The vpos field is not really a vpos; it is 1 unless the line is continued */
3096 struct position val_display_text_line
;
3098 static struct position
*
3099 display_text_line (w
, start
, start_byte
, vpos
, hpos
, taboffset
, ovstr_done
)
3107 register int pos
= start
;
3108 int pos_byte
= start_byte
;
3111 int pause
, limit_byte
;
3112 register unsigned char *p
;
3114 register GLYPH
*leftmargin
;
3115 register GLYPH
*p1prev
;
3116 register GLYPH
*p1start
;
3117 GLYPH
*p1_wide_column_end
= (GLYPH
*) 0;
3118 int prevpos
, prevpos_byte
;
3120 FRAME_PTR f
= XFRAME (w
->frame
);
3121 int tab_width
= XINT (current_buffer
->tab_width
);
3122 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
3123 int width
= window_internal_width (w
) - 1;
3124 struct position val
;
3125 int lastpos
, lastpos_byte
;
3127 int last_invis_skip
= 0;
3128 Lisp_Object last_invis_prop
;
3129 int hscroll
= XINT (w
->hscroll
);
3130 int truncate
= (hscroll
3131 || (truncate_partial_width_windows
3132 && !WINDOW_FULL_WIDTH_P (w
))
3133 || !NILP (current_buffer
->truncate_lines
));
3135 /* 1 if this buffer has a region to highlight. */
3136 int highlight_region
3137 = (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
)
3138 && XMARKER (current_buffer
->mark
)->buffer
!= 0);
3139 int region_beg
, region_end
;
3141 int selective
= (INTEGERP (current_buffer
->selective_display
)
3142 ? XINT (current_buffer
->selective_display
)
3143 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
3144 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
3145 register struct Lisp_Char_Table
*dp
= window_display_table (w
);
3147 Lisp_Object default_invis_vector
[3];
3148 /* Number of characters of ellipsis to display after an invisible line
3149 if it calls for an ellipsis.
3150 Note that this value can be nonzero regardless of whether
3151 selective display is enabled--you must check that separately. */
3153 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
3154 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
3155 : !NILP (current_buffer
->selective_display_ellipses
) ? 3 : 0);
3156 /* This is the sequence of Lisp objects to display
3157 when there are invisible lines. */
3158 Lisp_Object
*invis_vector_contents
3159 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
3160 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
3161 : default_invis_vector
);
3163 GLYPH truncator
= (dp
== 0 || !INTEGERP (DISP_TRUNC_GLYPH (dp
))
3164 || !GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (dp
)))
3165 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
3166 GLYPH continuer
= (dp
== 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp
))
3167 || !GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (dp
)))
3168 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
3170 /* If 1, we must handle multibyte characters. */
3171 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
3172 /* Length of multibyte form of each character. */
3174 /* Glyphs generated should be set this bit mask if text must be
3175 displayed from right to left. */
3176 GLYPH rev_dir_bit
= (NILP (current_buffer
->direction_reversed
)
3177 ? 0 : GLYPH_MASK_REV_DIR
);
3179 /* The next buffer location at which the face should change, due
3180 to overlays or text property changes. */
3181 int next_face_change
;
3183 /* The next location where the `invisible' property changes, or an
3184 overlay starts or ends. */
3187 /* The face we're currently using. */
3188 int current_face
= 0;
3191 XSETFASTINT (default_invis_vector
[2], '.');
3192 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
3194 get_display_line (f
, vpos
, WINDOW_LEFT_MARGIN (w
));
3195 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
3197 /* Show where to highlight the region. */
3198 if (highlight_region
3199 /* Maybe highlight only in selected window. */
3200 && (highlight_nonselected_windows
3201 || w
== XWINDOW (selected_window
)
3202 || (MINI_WINDOW_P (XWINDOW (selected_window
))
3203 && w
== XWINDOW (Vminibuf_scroll_window
))))
3205 region_beg
= marker_position (current_buffer
->mark
);
3206 if (PT
< region_beg
)
3208 region_end
= region_beg
;
3213 w
->region_showing
= Qt
;
3217 region_beg
= region_end
= -1;
3218 w
->region_showing
= Qnil
;
3221 if (MINI_WINDOW_P (w
)
3223 && vpos
== XFASTINT (w
->top
))
3225 if (! NILP (minibuf_prompt
))
3227 int old_width
= minibuf_prompt_width
;
3229 minibuf_prompt_width
3230 = (display_string (w
, vpos
, XSTRING (minibuf_prompt
)->data
,
3231 XSTRING (minibuf_prompt
)->size_byte
,
3232 hpos
+ WINDOW_LEFT_MARGIN (w
),
3233 /* Display a space if we truncate. */
3236 /* Truncate the prompt a little before the
3237 margin, so user input can at least start
3238 on the first line. */
3239 (XFASTINT (w
->width
) > 10
3240 ? XFASTINT (w
->width
) - 4 : -1),
3241 STRING_MULTIBYTE (minibuf_prompt
))
3242 - hpos
- WINDOW_LEFT_MARGIN (w
));
3243 hpos
+= minibuf_prompt_width
;
3244 taboffset
-= minibuf_prompt_width
- old_width
;
3247 minibuf_prompt_width
= 0;
3250 /* If we're hscrolled at all, use compute_motion to skip over any
3251 text off the left edge of the window. compute_motion may know
3252 tricks to do this faster than we can. */
3255 struct position
*left_edge
3256 = compute_motion (pos
, vpos
, hpos
, 0,
3258 width
, hscroll
, taboffset
, w
);
3260 /* Retrieve the buffer position and column provided by
3261 compute_motion. We can't assume that the column will be
3262 zero, because you may have multi-column characters crossing
3265 compute_motion may have moved us past the screen position we
3266 requested, if we hit a multi-column character, or the end of
3267 the line. If so, back up. */
3268 if (left_edge
->vpos
> vpos
3269 || left_edge
->hpos
> 0)
3271 pos
= left_edge
->bufpos
;
3272 pos_byte
= left_edge
->bytepos
;
3273 DEC_BOTH (pos
, pos_byte
);
3274 hpos
= left_edge
->prevhpos
;
3278 pos
= left_edge
->bufpos
;
3279 pos_byte
= left_edge
->bytepos
;
3280 hpos
= left_edge
->hpos
;
3284 hpos
+= WINDOW_LEFT_MARGIN (w
);
3286 desired_glyphs
->bufp
[vpos
] = start
;
3287 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
3289 charstart
= desired_glyphs
->charstarts
[vpos
] + hpos
;
3290 /* In case we don't ever write anything into it... */
3291 desired_glyphs
->charstarts
[vpos
][WINDOW_LEFT_MARGIN (w
)] = -1;
3292 leftmargin
= desired_glyphs
->glyphs
[vpos
] + WINDOW_LEFT_MARGIN (w
);
3293 endp
= leftmargin
+ width
;
3295 /* Arrange the overlays nicely for our purposes. Usually, we call
3296 display_text_line on only one line at a time, in which case this
3297 can't really hurt too much, or we call it on lines which appear
3298 one after another in the buffer, in which case all calls to
3299 recenter_overlay_lists but the first will be pretty cheap. */
3300 recenter_overlay_lists (current_buffer
, pos
);
3302 /* Loop generating characters.
3303 Stop at end of buffer, before newline,
3304 if reach or pass continuation column,
3305 or at face change. */
3307 limit_byte
= pos_byte
;
3308 next_face_change
= pos
;
3309 next_boundary
= pos
;
3312 prevpos_byte
= pos_byte
;
3314 /* If the window is hscrolled and point is in the invisible part of the
3315 current line beyond the left margin we can record the cursor location
3317 if (hscroll
&& start
<= PT
&& PT
< pos
&& cursor_vpos
< 0)
3320 cursor_hpos
= p1
- leftmargin
;
3325 int eat_following_binary_data
;
3331 while (pos
== next_boundary
)
3333 Lisp_Object position
, limit
, prop
, ww
;
3335 /* Display the overlay strings here, unless we're at ZV
3336 and have already displayed the appropriate strings
3337 on an earlier line. */
3338 if (pos
< ZV
|| !zv_strings_seen
++)
3341 unsigned char *ovstr
;
3342 ovlen
= overlay_strings (pos
, w
, &ovstr
);
3346 /* Skip the ones we did in a previous line. */
3347 ovstr
+= ovstr_done
;
3348 ovlen
-= ovstr_done
;
3357 c
= STRING_CHAR_AND_LENGTH (ovstr
, ovlen
, len
);
3358 ovstr
+= len
, ovlen
-= len
, ovstr_done
+= len
;
3359 charset
= CHAR_CHARSET (c
);
3360 cols
= (charset
== CHARSET_COMPOSITION
3361 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
3362 : CHARSET_WIDTH (charset
));
3366 c
= *ovstr
++, ovlen
--, ovstr_done
++;
3369 g
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3372 if (p1
>= leftmargin
&& p1
< endp
)
3373 *p1
= g
, g
|= GLYPH_MASK_PADDING
;
3377 /* If we did all the overlay strings
3378 and we have room for text, clear ovstr_done
3379 just for neatness' sake. */
3380 if (ovlen
== 0 && p1
< endp
)
3385 /* Did we reach point? Record the cursor location. */
3386 if (pos
== PT
&& cursor_vpos
< 0)
3389 cursor_hpos
= p1
- leftmargin
;
3395 XSETFASTINT (position
, pos
);
3396 limit
= Fnext_overlay_change (position
);
3397 #ifdef USE_TEXT_PROPERTIES
3398 /* This is just an estimate to give reasonable
3399 performance; nothing should go wrong if it is too small. */
3400 if (XFASTINT (limit
) > pos
+ 50)
3402 int limitpos
= pos
+ 50;
3403 XSETFASTINT (limit
, limitpos
);
3405 limit
= Fnext_single_property_change (position
, Qinvisible
,
3406 Fcurrent_buffer (), limit
);
3408 next_boundary
= XFASTINT (limit
);
3409 /* if the `invisible' property is set, we can skip to
3410 the next property change. */
3412 prop
= Fget_char_property (position
, Qinvisible
, ww
);
3413 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
3415 if (pos
< PT
&& next_boundary
>= PT
)
3418 cursor_hpos
= p1
- leftmargin
;
3420 pos
= next_boundary
;
3421 pos_byte
= CHAR_TO_BYTE (pos
);
3422 last_invis_skip
= pos
;
3423 last_invis_prop
= prop
;
3427 /* Did we reach point? Record the cursor location. */
3428 if (pos
== PT
&& cursor_vpos
< 0)
3431 cursor_hpos
= p1
- leftmargin
;
3434 /* Did we hit the end of the visible region of the buffer?
3438 /* Update charstarts for the end of this line. */
3439 /* Do nothing if off the left edge or at the right edge. */
3440 if (p1
>= leftmargin
&& p1
+ 1 != endp
)
3442 int *p2x
= &charstart
[(p1
< leftmargin
3450 /* Figure out where (if at all) the
3451 redisplay_end_trigger-hook should run. */
3452 if (MARKERP (w
->redisplay_end_trigger
)
3453 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
3454 e_t_h
= marker_position (w
->redisplay_end_trigger
);
3455 else if (INTEGERP (w
->redisplay_end_trigger
))
3456 e_t_h
= XINT (w
->redisplay_end_trigger
);
3460 /* If we've gone past the place to run a hook,
3462 if (pos
>= e_t_h
&& e_t_h
!= ZV
)
3464 Lisp_Object args
[3];
3466 args
[0] = Qredisplay_end_trigger_functions
;
3467 XSETWINDOW (args
[1], w
);
3468 XSETINT (args
[2], e_t_h
);
3470 /* Since we are *trying* to run these functions,
3471 don't try to run them again, even if they get an error. */
3472 w
->redisplay_end_trigger
= Qnil
;
3473 Frun_hook_with_args (3, args
);
3476 /* Notice if it changed the face of this character. */
3477 next_face_change
= pos
;
3481 /* Did we hit a face change? Figure out what face we should
3482 use now. We also hit this the first time through the
3483 loop, to see what face we should start with. */
3484 if (pos
>= next_face_change
3485 && (FRAME_WINDOW_P (f
) || FRAME_MSDOS_P (f
)))
3487 int limit
= pos
+ 50;
3489 current_face
= compute_char_face (f
, w
, pos
,
3490 region_beg
, region_end
,
3491 &next_face_change
, limit
, 0);
3495 /* Compute the next place we need to stop
3496 and do something special; set PAUSE. */
3500 if (pos
< next_boundary
&& next_boundary
< pause
)
3501 pause
= next_boundary
;
3502 if (pos
< next_face_change
&& next_face_change
< pause
)
3503 pause
= next_face_change
;
3508 /* Wouldn't you hate to read the next line to someone over
3510 if (pos
< PT
&& PT
< pause
)
3512 if (pos
< GPT
&& GPT
< pause
)
3515 /* LIMIT_BYTE is not the same place in the buffer as PAUSE.
3516 It is a limit on valid characters.
3517 We use it to bound STRING_CHAR_AND_LENGTH. */
3518 limit_byte
= ZV_BYTE
;
3519 if (pos
< GPT
&& GPT_BYTE
< limit_byte
)
3520 limit_byte
= GPT_BYTE
;
3523 int temp
= CHAR_TO_BYTE (pos
);
3524 p
= BYTE_POS_ADDR (temp
);
3532 p1_wide_column_end
= (GLYPH
*) 0;
3535 c
= STRING_CHAR_AND_LENGTH (p
, limit_byte
- pos_byte
, len
), p
+= len
;
3538 /* Let a display table override all standard display methods. */
3539 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
3541 p1
= copy_part_of_rope (f
, p1
, leftmargin
,
3542 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
3543 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
3544 current_face
, rev_dir_bit
);
3546 else if (c
>= 040 && c
< 0177)
3548 if (p1
>= leftmargin
)
3549 *p1
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3555 /* Same as p1prev, but after the invis_vector_contents text
3556 (if we have that on this line). */
3557 GLYPH
*p1prev_modified
;
3561 if (last_invis_skip
== pos
3562 && TEXT_PROP_MEANS_INVISIBLE_WITH_ELLIPSIS (last_invis_prop
))
3566 && indented_beyond_p (pos
+ 1, pos_byte
+ 1, selective
))
3568 int opoint
= PT
, opoint_byte
= PT_BYTE
;
3571 INC_BOTH (pos
, pos_byte
);
3572 scan_newline (pos
, pos_byte
, ZV
, ZV_BYTE
, 1, 1);
3573 if (FETCH_BYTE (pos_byte
- 1) == '\n')
3578 SET_PT_BOTH (opoint
, opoint_byte
);
3580 if (invis
&& selective_rlen
> 0 && p1
>= leftmargin
)
3585 cs
= charstart
+ (p1
- p1start
);
3588 p1
+= selective_rlen
;
3589 if (p1
- leftmargin
> width
)
3592 #if 0 /* This needs more work; charstarts needs to record
3593 both whether a position ho;ds an ellipsis character
3594 and what buffer position it corresponds to. */
3595 csend
= charstart
+ (p1
- p1start
);
3598 /* The idea is to use p1prev_modified instead of p1prev
3599 in the loop below over p2x. */
3600 p1prev_modified
= p1
;
3603 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
3604 (p1
- p1prev
), current_face
, rev_dir_bit
);
3607 /* Update charstarts for the newline that ended this line. */
3608 /* Do nothing here for a char that's entirely off the left edge
3609 or if it starts at the right edge. */
3610 if (p1
>= leftmargin
&& p1prev
!= endp
)
3612 /* Store the newline's position into charstarts
3613 for the column where the newline starts.
3614 Store -1 for the rest of the glyphs it occupies. */
3615 int *p2x
= &charstart
[(p1prev
< leftmargin
3616 ? leftmargin
: p1prev
)
3618 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3625 /* Draw the face of the newline character as extending all the
3626 way to the end of the frame line. */
3629 if (p1
< leftmargin
)
3632 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
) | rev_dir_bit
;
3642 if (p1
>= leftmargin
&& p1
< endp
)
3643 *p1
= MAKE_GLYPH (f
, ' ', current_face
) | rev_dir_bit
;
3646 while ((p1
- leftmargin
+ taboffset
+ hscroll
- (hscroll
> 0))
3649 else if (c
== Ctl ('M') && selective
== -1)
3651 int opoint
= PT
, opoint_byte
= PT_BYTE
;
3652 scan_newline (pos
, pos_byte
, ZV
, ZV_BYTE
, 1, 1);
3653 pos
= PT
, pos_byte
= PT_BYTE
;
3654 SET_PT_BOTH (opoint
, opoint_byte
);
3656 if (FETCH_BYTE (pos_byte
- 1) == '\n')
3658 if (selective_rlen
> 0)
3660 p1
+= selective_rlen
;
3661 if (p1
- leftmargin
> width
)
3663 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
3664 (p1
- p1prev
), current_face
, rev_dir_bit
);
3667 /* Draw the face of the newline character as extending all the
3668 way to the end of the frame line. */
3671 if (p1
< leftmargin
)
3674 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
) | rev_dir_bit
;
3678 /* Update charstarts for the ^M that ended this line. */
3679 /* Do nothing here for a char that's entirely off the left edge
3680 or if it starts at the right edge. */
3681 if (p1
>= leftmargin
&& p1prev
!= endp
)
3683 /* Store the newline's position into charstarts
3684 for the column where the newline starts.
3685 Store -1 for the rest of the glyphs it occupies. */
3686 int *p2x
= &charstart
[(p1prev
< leftmargin
3687 ? leftmargin
: p1prev
)
3689 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3697 else if (c
< 0200 && ctl_arrow
)
3699 if (p1
>= leftmargin
)
3701 (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
3702 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp
)))
3703 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
3707 if (p1
>= leftmargin
&& p1
< endp
)
3708 *p1
= MAKE_GLYPH (f
, c
^ 0100, current_face
) | rev_dir_bit
;
3713 /* C is not a multibyte character. */
3714 eat_following_binary_data
= multibyte
&& BASE_LEADING_CODE_P (c
);
3716 label_display_binary_data
:
3718 if (p1
>= leftmargin
&& p1
< endp
)
3720 (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
3721 && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp
)))
3722 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
3726 if (p1
>= leftmargin
&& p1
< endp
)
3727 *p1
= MAKE_GLYPH (f
, (c
>> 6) + '0', current_face
) | rev_dir_bit
;
3729 if (p1
>= leftmargin
&& p1
< endp
)
3730 *p1
= (MAKE_GLYPH (f
, (7 & (c
>> 3)) + '0', current_face
)
3733 if (p1
>= leftmargin
&& p1
< endp
)
3734 *p1
= MAKE_GLYPH (f
, (7 & c
) + '0', current_face
) | rev_dir_bit
;
3736 } while (eat_following_binary_data
3737 && (pos_byte
+ len
) < limit_byte
3738 && ! CHAR_HEAD_P (*p
)
3739 && ((c
= *p
++), len
++));
3743 /* C is a multibyte character. */
3744 int charset
= CHAR_CHARSET (c
);
3745 int columns
= (charset
== CHARSET_COMPOSITION
3746 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
3747 : CHARSET_WIDTH (charset
));
3748 GLYPH g
= MAKE_GLYPH (f
, c
, current_face
) | rev_dir_bit
;
3752 if (p1
>= leftmargin
&& p1
< endp
)
3753 *p1
= g
, g
|= GLYPH_MASK_PADDING
;
3757 p1_wide_column_end
= p1
;
3758 /* Check if binary data follows it. */
3759 if (pos_byte
+ len
< limit_byte
3760 && ! CHAR_HEAD_P (*p
))
3762 eat_following_binary_data
= 1;
3765 goto label_display_binary_data
;
3770 prevpos_byte
= pos_byte
;
3774 /* Update charstarts for the character just output. */
3776 /* Do nothing here for a char that's entirely off the left edge. */
3777 if (p1
>= leftmargin
)
3779 /* Store the char's position into charstarts
3780 for the first glyph occupied by this char.
3781 Store -1 for the rest of the glyphs it occupies. */
3784 int *p2x
= &charstart
[(p1prev
< leftmargin
3785 ? leftmargin
: p1prev
)
3787 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
3797 val
.hpos
= - XINT (w
->hscroll
);
3804 lastpos_byte
= pos_byte
;
3806 /* Store 0 in this charstart line for the positions where
3807 there is no character. But do leave what was recorded
3808 for the character that ended the line. */
3809 /* Add 1 in the endtest to compensate for the fact that ENDP was
3810 made from WIDTH, which is 1 less than the window's actual
3812 i
= p1
- p1start
+ 1;
3813 if (p1
< leftmargin
)
3814 i
+= leftmargin
- p1
;
3815 for (; i
< endp
- p1start
+ 1; i
++)
3818 /* Handle continuation in middle of a character */
3819 /* by backing up over it */
3822 /* Don't back up if we never actually displayed any text.
3823 This occurs when the minibuffer prompt takes up the whole line. */
3826 /* Start the next line with that same character whose
3827 character code is C and the length of multi-byte form is
3830 pos_byte
= prevpos_byte
;
3832 if (p1_wide_column_end
< endp
)
3833 /* As ENDP is not in the middle of wide-column character,
3834 we can break the line at ENDP and start from the middle
3835 column in the next line. So, adjust VAL.HPOS to skip
3836 the columns output on this line. */
3837 val
.hpos
+= p1prev
- endp
;
3840 /* We displayed a wide-column character at around ENDP.
3841 Since we can't broke it in the middle, the whole
3842 character should be driven into the next line. */
3843 /* As the result, the actual columns occupied by the
3844 text on this line is less than WIDTH. VAL.TAB_OFFSET
3845 must be adjusted. */
3846 taboffset
= taboffset
+ (p1prev
- endp
);
3847 /* Let's fill unused columns with TRUNCATOR or CONTINUER. */
3849 GLYPH g
= fix_glyph (f
, truncate
? truncator
: continuer
, 0);
3850 while (p1prev
< endp
)
3853 /* If POINT is at POS, cursor should not on this line. */
3855 lastpos_byte
= pos_byte
;
3861 /* Keep in this line everything up to the continuation column. */
3865 /* Finish deciding which character to start the next line on,
3866 and what hpos to start it at.
3867 Also set `lastpos' to the last position which counts as "on this line"
3868 for cursor-positioning. */
3872 if (FETCH_BYTE (pos_byte
) == '\n')
3874 int opoint
= PT
, opoint_byte
= PT_BYTE
;
3876 /* If stopped due to a newline, start next line after it */
3877 SET_PT_BOTH (pos
+ 1, pos_byte
+ 1);
3880 /* Check again for hidden lines, in case the newline occurred exactly
3881 at the right margin. */
3882 while (PT
< ZV
&& selective
> 0
3883 && indented_beyond_p (PT
, PT_BYTE
, selective
))
3884 scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, 1, 1);
3886 pos
= PT
, pos_byte
= PT_BYTE
;
3887 SET_PT_BOTH (opoint
, opoint_byte
);
3890 /* Stopped due to right margin of window */
3894 int opoint
= PT
, opoint_byte
= PT_BYTE
;
3896 SET_PT_BOTH (pos
, pos_byte
);
3897 *p1
++ = fix_glyph (f
, truncator
, 0);
3898 /* Truncating => start next line after next newline,
3899 and point is on this line if it is before the newline,
3900 and skip none of first char of next line */
3902 scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, 1, 1);
3903 while (PT
< ZV
&& selective
> 0
3904 && indented_beyond_p (PT
, PT_BYTE
, selective
));
3905 pos
= PT
, pos_byte
= PT_BYTE
;
3906 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
3907 SET_PT_BOTH (opoint
, opoint_byte
);
3909 lastpos
= pos
- (FETCH_BYTE (pos_byte
- 1) == '\n');
3910 lastpos_byte
= CHAR_TO_BYTE (lastpos
);
3915 *p1
++ = fix_glyph (f
, continuer
, 0);
3917 DEC_BOTH (lastpos
, lastpos_byte
);
3918 val
.tab_offset
= taboffset
+ width
;
3925 /* If point is at eol or in invisible text at eol,
3926 record its frame location now. */
3928 if (start
<= PT
&& PT
<= lastpos
&& cursor_vpos
< 0)
3931 cursor_hpos
= p1
- leftmargin
;
3934 if (cursor_vpos
== vpos
)
3936 if (cursor_hpos
< 0) cursor_hpos
= 0;
3937 if (cursor_hpos
> width
) cursor_hpos
= width
;
3938 cursor_hpos
+= WINDOW_LEFT_MARGIN (w
);
3939 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
3941 if (!(cursor_in_echo_area
&& FRAME_HAS_MINIBUF_P (f
)
3942 && EQ (FRAME_MINIBUF_WINDOW (f
), minibuf_window
)))
3944 FRAME_CURSOR_Y (f
) = cursor_vpos
;
3945 FRAME_CURSOR_X (f
) = cursor_hpos
;
3948 if (w
== XWINDOW (selected_window
))
3950 /* Line is not continued and did not start
3951 in middle of character */
3952 if ((hpos
- WINDOW_LEFT_MARGIN (w
)
3953 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
3956 this_line_bufpos
= start
;
3957 this_line_buffer
= current_buffer
;
3958 this_line_vpos
= cursor_vpos
;
3959 this_line_start_hpos
= hpos
- WINDOW_LEFT_MARGIN (w
);
3960 this_line_endpos
= Z
- lastpos
;
3963 this_line_bufpos
= 0;
3968 /* If hscroll and line not empty, insert truncation-at-left marker */
3969 if (hscroll
&& lastpos
!= start
)
3971 GLYPH g
= fix_glyph (f
, truncator
, 0);
3973 if (p1
<= leftmargin
)
3974 p1
= leftmargin
+ 1;
3975 else /* MULE: it may be a wide-column character */
3977 p1prev
= leftmargin
+ 1;
3978 while (p1prev
< p1
&& *p1prev
& GLYPH_MASK_PADDING
)
3983 if (!WINDOW_RIGHTMOST_P (w
))
3986 if (p1
< leftmargin
) p1
= leftmargin
;
3987 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
3989 /* Don't draw vertical bars if we're using scroll bars. They're
3990 covered up by the scroll bars, and it's distracting to see
3991 them when the scroll bar windows are flickering around to be
3993 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
3996 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
3999 else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4000 *p1
++ = (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
4001 ? XINT (DISP_BORDER_GLYPH (dp
))
4004 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
4005 p1
- desired_glyphs
->glyphs
[vpos
]);
4006 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
4008 /* If the start of this line is the overlay arrow-position,
4009 then put the arrow string into the display-line. */
4011 if (MARKERP (Voverlay_arrow_position
)
4012 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
4013 && start
== marker_position (Voverlay_arrow_position
)
4014 && STRINGP (Voverlay_arrow_string
)
4015 && ! overlay_arrow_seen
)
4018 int len
= XSTRING (Voverlay_arrow_string
)->size
;
4024 if (!NULL_INTERVAL_P (XSTRING (Voverlay_arrow_string
)->intervals
))
4026 /* If the arrow string has text props, obey them when displaying. */
4027 for (i
= 0, i_byte
= 0; i
< len
; )
4030 Lisp_Object face
, ilisp
;
4033 if (STRING_MULTIBYTE (Voverlay_arrow_string
))
4034 FETCH_STRING_CHAR_ADVANCE (c
, Voverlay_arrow_string
, i
, i_byte
);
4036 c
= XSTRING (Voverlay_arrow_string
)->data
[i
++];
4038 XSETFASTINT (ilisp
, i
);
4039 face
= Fget_text_property (ilisp
, Qface
, Voverlay_arrow_string
);
4040 newface
= compute_glyph_face_1 (f
, face
, 0);
4041 leftmargin
[i
] = FAST_MAKE_GLYPH (c
, newface
);
4045 #endif /* HAVE_FACES */
4047 for (i
= 0; i
< len
; i
++)
4048 leftmargin
[i
] = p
[i
];
4051 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
4052 arrow_end
= (leftmargin
- desired_glyphs
->glyphs
[vpos
]) + len
;
4053 if (desired_glyphs
->used
[vpos
] < arrow_end
)
4054 desired_glyphs
->used
[vpos
] = arrow_end
;
4056 overlay_arrow_seen
= 1;
4060 val
.bytepos
= pos_byte
;
4061 val
.ovstring_chars_done
= ovstr_done
;
4062 val_display_text_line
= val
;
4063 return &val_display_text_line
;
4066 /* Redisplay the menu bar in the frame for window W. */
4069 display_menu_bar (w
)
4072 Lisp_Object items
, tail
;
4073 register int vpos
= 0;
4074 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4075 int maxendcol
= FRAME_WIDTH (f
);
4080 if (!NILP (Vwindow_system
))
4084 #ifdef USE_X_TOOLKIT
4087 #endif /* USE_X_TOOLKIT */
4089 get_display_line (f
, vpos
, 0);
4091 items
= FRAME_MENU_BAR_ITEMS (f
);
4092 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
4094 Lisp_Object pos
, string
;
4095 string
= XVECTOR (items
)->contents
[i
+ 1];
4099 XSETFASTINT (XVECTOR (items
)->contents
[i
+ 3], hpos
);
4101 if (hpos
< maxendcol
)
4102 hpos
= display_string (w
, vpos
,
4103 XSTRING (string
)->data
,
4104 XSTRING (string
)->size_byte
,
4105 hpos
, 0, 0, hpos
, maxendcol
,
4106 STRING_MULTIBYTE (string
));
4107 /* Put a space between items. */
4108 if (hpos
< maxendcol
)
4110 int hpos1
= hpos
+ 1;
4111 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0,
4112 min (hpos1
, maxendcol
), maxendcol
, 0);
4116 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
4117 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
4119 /* Fill out the line with spaces. */
4120 if (maxendcol
> hpos
)
4121 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0, maxendcol
, maxendcol
, 0);
4123 /* Clear the rest of the lines allocated to the menu bar. */
4125 while (vpos
< FRAME_MENU_BAR_LINES (f
))
4126 get_display_line (f
, vpos
++, 0);
4129 /* Display the mode line for window w */
4132 display_mode_line (w
)
4135 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
4136 register int left
= WINDOW_LEFT_MARGIN (w
);
4137 register int right
= WINDOW_RIGHT_MARGIN (w
);
4138 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4140 line_number_displayed
= 0;
4141 w
->column_number_displayed
= Qnil
;
4143 get_display_line (f
, vpos
, left
);
4145 /* Temporarily make frame F's kboard the current kboard
4146 so that kboard-local variables in the mode_line_format
4147 will get the right values. */
4148 push_frame_kboard (f
);
4150 display_mode_element (w
, vpos
, left
, 0, right
, right
,
4151 current_buffer
->mode_line_format
);
4153 pop_frame_kboard ();
4155 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
4157 /* Put the mode line in inverse video.
4158 Use faces if possible, since that lets us handle
4159 partial-width windows and avoid inverting the scroll bar columns. */
4161 if (! FRAME_TERMCAP_P (f
) && mode_line_inverse_video
)
4163 /* For a partial width window, explicitly set face of each glyph. */
4165 unsigned int padding
;
4166 GLYPH
*ptr
= FRAME_DESIRED_GLYPHS (f
)->glyphs
[vpos
];
4167 for (i
= left
; i
< right
; ++i
)
4169 padding
= ptr
[i
] & GLYPH_MASK_PADDING
;
4170 ptr
[i
] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr
[i
]), 1) | padding
;
4176 /* Make the mode line inverse video if the entire line
4177 is made of mode lines.
4178 I.e. if this window is full width,
4179 or if it is the child of a full width window
4180 (which implies that that window is split side-by-side
4181 and the rest of this line is mode lines of the sibling windows). */
4182 if (WINDOW_FULL_WIDTH_P (w
)
4183 || WINDOW_FULL_WIDTH_P (XWINDOW (w
->parent
)))
4184 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
4187 /* Contribute ELT to the mode line for window W.
4188 How it translates into text depends on its data type.
4190 VPOS is the position of the mode line being displayed.
4192 HPOS is the position (absolute on frame) where this element's text
4193 should start. The output is truncated automatically at the right
4196 DEPTH is the depth in recursion. It is used to prevent
4197 infinite recursion here.
4199 MINENDCOL is the hpos before which the element may not end.
4200 The element is padded at the right with spaces if nec
4201 to reach this column.
4203 MAXENDCOL is the hpos past which this element may not extend.
4204 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
4205 (This is necessary to make nested padding and truncation work.)
4207 Returns the hpos of the end of the text generated by ELT.
4208 The next element will receive that value as its HPOS arg,
4209 so as to concatenate the elements. */
4212 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
4214 register int vpos
, hpos
;
4217 register int maxendcol
;
4218 register Lisp_Object elt
;
4226 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
4230 /* A string: output it and check for %-constructs within it. */
4231 register unsigned char c
;
4232 register unsigned char *this = XSTRING (elt
)->data
;
4234 while (hpos
< maxendcol
&& *this)
4236 unsigned char *last
= this;
4237 while ((c
= *this++) != '\0' && c
!= '%')
4239 if (this - 1 != last
)
4241 register int lim
= --this - last
+ hpos
;
4242 if (frame_title_ptr
)
4243 hpos
= store_frame_title (last
, hpos
, min (lim
, maxendcol
));
4245 hpos
= display_string (w
, vpos
, last
, -1, hpos
, 0, 1,
4246 hpos
, min (lim
, maxendcol
),
4247 STRING_MULTIBYTE (elt
));
4251 register int minendcol
;
4252 register int spec_width
= 0;
4254 /* We can't allow -ve args due to the "%-" construct */
4255 /* Argument specifies minwidth but not maxwidth
4256 (maxwidth can be specified by
4257 (<negative-number> . <stuff>) mode-line elements) */
4259 while ((c
= *this++) >= '0' && c
<= '9')
4261 spec_width
= spec_width
* 10 + (c
- '0');
4264 minendcol
= hpos
+ spec_width
;
4265 if (minendcol
> maxendcol
)
4267 spec_width
= maxendcol
- hpos
;
4268 minendcol
= maxendcol
;
4272 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
4273 spec_width
, maxendcol
,
4274 Vglobal_mode_string
);
4277 char *spec
= decode_mode_spec (w
, c
, spec_width
,
4279 if (frame_title_ptr
)
4280 hpos
= store_frame_title (spec
, minendcol
, maxendcol
);
4282 hpos
= display_string (w
, vpos
, spec
, -1,
4284 minendcol
, maxendcol
, -1);
4292 /* A symbol: process the value of the symbol recursively
4293 as if it appeared here directly. Avoid error if symbol void.
4294 Special case: if value of symbol is a string, output the string
4297 register Lisp_Object tem
;
4298 tem
= Fboundp (elt
);
4301 tem
= Fsymbol_value (elt
);
4302 /* If value is a string, output that string literally:
4303 don't check for % within it. */
4306 if (frame_title_ptr
)
4307 hpos
= store_frame_title (XSTRING (tem
)->data
,
4308 minendcol
, maxendcol
);
4310 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
4311 XSTRING (tem
)->size_byte
,
4312 hpos
, 0, 1, minendcol
, maxendcol
,
4313 STRING_MULTIBYTE (tem
));
4315 /* Give up right away for nil or t. */
4316 else if (!EQ (tem
, elt
))
4317 { elt
= tem
; goto tail_recurse
; }
4324 register Lisp_Object car
, tem
;
4326 /* A cons cell: three distinct cases.
4327 If first element is a string or a cons, process all the elements
4328 and effectively concatenate them.
4329 If first element is a negative number, truncate displaying cdr to
4330 at most that many characters. If positive, pad (with spaces)
4331 to at least that many characters.
4332 If first element is a symbol, process the cadr or caddr recursively
4333 according to whether the symbol's value is non-nil or nil. */
4334 car
= XCONS (elt
)->car
;
4337 tem
= Fboundp (car
);
4338 elt
= XCONS (elt
)->cdr
;
4341 /* elt is now the cdr, and we know it is a cons cell.
4342 Use its car if CAR has a non-nil value. */
4345 tem
= Fsymbol_value (car
);
4347 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
4349 /* Symbol's value is nil (or symbol is unbound)
4350 Get the cddr of the original list
4351 and if possible find the caddr and use that. */
4352 elt
= XCONS (elt
)->cdr
;
4355 else if (!CONSP (elt
))
4357 elt
= XCONS (elt
)->car
;
4360 else if (INTEGERP (car
))
4362 register int lim
= XINT (car
);
4363 elt
= XCONS (elt
)->cdr
;
4365 /* Negative int means reduce maximum width.
4366 DO NOT change MINENDCOL here!
4367 (20 -10 . foo) should truncate foo to 10 col
4368 and then pad to 20. */
4369 maxendcol
= min (maxendcol
, hpos
- lim
);
4372 /* Padding specified. Don't let it be more than
4375 if (lim
> maxendcol
)
4377 /* If that's more padding than already wanted, queue it.
4378 But don't reduce padding already specified even if
4379 that is beyond the current truncation point. */
4380 if (lim
> minendcol
)
4385 else if (STRINGP (car
) || CONSP (car
))
4387 register int limit
= 50;
4388 /* LIMIT is to protect against circular lists. */
4389 while (CONSP (elt
) && --limit
> 0
4390 && hpos
< maxendcol
)
4392 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
4395 elt
= XCONS (elt
)->cdr
;
4403 if (frame_title_ptr
)
4404 hpos
= store_frame_title ("*invalid*", minendcol
, maxendcol
);
4406 hpos
= display_string (w
, vpos
, "*invalid*", -1, hpos
, 0, 1,
4407 minendcol
, maxendcol
, 0);
4411 if (minendcol
> hpos
)
4412 if (frame_title_ptr
)
4413 hpos
= store_frame_title ("", minendcol
, maxendcol
);
4415 hpos
= display_string (w
, vpos
, "", 0, hpos
,
4416 0, 1, minendcol
, maxendcol
, 0);
4420 /* Write a null-terminated, right justified decimal representation of
4421 the positive integer D to BUF using a minimal field width WIDTH. */
4424 pint2str (buf
, width
, d
)
4429 register char *p
= buf
;
4436 *p
++ = d
% 10 + '0';
4439 for (width
-= (int) (p
- buf
); width
> 0; --width
) *p
++ = ' ';
4449 /* Set a mnemonic character for CODING_SYSTEM (Lisp symbol) in BUF.
4450 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
4451 type of CODING_SYSTEM. Return updated pointer into BUF. */
4454 decode_mode_spec_coding (coding_system
, buf
, eol_flag
)
4455 Lisp_Object coding_system
;
4460 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
4462 val
= coding_system
;
4464 if (NILP (val
)) /* Not yet decided. */
4469 *buf
++ = eol_mnemonic_undecided
;
4470 /* Don't mention EOL conversion if it isn't decided. */
4474 Lisp_Object eolvalue
;
4476 eolvalue
= Fget (coding_system
, Qeol_type
);
4478 while (!NILP (val
) && SYMBOLP (val
))
4480 val
= Fget (val
, Qcoding_system
);
4481 if (NILP (eolvalue
))
4482 eolvalue
= Fget (val
, Qeol_type
);
4486 *buf
++ = XFASTINT (XVECTOR (val
)->contents
[1]);
4490 /* The EOL conversion we are using. */
4492 /* The EOL conversion that is normal on this system. */
4494 if (NILP (eolvalue
)) /* Not yet decided. */
4495 eoltype
= eol_mnemonic_undecided
;
4496 else if (VECTORP (eolvalue
)) /* Not yet decided. */
4497 eoltype
= eol_mnemonic_undecided
;
4498 else /* INTEGERP (eolvalue) -- 0:LF, 1:CRLF, 2:CR */
4499 eoltype
= (XFASTINT (eolvalue
) == 0
4501 : (XFASTINT (eolvalue
) == 1
4502 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
4504 /* Mention the EOL conversion if it is not the usual one. */
4511 /* Return a string for the output of a mode line %-spec for window W,
4512 generated by character C. SPEC_WIDTH is the field width when
4513 padding to the left (%c, %l). The value returned from this
4514 function will later be truncated to width MAXWIDTH. */
4516 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
4519 decode_mode_spec (w
, c
, spec_width
, maxwidth
)
4522 register int spec_width
;
4523 register int maxwidth
;
4526 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
4527 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
4528 struct buffer
*b
= XBUFFER (w
->buffer
);
4531 if (maxwidth
> FRAME_WIDTH (f
))
4532 maxwidth
= FRAME_WIDTH (f
);
4537 if (!NILP (b
->read_only
))
4539 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4544 /* This differs from %* only for a modified read-only buffer. */
4545 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4547 if (!NILP (b
->read_only
))
4552 /* This differs from %* in ignoring read-only-ness. */
4553 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
4565 if (command_loop_level
> 5)
4567 p
= decode_mode_spec_buf
;
4568 for (i
= 0; i
< command_loop_level
; i
++)
4571 return decode_mode_spec_buf
;
4579 if (command_loop_level
> 5)
4581 p
= decode_mode_spec_buf
;
4582 for (i
= 0; i
< command_loop_level
; i
++)
4585 return decode_mode_spec_buf
;
4593 if (maxwidth
< sizeof (lots_of_dashes
))
4594 return lots_of_dashes
;
4597 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
4601 return decode_mode_spec_buf
;
4607 if (maxwidth
>= 3 && XSTRING (obj
)->size_byte
> maxwidth
)
4609 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
4610 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
4611 decode_mode_spec_buf
[maxwidth
] = '\0';
4612 return decode_mode_spec_buf
;
4619 int col
= current_column ();
4620 XSETFASTINT (w
->column_number_displayed
, col
);
4621 pint2str (decode_mode_spec_buf
, spec_width
, col
);
4622 return decode_mode_spec_buf
;
4626 /* %F displays the frame name. */
4627 /* Systems that can only display a single frame at a time should
4628 NOT replace the frame name with the (constant) frame title,
4629 since then they won't be able to tell which frame is that. */
4630 if (FRAME_WINDOW_P (f
) && !NILP (f
->title
))
4631 return (char *) XSTRING (f
->title
)->data
;
4632 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
4633 return (char *) XSTRING (f
->name
)->data
;
4641 else if (STRINGP (obj
) && XSTRING (obj
)->size_byte
> maxwidth
)
4643 bcopy ("...", decode_mode_spec_buf
, 3);
4644 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size_byte
- maxwidth
+ 3,
4645 decode_mode_spec_buf
+ 3, maxwidth
- 3);
4646 return decode_mode_spec_buf
;
4653 int startpos
= XMARKER (w
->start
)->charpos
;
4654 int startpos_byte
= marker_byte_position (w
->start
);
4655 int line
, linepos
, linepos_byte
, topline
;
4658 int height
= XFASTINT (w
->height
);
4660 /* If we decided that this buffer isn't suitable for line numbers,
4661 don't forget that too fast. */
4662 if (EQ (w
->base_line_pos
, w
->buffer
))
4664 /* But do forget it, if the window shows a different buffer now. */
4665 else if (BUFFERP (w
->base_line_pos
))
4666 w
->base_line_pos
= Qnil
;
4668 /* If the buffer is very big, don't waste time. */
4669 if (BUF_ZV (b
) - BUF_BEGV (b
) > line_number_display_limit
)
4671 w
->base_line_pos
= Qnil
;
4672 w
->base_line_number
= Qnil
;
4676 if (!NILP (w
->base_line_number
)
4677 && !NILP (w
->base_line_pos
)
4678 && XFASTINT (w
->base_line_pos
) <= startpos
)
4680 line
= XFASTINT (w
->base_line_number
);
4681 linepos
= XFASTINT (w
->base_line_pos
);
4682 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
4687 linepos
= BUF_BEGV (b
);
4688 linepos_byte
= BUF_BEGV_BYTE (b
);
4691 /* Count lines from base line to window start position. */
4692 nlines
= display_count_lines (linepos
, linepos_byte
,
4696 topline
= nlines
+ line
;
4698 /* Determine a new base line, if the old one is too close
4699 or too far away, or if we did not have one.
4700 "Too close" means it's plausible a scroll-down would
4702 if (startpos
== BUF_BEGV (b
))
4704 XSETFASTINT (w
->base_line_number
, topline
);
4705 XSETFASTINT (w
->base_line_pos
, BUF_BEGV (b
));
4707 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
4708 || linepos
== BUF_BEGV (b
))
4710 int limit
= BUF_BEGV (b
);
4711 int limit_byte
= BUF_BEGV_BYTE (b
);
4713 int distance
= (height
* 2 + 30) * 200;
4715 if (startpos
- distance
> limit
)
4717 limit
= startpos
- distance
;
4718 limit_byte
= CHAR_TO_BYTE (limit
);
4721 nlines
= display_count_lines (startpos
, startpos_byte
,
4723 - (height
* 2 + 30),
4725 /* If we couldn't find the lines we wanted within
4727 give up on line numbers for this window. */
4728 if (position
== limit_byte
&& limit
== startpos
- distance
)
4730 w
->base_line_pos
= w
->buffer
;
4731 w
->base_line_number
= Qnil
;
4735 XSETFASTINT (w
->base_line_number
, topline
- nlines
);
4736 XSETFASTINT (w
->base_line_pos
, BYTE_TO_CHAR (position
));
4739 /* Now count lines from the start pos to point. */
4740 nlines
= display_count_lines (startpos
, startpos_byte
,
4741 PT_BYTE
, PT
, &junk
);
4743 /* Record that we did display the line number. */
4744 line_number_displayed
= 1;
4746 /* Make the string to show. */
4747 pint2str (decode_mode_spec_buf
, spec_width
, topline
+ nlines
);
4748 return decode_mode_spec_buf
;
4751 char* p
= decode_mode_spec_buf
;
4752 for (spec_width
-= 2; spec_width
> 0; --spec_width
) *p
++ = ' ';
4754 return decode_mode_spec_buf
;
4764 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
4770 int pos
= marker_position (w
->start
);
4771 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
4773 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
4775 if (pos
<= BUF_BEGV (b
))
4780 else if (pos
<= BUF_BEGV (b
))
4784 if (total
> 1000000)
4785 /* Do it differently for a large value, to avoid overflow. */
4786 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
4788 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
4789 /* We can't normally display a 3-digit number,
4790 so get us a 2-digit number that is close. */
4793 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
4794 return decode_mode_spec_buf
;
4798 /* Display percentage of size above the bottom of the screen. */
4801 int toppos
= marker_position (w
->start
);
4802 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
4803 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
4805 if (botpos
>= BUF_ZV (b
))
4807 if (toppos
<= BUF_BEGV (b
))
4814 if (total
> 1000000)
4815 /* Do it differently for a large value, to avoid overflow. */
4816 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
4818 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
4819 /* We can't normally display a 3-digit number,
4820 so get us a 2-digit number that is close. */
4823 if (toppos
<= BUF_BEGV (b
))
4824 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
4826 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
4827 return decode_mode_spec_buf
;
4832 /* status of process */
4833 obj
= Fget_buffer_process (w
->buffer
);
4835 return "no process";
4837 obj
= Fsymbol_name (Fprocess_status (obj
));
4841 case 't': /* indicate TEXT or BINARY */
4842 #ifdef MODE_LINE_BINARY_TEXT
4843 return MODE_LINE_BINARY_TEXT (b
);
4849 /* coding-system (not including end-of-line format) */
4851 /* coding-system (including end-of-line type) */
4853 int eol_flag
= (c
== 'Z');
4854 char *p
= decode_mode_spec_buf
;
4856 if (! FRAME_WINDOW_P (f
))
4858 /* No need to mention EOL here--the terminal never needs
4859 to do EOL conversion. */
4860 p
= decode_mode_spec_coding (keyboard_coding
.symbol
, p
, 0);
4861 p
= decode_mode_spec_coding (terminal_coding
.symbol
, p
, 0);
4863 p
= decode_mode_spec_coding (b
->buffer_file_coding_system
,
4866 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
4868 obj
= Fget_buffer_process (Fcurrent_buffer ());
4871 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
4873 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
4876 #endif /* subprocesses */
4879 return decode_mode_spec_buf
;
4884 return (char *) XSTRING (obj
)->data
;
4889 /* Count up to COUNT lines starting from START / START_BYTE.
4890 But don't go beyond LIMIT_BYTE.
4891 Return the number of lines thus found (always nonnegative).
4893 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
4896 display_count_lines (start
, start_byte
, limit_byte
, count
, byte_pos_ptr
)
4897 int start
, start_byte
, limit_byte
, count
;
4900 register unsigned char *cursor
;
4901 unsigned char *base
;
4903 register int ceiling
;
4904 register unsigned char *ceiling_addr
;
4905 int orig_count
= count
;
4907 /* If we are not in selective display mode,
4908 check only for newlines. */
4909 int selective_display
= (!NILP (current_buffer
->selective_display
)
4910 && !INTEGERP (current_buffer
->selective_display
));
4914 while (start_byte
< limit_byte
)
4916 ceiling
= BUFFER_CEILING_OF (start_byte
);
4917 ceiling
= min (limit_byte
- 1, ceiling
);
4918 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
4919 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
4922 if (selective_display
)
4923 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
4926 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
4929 if (cursor
!= ceiling_addr
)
4933 start_byte
+= cursor
- base
+ 1;
4934 *byte_pos_ptr
= start_byte
;
4938 if (++cursor
== ceiling_addr
)
4944 start_byte
+= cursor
- base
;
4949 while (start_byte
> limit_byte
)
4951 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
4952 ceiling
= max (limit_byte
, ceiling
);
4953 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
4954 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
4957 if (selective_display
)
4958 while (--cursor
!= ceiling_addr
4959 && *cursor
!= '\n' && *cursor
!= 015)
4962 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
4965 if (cursor
!= ceiling_addr
)
4969 start_byte
+= cursor
- base
+ 1;
4970 *byte_pos_ptr
= start_byte
;
4971 /* When scanning backwards, we should
4972 not count the newline posterior to which we stop. */
4973 return - orig_count
- 1;
4979 /* Here we add 1 to compensate for the last decrement
4980 of CURSOR, which took it past the valid range. */
4981 start_byte
+= cursor
- base
+ 1;
4985 *byte_pos_ptr
= limit_byte
;
4988 return - orig_count
+ count
;
4989 return orig_count
- count
;
4993 /* Display STRING on one line of window W, starting at HPOS.
4994 Display at position VPOS. Caller should have done get_display_line.
4995 If VPOS == -1, display it as the current frame's title.
4996 LENGTH is the length of STRING, or -1 meaning STRING is null-terminated.
4998 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
5000 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
5001 MAXCOL is the last column ok to end at. Truncate here.
5002 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
5003 Both count from the left edge of the frame, as does HPOS.
5004 The right edge of W is an implicit maximum.
5005 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
5007 OBEY_WINDOW_WIDTH says to put spaces or vertical bars
5008 at the place where the current window ends in this line
5009 and not display anything beyond there. Otherwise, only MAXCOL
5010 controls where to stop output.
5012 MULTIBYTE can be 0 meaning do not display multibyte chars,
5013 1 meaning do display them, or -1 meaning obey the current buffer's
5014 value of enable_multibyte_characters.
5016 Returns ending hpos. */
5019 display_string (w
, vpos
, string
, length
, hpos
, truncate
,
5020 obey_window_width
, mincol
, maxcol
, multibyte
)
5022 unsigned char *string
;
5026 int obey_window_width
;
5033 int hscroll
= XINT (w
->hscroll
);
5034 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
5035 register GLYPH
*start
;
5036 register GLYPH
*end
;
5037 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
5038 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
5039 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
5040 int window_width
= XFASTINT (w
->width
);
5042 /* Use the standard display table, not the window's display table.
5043 We don't want the mode line in rot13. */
5044 register struct Lisp_Char_Table
*dp
= 0;
5047 if (multibyte
== -1)
5048 multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
5049 /* Now multibyte is 1 if we should display multibyte characters. */
5051 if (DISP_TABLE_P (Vstandard_display_table
))
5052 dp
= XCHAR_TABLE (Vstandard_display_table
);
5054 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
5057 start
= desired_glyphs
->glyphs
[vpos
];
5059 if (obey_window_width
)
5061 start
+= XFASTINT (w
->left
);
5062 end
= start
+ window_width
- (truncate
!= 0);
5064 if (!WINDOW_RIGHTMOST_P (w
))
5066 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
5070 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
5073 else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5078 if (! obey_window_width
5079 || (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
))
5080 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
5082 /* Store 0 in charstart for these columns. */
5083 for (i
= (hpos
>= 0 ? hpos
: 0); i
< end
- p1start
+ hpos
; i
++)
5084 desired_glyphs
->charstarts
[vpos
][i
] = 0;
5086 if (maxcol
>= 0 && mincol
> maxcol
)
5090 /* We need this value for multibyte characters. */
5091 length
= strlen (string
);
5093 /* We set truncated to 1 if we get stopped by trying to pass END
5094 (that is, trying to pass MAXCOL.) */
5103 c
= STRING_CHAR_AND_LENGTH (string
, length
, len
);
5105 c
= *string
, len
= 1;
5107 string
+= len
, length
-= len
;
5115 if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
5117 p1
= copy_part_of_rope (f
, p1
, start
,
5118 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
5119 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
5122 else if (c
>= 040 && c
< 0177)
5132 if (p1
>= start
&& p1
< end
)
5136 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
5138 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
5142 (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
5143 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp
)))
5144 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
5147 if (p1
>= start
&& p1
< end
)
5153 /* C is a control character or a binary byte data. */
5156 (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
5157 && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp
)))
5158 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
5161 if (p1
>= start
&& p1
< end
)
5162 *p1
= (c
>> 6) + '0';
5164 if (p1
>= start
&& p1
< end
)
5165 *p1
= (7 & (c
>> 3)) + '0';
5167 if (p1
>= start
&& p1
< end
)
5168 *p1
= (7 & c
) + '0';
5173 /* C is a multibyte character. */
5174 int charset
= CHAR_CHARSET (c
);
5175 int columns
= (charset
== CHARSET_COMPOSITION
5176 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->width
5177 : CHARSET_WIDTH (charset
));
5181 /* Since we can't show the left part of C, fill all
5182 columns with spaces. */
5183 columns
-= start
- p1
;
5192 else if (p1
+ columns
> end
)
5194 /* Since we can't show the right part of C, fill all
5195 columns with TRUNCATE if TRUNCATE is specified. */
5199 *p1
++ = fix_glyph (f
, truncate
, 0);
5200 /* And tell the line is truncated. */
5207 /* We can show the whole glyph of C. */
5210 *p1
++ = c
| GLYPH_MASK_PADDING
;
5218 if (truncate
) *p1
++ = fix_glyph (f
, truncate
, 0);
5220 else if (mincol
>= 0)
5222 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
5228 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
5230 if (len
> desired_glyphs
->used
[vpos
])
5231 desired_glyphs
->used
[vpos
] = len
;
5232 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
5238 /* This is like a combination of memq and assq.
5239 Return 1 if PROPVAL appears as an element of LIST
5240 or as the car of an element of LIST.
5241 If PROPVAL is a list, compare each element against LIST
5242 in that way, and return 1 if any element of PROPVAL is found in LIST.
5244 This function cannot quit. */
5247 invisible_p (propval
, list
)
5248 register Lisp_Object propval
;
5251 register Lisp_Object tail
, proptail
;
5252 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5254 register Lisp_Object tem
;
5255 tem
= XCONS (tail
)->car
;
5256 if (EQ (propval
, tem
))
5258 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
5261 if (CONSP (propval
))
5262 for (proptail
= propval
; CONSP (proptail
);
5263 proptail
= XCONS (proptail
)->cdr
)
5265 Lisp_Object propelt
;
5266 propelt
= XCONS (proptail
)->car
;
5267 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5269 register Lisp_Object tem
;
5270 tem
= XCONS (tail
)->car
;
5271 if (EQ (propelt
, tem
))
5273 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
5280 /* Return 1 if PROPVAL appears as the car of an element of LIST
5281 and the cdr of that element is non-nil.
5282 If PROPVAL is a list, check each element of PROPVAL in that way,
5283 and the first time some element is found,
5284 return 1 if the cdr of that element is non-nil.
5286 This function cannot quit. */
5289 invisible_ellipsis_p (propval
, list
)
5290 register Lisp_Object propval
;
5293 register Lisp_Object tail
, proptail
;
5294 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5296 register Lisp_Object tem
;
5297 tem
= XCONS (tail
)->car
;
5298 if (CONSP (tem
) && EQ (propval
, XCONS (tem
)->car
))
5299 return ! NILP (XCONS (tem
)->cdr
);
5301 if (CONSP (propval
))
5302 for (proptail
= propval
; CONSP (proptail
);
5303 proptail
= XCONS (proptail
)->cdr
)
5305 Lisp_Object propelt
;
5306 propelt
= XCONS (proptail
)->car
;
5307 for (tail
= list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5309 register Lisp_Object tem
;
5310 tem
= XCONS (tail
)->car
;
5311 if (CONSP (tem
) && EQ (propelt
, XCONS (tem
)->car
))
5312 return ! NILP (XCONS (tem
)->cdr
);
5321 staticpro (&Qmenu_bar_update_hook
);
5322 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
5324 staticpro (&Qoverriding_terminal_local_map
);
5325 Qoverriding_terminal_local_map
= intern ("overriding-terminal-local-map");
5327 staticpro (&Qoverriding_local_map
);
5328 Qoverriding_local_map
= intern ("overriding-local-map");
5330 staticpro (&Qwindow_scroll_functions
);
5331 Qwindow_scroll_functions
= intern ("window-scroll-functions");
5333 staticpro (&Qredisplay_end_trigger_functions
);
5334 Qredisplay_end_trigger_functions
= intern ("redisplay-end-trigger-functions");
5336 staticpro (&last_arrow_position
);
5337 staticpro (&last_arrow_string
);
5338 last_arrow_position
= Qnil
;
5339 last_arrow_string
= Qnil
;
5341 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
5342 "String (or mode line construct) included (normally) in `mode-line-format'.");
5343 Vglobal_mode_string
= Qnil
;
5345 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
5346 "Marker for where to display an arrow on top of the buffer text.\n\
5347 This must be the beginning of a line in order to work.\n\
5348 See also `overlay-arrow-string'.");
5349 Voverlay_arrow_position
= Qnil
;
5351 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
5352 "String to display as an arrow. See also `overlay-arrow-position'.");
5353 Voverlay_arrow_string
= Qnil
;
5355 DEFVAR_INT ("scroll-step", &scroll_step
,
5356 "*The number of lines to try scrolling a window by when point moves out.\n\
5357 If that fails to bring point back on frame, point is centered instead.\n\
5358 If this is zero, point is always centered after it moves off frame.");
5360 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively
,
5361 "*Scroll up to this many lines, to bring point back on screen.");
5362 scroll_conservatively
= 0;
5364 DEFVAR_INT ("scroll-margin", &scroll_margin
,
5365 "*Number of lines of margin at the top and bottom of a window.\n\
5366 Recenter the window whenever point gets within this many lines\n\
5367 of the top or bottom of the window.");
5370 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
5372 DEFVAR_BOOL ("truncate-partial-width-windows",
5373 &truncate_partial_width_windows
,
5374 "*Non-nil means truncate lines in all windows less than full frame wide.");
5375 truncate_partial_width_windows
= 1;
5377 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
5378 "*Non-nil means use inverse video for the mode line.");
5379 mode_line_inverse_video
= 1;
5381 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
5382 "*Maximum buffer size (in characters) for line number display\n\
5383 If the buffer is bigger than this, the line number does not appear\n\
5384 in the mode line..");
5385 line_number_display_limit
= 1000000;
5387 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
5388 "*Non-nil means highlight region even in nonselected windows.");
5389 highlight_nonselected_windows
= 0;
5391 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
5392 "Non-nil if more than one frame is visible on this display.\n\
5393 Minibuffer-only frames don't count, but iconified frames do.\n\
5394 This variable is not guaranteed to be accurate except while processing\n\
5395 `frame-title-format' and `icon-title-format'.");
5397 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
5398 "Template for displaying the titlebar of visible frames.\n\
5399 \(Assuming the window manager supports this feature.)\n\
5400 This variable has the same structure as `mode-line-format' (which see),\n\
5401 and is used only on frames for which no explicit name has been set\n\
5402 \(see `modify-frame-parameters').");
5403 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
5404 "Template for displaying the titlebar of an iconified frame.\n\
5405 \(Assuming the window manager supports this feature.)\n\
5406 This variable has the same structure as `mode-line-format' (which see),\n\
5407 and is used only on frames for which no explicit name has been set\n\
5408 \(see `modify-frame-parameters').");
5410 = Vframe_title_format
5411 = Fcons (intern ("multiple-frames"),
5412 Fcons (build_string ("%b"),
5413 Fcons (Fcons (build_string (""),
5414 Fcons (intern ("invocation-name"),
5415 Fcons (build_string ("@"),
5416 Fcons (intern ("system-name"),
5420 DEFVAR_LISP ("message-log-max", &Vmessage_log_max
,
5421 "Maximum number of lines to keep in the message log buffer.\n\
5422 If nil, disable message logging. If t, log messages but don't truncate\n\
5423 the buffer when it becomes large.");
5424 XSETFASTINT (Vmessage_log_max
, 50);
5426 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions
,
5427 "Functions called before redisplay, if window sizes have changed.\n\
5428 The value should be a list of functions that take one argument.\n\
5429 Just before redisplay, for each frame, if any of its windows have changed\n\
5430 size since the last redisplay, or have been split or deleted,\n\
5431 all the functions in the list are called, with the frame as argument.");
5432 Vwindow_size_change_functions
= Qnil
;
5434 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions
,
5435 "List of functions to call before redisplaying a window with scrolling.\n\
5436 Each function is called with two arguments, the window\n\
5437 and its new display-start position. Note that the value of `window-end'\n\
5438 is not valid when these functions are called.");
5439 Vwindow_scroll_functions
= Qnil
;
5441 DEFVAR_INT ("minibuffer-scroll-overlap", &minibuffer_scroll_overlap
,
5442 "*Number of characters of overlap when scrolling a one-line window.\n\
5443 This commonly affects the minibuffer window, hence the name of the variable.");
5444 minibuffer_scroll_overlap
= 20;
5447 /* initialize the window system */
5450 Lisp_Object root_window
;
5451 #ifndef COMPILER_REGISTER_BUG
5453 #endif /* COMPILER_REGISTER_BUG */
5454 struct window
*mini_w
;
5456 this_line_bufpos
= 0;
5458 mini_w
= XWINDOW (minibuf_window
);
5459 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
5461 echo_area_glyphs
= 0;
5462 previous_echo_glyphs
= 0;
5464 if (!noninteractive
)
5466 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
5467 XSETFASTINT (XWINDOW (root_window
)->top
, FRAME_MENU_BAR_LINES (f
));
5468 set_window_height (root_window
,
5469 FRAME_HEIGHT (f
) - 1 - FRAME_MENU_BAR_LINES (f
),
5471 XSETFASTINT (mini_w
->top
, FRAME_HEIGHT (f
) - 1);
5472 set_window_height (minibuf_window
, 1, 0);
5474 XSETFASTINT (XWINDOW (root_window
)->width
, FRAME_WIDTH (f
));
5475 XSETFASTINT (mini_w
->width
, FRAME_WIDTH (f
));