1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 86, 87, 88, 93, 94 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /*#include <ctype.h>*/
29 #include "dispextern.h"
35 #include "termhooks.h"
36 #include "intervals.h"
39 extern void set_frame_menubar ();
42 extern int interrupt_input
;
43 extern int command_loop_level
;
45 /* Nonzero means print newline before next minibuffer message. */
47 int noninteractive_need_newline
;
49 #define min(a, b) ((a) < (b) ? (a) : (b))
50 #define max(a, b) ((a) > (b) ? (a) : (b))
52 /* The buffer position of the first character appearing
53 entirely or partially on the current frame line.
54 Or zero, which disables the optimization for the current frame line. */
55 static int this_line_bufpos
;
57 /* Number of characters past the end of this line,
58 including the terminating newline */
59 static int this_line_endpos
;
61 /* The vertical position of this frame line. */
62 static int this_line_vpos
;
64 /* Hpos value for start of display on this frame line.
65 Usually zero, but negative if first character really began
67 static int this_line_start_hpos
;
69 /* Buffer that this_line variables are describing. */
70 static struct buffer
*this_line_buffer
;
72 /* Set by try_window_id to the vpos of first of any lines
73 scrolled on to the bottom of the frame. These lines should
74 not be included in any general scroll computation. */
75 static int scroll_bottom_vpos
;
77 /* Value of echo_area_glyphs when it was last acted on.
78 If this is nonzero, there is a message on the frame
79 in the minibuffer and it should be erased as soon
80 as it is no longer requested to appear. */
81 char *previous_echo_glyphs
;
83 /* Nonzero means truncate lines in all windows less wide than the frame */
84 int truncate_partial_width_windows
;
86 Lisp_Object Vglobal_mode_string
;
88 /* Marker for where to display an arrow on top of the buffer text. */
89 Lisp_Object Voverlay_arrow_position
;
91 /* String to display for the arrow. */
92 Lisp_Object Voverlay_arrow_string
;
94 /* Values of those variables at last redisplay. */
95 static Lisp_Object last_arrow_position
, last_arrow_string
;
97 /* Nonzero if overlay arrow has been displayed once in this window. */
98 static int overlay_arrow_seen
;
100 /* Nonzero means highlight the region even in nonselected windows. */
101 static int highlight_nonselected_windows
;
103 /* If cursor motion alone moves point off frame,
104 Try scrolling this many lines up or down if that will bring it back. */
107 /* Nonzero if try_window_id has made blank lines at window bottom
108 since the last redisplay that paused */
109 static int blank_end_of_window
;
111 /* Number of windows showing the buffer of the selected window.
112 keyboard.c refers to this. */
115 /* display_text_line sets these to the frame position (origin 0) of point,
116 whether the window is selected or not.
117 Set one to -1 first to determine whether point was found afterwards. */
119 static int cursor_vpos
;
120 static int cursor_hpos
;
124 /* Nonzero means display mode line highlighted */
125 int mode_line_inverse_video
;
127 static void echo_area_display ();
128 void mark_window_display_accurate ();
129 static void redisplay_windows ();
130 static void redisplay_window ();
131 static void update_menu_bars ();
132 static void update_menu_bar ();
133 static void try_window ();
134 static int try_window_id ();
135 static struct position
*display_text_line ();
136 static void display_mode_line ();
137 static int display_mode_element ();
138 static char *fmodetrunc ();
139 static char *decode_mode_spec ();
140 static int display_string ();
141 static void display_menu_bar ();
142 static int display_count_lines ();
144 /* Prompt to display in front of the minibuffer contents */
145 char *minibuf_prompt
;
147 /* Width in columns of current minibuffer prompt. */
148 int minibuf_prompt_width
;
150 /* Message to display instead of minibuffer contents
151 This is what the functions error and message make,
152 and command echoing uses it as well.
153 It overrides the minibuf_prompt as well as the buffer. */
154 char *echo_area_glyphs
;
156 /* This is the length of the message in echo_area_glyphs. */
157 int echo_area_glyphs_length
;
159 /* true iff we should redraw the mode lines on the next redisplay */
160 int update_mode_lines
;
162 /* Smallest number of characters before the gap
163 at any time since last redisplay that finished.
164 Valid for current buffer when try_window_id can be called. */
167 /* Smallest number of characters after the gap
168 at any time since last redisplay that finished.
169 Valid for current buffer when try_window_id can be called. */
172 /* MODIFF as of last redisplay that finished;
173 if it matches MODIFF, beg_unchanged and end_unchanged
174 contain no useful information */
175 int unchanged_modified
;
177 /* Nonzero if head_clip or tail_clip of current buffer has changed
178 since last redisplay that finished */
181 /* Nonzero if window sizes or contents have changed
182 since last redisplay that finished */
183 int windows_or_buffers_changed
;
185 /* Nonzero after display_mode_line if %l was used
186 and it displayed a line number. */
187 int line_number_displayed
;
189 /* Maximum buffer size for which to display line numbers. */
190 int line_number_display_limit
;
192 /* Specify m, a string, as a message in the minibuf. If m is 0, clear out
193 any existing message, and let the minibuffer text show through. */
201 if (noninteractive_need_newline
)
203 noninteractive_need_newline
= 0;
204 if (cursor_in_echo_area
!= 0)
205 fprintf (stderr
, "%s", m
);
207 fprintf (stderr
, "%s\n", m
);
210 /* A null message buffer means that the frame hasn't really been
211 initialized yet. Error messages get reported properly by
212 cmd_error, so this must be just an informative message; toss it. */
213 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
216 Lisp_Object minibuf_frame
;
218 choose_minibuf_frame ();
219 minibuf_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
220 FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame
));
221 if (FRAME_VISIBLE_P (selected_frame
)
222 && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame
)))
223 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window
)));
228 echo_area_glyphs
= m
;
229 echo_area_glyphs_length
= strlen (m
);
232 echo_area_glyphs
= previous_echo_glyphs
= 0;
234 do_pending_window_change ();
235 echo_area_display ();
236 update_frame (XFRAME (XWINDOW (minibuf_window
)->frame
), 1, 1);
237 do_pending_window_change ();
241 /* Display an echo area message M with a specified length of LEN chars.
242 This way, null characters can be included. Do not pass text that is
243 stored in a Lisp string. */
252 if (noninteractive_need_newline
)
254 noninteractive_need_newline
= 0;
255 fwrite (m
, len
, 1, stderr
);
256 if (cursor_in_echo_area
== 0)
257 fprintf (stderr
, "\n");
260 /* A null message buffer means that the frame hasn't really been
261 initialized yet. Error messages get reported properly by
262 cmd_error, so this must be just an informative message; toss it. */
263 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
266 Lisp_Object minibuf_frame
;
268 choose_minibuf_frame ();
269 minibuf_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
270 FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame
));
271 if (FRAME_VISIBLE_P (selected_frame
)
272 && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame
)))
273 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window
)));
278 echo_area_glyphs
= m
;
279 echo_area_glyphs_length
= len
;
282 echo_area_glyphs
= previous_echo_glyphs
= 0;
284 do_pending_window_change ();
285 echo_area_display ();
286 update_frame (XFRAME (XWINDOW (minibuf_window
)->frame
), 1, 1);
287 do_pending_window_change ();
291 /* Truncate what will be displayed in the echo area
292 the next time we display it--but don't redisplay it now. */
295 truncate_echo_area (len
)
298 /* A null message buffer means that the frame hasn't really been
299 initialized yet. Error messages get reported properly by
300 cmd_error, so this must be just an informative message; toss it. */
301 if (!noninteractive
&& INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
302 echo_area_glyphs_length
= len
;
305 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
306 zero if being used by message. */
307 int message_buf_print
;
309 /* Dump an informative message to the minibuf. If m is 0, clear out
310 any existing message, and let the minibuffer text show through. */
313 message (m
, a1
, a2
, a3
)
320 if (noninteractive_need_newline
)
322 noninteractive_need_newline
= 0;
323 fprintf (stderr
, m
, a1
, a2
, a3
);
324 if (cursor_in_echo_area
== 0)
325 fprintf (stderr
, "\n");
329 else if (INTERACTIVE
)
331 /* The frame whose minibuffer we're going to display the message on.
332 It may be larger than the selected frame, so we need
333 to use its buffer, not the selected frame's buffer. */
334 FRAME_PTR echo_frame
;
336 choose_minibuf_frame ();
337 echo_frame
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
339 echo_frame
= selected_frame
;
342 /* A null message buffer means that the frame hasn't really been
343 initialized yet. Error messages get reported properly by
344 cmd_error, so this must be just an informative message; toss it. */
345 if (FRAME_MESSAGE_BUF (echo_frame
))
356 len
= doprnt (FRAME_MESSAGE_BUF (echo_frame
),
357 FRAME_WIDTH (echo_frame
), m
, 0, 3, a
);
359 len
= doprnt (FRAME_MESSAGE_BUF (echo_frame
),
360 FRAME_WIDTH (echo_frame
), m
, 0, 3, &a1
);
361 #endif /* NO_ARG_ARRAY */
363 message2 (FRAME_MESSAGE_BUF (echo_frame
), len
);
368 /* Print should start at the beginning of the message
370 message_buf_print
= 0;
382 choose_minibuf_frame ();
385 f
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
387 if (! FRAME_VISIBLE_P (f
))
392 redraw_garbaged_frames ();
396 if (echo_area_glyphs
|| minibuf_level
== 0)
398 vpos
= XFASTINT (XWINDOW (minibuf_window
)->top
);
399 get_display_line (f
, vpos
, 0);
400 display_string (XWINDOW (minibuf_window
), vpos
,
401 echo_area_glyphs
? echo_area_glyphs
: "",
402 echo_area_glyphs
? echo_area_glyphs_length
: -1,
403 0, 0, 0, 0, FRAME_WIDTH (f
));
405 /* If desired cursor location is on this line, put it at end of text */
406 if (FRAME_CURSOR_Y (f
) == vpos
)
407 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
409 /* Fill the rest of the minibuffer window with blank lines. */
414 i
< vpos
+ XFASTINT (XWINDOW (minibuf_window
)->height
); i
++)
416 get_display_line (f
, i
, 0);
417 display_string (XWINDOW (minibuf_window
), vpos
,
418 "", 0, 0, 0, 0, 0, FRAME_WIDTH (f
));
422 else if (!EQ (minibuf_window
, selected_window
))
423 windows_or_buffers_changed
++;
425 if (EQ (minibuf_window
, selected_window
))
426 this_line_bufpos
= 0;
428 previous_echo_glyphs
= echo_area_glyphs
;
431 /* Prepare for redisplay by updating menu-bar item lists when appropriate.
432 This can't be done in `redisplay' itself because it can call eval. */
437 register struct window
*w
= XWINDOW (selected_window
);
443 /* Set the visible flags for all frames.
444 Do this before checking for resized or garbaged frames; they want
445 to know if their frames are visible.
446 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
448 Lisp_Object tail
, frame
;
450 FOR_EACH_FRAME (tail
, frame
)
451 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
454 /* Notice any pending interrupt request to change frame size. */
455 do_pending_window_change ();
459 redraw_garbaged_frames ();
463 if (clip_changed
|| windows_or_buffers_changed
)
466 /* Detect case that we need to write a star in the mode line. */
467 if (XFASTINT (w
->last_modified
) < MODIFF
468 && XFASTINT (w
->last_modified
) <= current_buffer
->save_modified
)
470 w
->update_mode_line
= Qt
;
471 if (buffer_shared
> 1)
475 all_windows
= update_mode_lines
|| buffer_shared
> 1;
477 /* If specs for an arrow have changed, do thorough redisplay
478 to ensure we remove any arrow that should no longer exist. */
479 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
480 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
481 all_windows
= 1, clip_changed
= 1;
483 /* Update the menu bar item lists, if appropriate.
484 This has to be done before any actual redisplay
485 or generation of display lines. */
488 Lisp_Object tail
, frame
;
490 FOR_EACH_FRAME (tail
, frame
)
492 FRAME_PTR f
= XFRAME (frame
);
494 if (FRAME_VISIBLE_P (f
))
495 update_menu_bars (FRAME_ROOT_WINDOW (f
));
498 else if (FRAME_VISIBLE_P (selected_frame
))
499 update_menu_bar (selected_window
);
502 /* Do a frame update, taking possible shortcuts into account.
503 This is the main external entry point for redisplay.
505 If the last redisplay displayed an echo area message and that
506 message is no longer requested, we clear the echo area
507 or bring back the minibuffer if that is in use.
509 Do not call eval from within this function.
510 Calls to eval after the call to echo_area_display would confuse
511 the display_line mechanism and would cause a crash.
512 Calls to eval before that point will work most of the time,
513 but can still lose, because this function
514 can be called from signal handlers; with alarms set up;
515 or with synchronous processes running.
517 See Fcall_process; if you called it from here, it could be
518 entered recursively. */
523 register struct window
*w
= XWINDOW (selected_window
);
527 register int tlbufpos
, tlendpos
;
529 extern int input_pending
;
534 /* Set the visible flags for all frames.
535 Do this before checking for resized or garbaged frames; they want
536 to know if their frames are visible.
537 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
539 Lisp_Object tail
, frame
;
541 FOR_EACH_FRAME (tail
, frame
)
542 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
545 /* Notice any pending interrupt request to change frame size. */
546 do_pending_window_change ();
550 redraw_garbaged_frames ();
554 if (clip_changed
|| windows_or_buffers_changed
)
557 /* Detect case that we need to write a star in the mode line. */
558 if (XFASTINT (w
->last_modified
) < MODIFF
559 && XFASTINT (w
->last_modified
) <= current_buffer
->save_modified
)
561 w
->update_mode_line
= Qt
;
562 if (buffer_shared
> 1)
566 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
568 all_windows
= update_mode_lines
|| buffer_shared
> 1;
570 /* If specs for an arrow have changed, do thorough redisplay
571 to ensure we remove any arrow that should no longer exist. */
572 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
573 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
574 all_windows
= 1, clip_changed
= 1;
576 /* Normally the message* functions will have already displayed and
577 updated the echo area, but the frame may have been trashed, or
578 the update may have been preempted, so display the echo area
580 if (echo_area_glyphs
|| previous_echo_glyphs
)
582 echo_area_display ();
586 /* If showing region, and mark has changed, must redisplay whole window. */
587 if (((!NILP (Vtransient_mark_mode
)
588 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
589 != !NILP (w
->region_showing
))
590 || (!NILP (w
->region_showing
)
591 && !EQ (w
->region_showing
,
592 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
593 this_line_bufpos
= -1;
595 tlbufpos
= this_line_bufpos
;
596 tlendpos
= this_line_endpos
;
597 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
598 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
599 /* Make sure recorded data applies to current buffer, etc */
600 && this_line_buffer
== current_buffer
601 && current_buffer
== XBUFFER (w
->buffer
)
602 && NILP (w
->force_start
)
603 /* Point must be on the line that we have info recorded about */
605 && point
<= Z
- tlendpos
606 /* All text outside that line, including its final newline,
608 && (XFASTINT (w
->last_modified
) >= MODIFF
609 || (beg_unchanged
>= tlbufpos
- 1
611 /* If selective display, can't optimize
612 if the changes start at the beginning of the line. */
613 && ((XTYPE (current_buffer
->selective_display
) == Lisp_Int
614 && XINT (current_buffer
->selective_display
) > 0
615 ? (beg_unchanged
>= tlbufpos
618 && end_unchanged
>= tlendpos
619 && Z
- GPT
>= tlendpos
)))
621 if (tlbufpos
> BEGV
&& FETCH_CHAR (tlbufpos
- 1) != '\n'
623 || FETCH_CHAR (tlbufpos
) == '\n'))
624 /* Former continuation line has disappeared by becoming empty */
626 else if (XFASTINT (w
->last_modified
) < MODIFF
627 || MINI_WINDOW_P (w
))
630 overlay_arrow_seen
= 0;
631 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
632 pos_tab_offset (w
, tlbufpos
));
633 /* If line contains point, is not continued,
634 and ends at same distance from eob as before, we win */
635 if (cursor_vpos
>= 0 && this_line_bufpos
636 && this_line_endpos
== tlendpos
)
638 if (XFASTINT (w
->width
) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w
))))
639 preserve_other_columns (w
);
645 else if (point
== XFASTINT (w
->last_point
))
649 do_pending_window_change ();
654 /* If highlighting the region, we can't just move the cursor. */
655 else if (! (!NILP (Vtransient_mark_mode
)
656 && !NILP (current_buffer
->mark_active
))
657 && NILP (w
->region_showing
))
659 pos
= *compute_motion (tlbufpos
, 0,
660 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
661 point
, 2, - (1 << (SHORTBITS
- 1)),
662 window_internal_width (w
) - 1,
664 pos_tab_offset (w
, tlbufpos
));
667 FRAME_CURSOR_X (selected_frame
)
668 = XFASTINT (w
->left
) + max (pos
.hpos
, 0);
669 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
676 /* Text changed drastically or point moved off of line */
677 cancel_line (this_line_vpos
, selected_frame
);
680 this_line_bufpos
= 0;
681 all_windows
|= buffer_shared
> 1;
685 Lisp_Object tail
, frame
;
687 #ifdef HAVE_X_WINDOWS
688 /* Since we're doing a thorough redisplay, we might as well
689 recompute all our display faces. */
690 clear_face_vector ();
693 /* Recompute # windows showing selected buffer.
694 This will be incremented each time such a window is displayed. */
697 FOR_EACH_FRAME (tail
, frame
)
699 FRAME_PTR f
= XFRAME (frame
);
701 /* Mark all the scroll bars to be removed; we'll redeem the ones
702 we want when we redisplay their windows. */
703 if (condemn_scroll_bars_hook
)
704 (*condemn_scroll_bars_hook
) (f
);
706 if (FRAME_VISIBLE_P (f
))
707 redisplay_windows (FRAME_ROOT_WINDOW (f
));
709 /* Any scroll bars which redisplay_windows should have nuked
710 should now go away. */
711 if (judge_scroll_bars_hook
)
712 (*judge_scroll_bars_hook
) (f
);
715 else if (FRAME_VISIBLE_P (selected_frame
))
717 redisplay_window (selected_window
, 1);
718 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
719 preserve_other_columns (w
);
723 /* Prevent various kinds of signals during display update.
724 stdio is not robust about handling signals,
725 which can cause an apparent I/O error. */
737 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
741 if (XTYPE (XCONS (tail
)->car
) != Lisp_Frame
)
744 f
= XFRAME (XCONS (tail
)->car
);
745 if (FRAME_VISIBLE_P (f
))
747 pause
|= update_frame (f
, 0, 0);
749 mark_window_display_accurate (f
->root_window
, 1);
754 #endif /* MULTI_FRAME */
756 if (FRAME_VISIBLE_P (selected_frame
))
757 pause
= update_frame (selected_frame
, 0, 0);
759 /* We may have called echo_area_display at the top of this
760 function. If the echo area is on another frame, that may
761 have put text on a frame other than the selected one, so the
762 above call to update_frame would not have caught it. Catch
765 FRAME_PTR mini_frame
=
766 XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
768 if (mini_frame
!= selected_frame
)
769 pause
|= update_frame (mini_frame
, 0, 0);
773 /* If frame does not match, prevent doing single-line-update next time.
774 Also, don't forget to check every line to update the arrow. */
777 this_line_bufpos
= 0;
778 if (!NILP (last_arrow_position
))
780 last_arrow_position
= Qt
;
781 last_arrow_string
= Qt
;
783 /* If we pause after scrolling, some lines in current_frame
784 may be null, so preserve_other_columns won't be able to
785 preserve all the vertical-bar separators. So, avoid using it
787 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
788 update_mode_lines
= 1;
791 /* Now text on frame agrees with windows, so
792 put info into the windows for partial redisplay to follow */
796 register struct buffer
*b
= XBUFFER (w
->buffer
);
798 blank_end_of_window
= 0;
800 unchanged_modified
= BUF_MODIFF (b
);
801 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
802 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
804 XFASTINT (w
->last_point
) = BUF_PT (b
);
805 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (selected_frame
);
806 XFASTINT (w
->last_point_y
) = FRAME_CURSOR_Y (selected_frame
);
809 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
812 w
->update_mode_line
= Qnil
;
813 XFASTINT (w
->last_modified
) = BUF_MODIFF (b
);
814 w
->window_end_valid
= Qt
;
815 last_arrow_position
= Voverlay_arrow_position
;
816 last_arrow_string
= Voverlay_arrow_string
;
818 update_mode_lines
= 0;
819 windows_or_buffers_changed
= 0;
822 /* Start SIGIO interrupts coming again.
823 Having them off during the code above
824 makes it less likely one will discard output,
825 but not impossible, since there might be stuff
826 in the system buffer here.
827 But it is much hairier to try to do anything about that. */
833 /* Change frame size now if a change is pending. */
834 do_pending_window_change ();
837 /* Redisplay, but leave alone any recent echo area message
838 unless another message has been requested in its place.
840 This is useful in situations where you need to redisplay but no
841 user action has occurred, making it inappropriate for the message
842 area to be cleared. See tracking_off and
843 wait_reading_process_input for examples of these situations. */
845 redisplay_preserve_echo_area ()
847 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
849 echo_area_glyphs
= previous_echo_glyphs
;
851 echo_area_glyphs
= 0;
858 mark_window_display_accurate (window
, flag
)
862 register struct window
*w
;
864 for (;!NILP (window
); window
= w
->next
)
866 if (XTYPE (window
) != Lisp_Window
) abort ();
867 w
= XWINDOW (window
);
869 if (!NILP (w
->buffer
))
871 XFASTINT (w
->last_modified
)
873 : XBUFFER (w
->buffer
) == current_buffer
874 ? MODIFF
: BUF_MODIFF (XBUFFER (w
->buffer
));
876 /* Record if we are showing a region, so can make sure to
877 update it fully at next redisplay. */
878 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
879 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
880 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
884 w
->window_end_valid
= Qt
;
885 w
->update_mode_line
= Qnil
;
887 if (!NILP (w
->vchild
))
888 mark_window_display_accurate (w
->vchild
, flag
);
889 if (!NILP (w
->hchild
))
890 mark_window_display_accurate (w
->hchild
, flag
);
895 last_arrow_position
= Voverlay_arrow_position
;
896 last_arrow_string
= Voverlay_arrow_string
;
900 /* t is unequal to any useful value of Voverlay_arrow_... */
901 last_arrow_position
= Qt
;
902 last_arrow_string
= Qt
;
906 /* Update the menu bar item lists for WINDOW
907 and its subwindows and siblings.
908 This has to be done before we start to fill in any display lines,
909 because it can call eval. */
912 update_menu_bars (window
)
915 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
916 update_menu_bar (window
, 0);
919 /* Update the menu bar item list for window WINDOW and its subwindows. */
922 update_menu_bar (window
, just_this_one
)
926 register struct window
*w
= XWINDOW (window
);
927 struct buffer
*old
= current_buffer
;
928 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
930 /* If this is a combination window, do its children; that's all. */
932 if (!NILP (w
->vchild
))
934 update_menu_bars (w
->vchild
);
937 if (!NILP (w
->hchild
))
939 update_menu_bars (w
->hchild
);
942 if (NILP (w
->buffer
))
945 if (update_mode_lines
)
946 w
->update_mode_line
= Qt
;
948 /* When we reach a frame's selected window, redo the frame's menu bar. */
949 if (!NILP (w
->update_mode_line
)
951 && FRAME_EXTERNAL_MENU_BAR (f
)
953 && FRAME_MENU_BAR_LINES (f
) > 0
955 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
957 /* If the user has switched buffers or windows, we need to
958 recompute to reflect the new bindings. But we'll
959 recompute when update_mode_lines is set too; that means
960 that people can use force-mode-line-update to request
961 that the menu bar be recomputed. The adverse effect on
962 the rest of the redisplay algorithm is about the same as
963 windows_or_buffers_changed anyway. */
964 if (windows_or_buffers_changed
966 || (XFASTINT (w
->last_modified
) < MODIFF
967 && (XFASTINT (w
->last_modified
)
968 <= XBUFFER (w
->buffer
)->save_modified
)))
970 struct buffer
*prev
= current_buffer
;
971 current_buffer
= XBUFFER (w
->buffer
);
972 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items ();
973 current_buffer
= prev
;
975 set_frame_menubar (f
);
976 #endif /* USE_X_TOOLKIT */
983 /* Redisplay WINDOW and its subwindows and siblings. */
986 redisplay_windows (window
)
989 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
990 redisplay_window (window
, 0);
993 /* Redisplay window WINDOW and its subwindows. */
996 redisplay_window (window
, just_this_one
)
1000 register struct window
*w
= XWINDOW (window
);
1001 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1003 register int lpoint
= point
;
1004 struct buffer
*old
= current_buffer
;
1005 register int width
= window_internal_width (w
) - 1;
1006 register int startp
;
1007 register int hscroll
= XINT (w
->hscroll
);
1008 struct position pos
;
1011 int window_needs_modeline
;
1013 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1015 /* If this is a combination window, do its children; that's all. */
1017 if (!NILP (w
->vchild
))
1019 redisplay_windows (w
->vchild
);
1022 if (!NILP (w
->hchild
))
1024 redisplay_windows (w
->hchild
);
1027 if (NILP (w
->buffer
))
1030 height
= window_internal_height (w
);
1032 if (MINI_WINDOW_P (w
))
1034 if (w
== XWINDOW (minibuf_window
))
1036 if (echo_area_glyphs
)
1037 /* We've already displayed the echo area glyphs, if any. */
1038 goto finish_scroll_bars
;
1042 /* This is a minibuffer, but it's not the currently active one, so
1044 int vpos
= XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1047 for (i
= 0; i
< height
; i
++)
1049 get_display_line (f
, vpos
+ i
, 0);
1050 display_string (w
, vpos
+ i
, "", 0, 0, 0, 1, 0, width
);
1053 goto finish_scroll_bars
;
1057 if (update_mode_lines
)
1058 w
->update_mode_line
= Qt
;
1060 /* Otherwise set up data on this window; select its buffer and point value */
1062 current_buffer
= XBUFFER (w
->buffer
);
1065 /* Count number of windows showing the selected buffer. */
1068 && current_buffer
== XBUFFER (XWINDOW (selected_window
)->buffer
))
1071 /* POINT refers normally to the selected window.
1072 For any other window, set up appropriate value. */
1074 if (!EQ (window
, selected_window
))
1076 SET_PT (marker_position (w
->pointm
));
1080 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
1082 else if (point
> (ZV
- 1))
1085 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
1089 /* If window-start is screwed up, choose a new one. */
1090 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
1093 startp
= marker_position (w
->start
);
1095 /* Handle case where place to start displaying has been specified,
1096 unless the specified location is outside the accessible range. */
1097 if (!NILP (w
->force_start
))
1099 /* Forget any recorded base line for line number display. */
1100 w
->base_line_number
= Qnil
;
1101 w
->update_mode_line
= Qt
;
1102 w
->force_start
= Qnil
;
1103 XFASTINT (w
->last_modified
) = 0;
1104 if (startp
< BEGV
) startp
= BEGV
;
1105 if (startp
> ZV
) startp
= ZV
;
1106 try_window (window
, startp
);
1107 if (cursor_vpos
< 0)
1109 /* ??? What should happen here if highlighting a region? */
1110 /* If point does not appear, move point so it does appear */
1111 pos
= *compute_motion (startp
, 0,
1112 ((EQ (window
, minibuf_window
) && startp
== 1)
1113 ? minibuf_prompt_width
: 0)
1115 (hscroll
? 1 - hscroll
: 0),
1117 - (1 << (SHORTBITS
- 1)),
1118 width
, hscroll
, pos_tab_offset (w
, startp
));
1119 SET_PT (pos
.bufpos
);
1120 if (w
!= XWINDOW (selected_window
))
1121 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
1124 if (current_buffer
== old
)
1126 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
1127 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1133 /* Handle case where text has not changed, only point,
1134 and it has not moved off the frame */
1136 /* This code is not used for minibuffer for the sake of
1137 the case of redisplaying to replace an echo area message;
1138 since in that case the minibuffer contents per se are usually unchanged.
1139 This code is of no real use in the minibuffer since
1140 the handling of this_line_bufpos, etc.,
1141 in redisplay handles the same cases. */
1143 if (XFASTINT (w
->last_modified
) >= MODIFF
1144 && point
>= startp
&& !clip_changed
1145 && (just_this_one
|| XFASTINT (w
->width
) == FRAME_WIDTH (f
))
1146 /* Can't use this case if highlighting a region. */
1147 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1148 && NILP (w
->region_showing
)
1149 && !EQ (window
, minibuf_window
))
1151 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0),
1152 point
, height
+ 1, 10000, width
, hscroll
,
1153 pos_tab_offset (w
, startp
));
1155 if (pos
.vpos
< height
)
1157 /* Ok, point is still on frame */
1158 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
1160 /* These variables are supposed to be origin 1 */
1161 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
1162 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1164 /* This doesn't do the trick, because if a window to the right of
1165 this one must be redisplayed, this does nothing because there
1166 is nothing in DesiredFrame yet, and then the other window is
1167 redisplayed, making likes that are empty in this window's columns.
1168 if (XFASTINT (w->width) != FRAME_WIDTH (f))
1169 preserve_my_columns (w);
1173 /* Don't bother trying redisplay with same start;
1174 we already know it will lose */
1176 /* If current starting point was originally the beginning of a line
1177 but no longer is, find a new starting point. */
1178 else if (!NILP (w
->start_at_line_beg
)
1180 || FETCH_CHAR (startp
- 1) == '\n'))
1184 else if (just_this_one
&& !MINI_WINDOW_P (w
)
1186 && XFASTINT (w
->last_modified
)
1187 /* or else vmotion on first line won't work. */
1188 && ! NILP (w
->start_at_line_beg
)
1189 && ! EQ (w
->window_end_valid
, Qnil
)
1190 && do_id
&& !clip_changed
1191 && !blank_end_of_window
1192 && XFASTINT (w
->width
) == FRAME_WIDTH (f
)
1193 /* Can't use this case if highlighting a region. */
1194 && !(!NILP (Vtransient_mark_mode
)
1195 && !NILP (current_buffer
->mark_active
))
1196 && NILP (w
->region_showing
)
1197 && EQ (last_arrow_position
, Voverlay_arrow_position
)
1198 && EQ (last_arrow_string
, Voverlay_arrow_string
)
1199 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
1202 /* tem > 0 means success. tem == -1 means choose new start.
1203 tem == -2 means try again with same start,
1204 and nothing but whitespace follows the changed stuff.
1205 tem == 0 means try again with same start. */
1209 else if (startp
>= BEGV
&& startp
<= ZV
1210 /* Avoid starting display at end of buffer! */
1211 && (startp
< ZV
|| startp
== BEGV
1212 || (XFASTINT (w
->last_modified
) >= MODIFF
)))
1214 /* Try to redisplay starting at same place as before */
1215 /* If point has not moved off frame, accept the results */
1216 try_window (window
, startp
);
1217 if (cursor_vpos
>= 0)
1219 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1220 /* Forget any recorded base line for line number display. */
1221 w
->base_line_number
= Qnil
;
1225 cancel_my_columns (w
);
1228 XFASTINT (w
->last_modified
) = 0;
1229 w
->update_mode_line
= Qt
;
1231 /* Try to scroll by specified few lines */
1233 if (scroll_step
&& !clip_changed
)
1237 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1238 scroll_step
, width
, hscroll
, window
);
1239 if (pos
.vpos
>= height
)
1243 pos
= *vmotion (startp
, point
< startp
? - scroll_step
: scroll_step
,
1244 width
, hscroll
, window
);
1246 if (point
>= pos
.bufpos
)
1248 try_window (window
, pos
.bufpos
);
1249 if (cursor_vpos
>= 0)
1251 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1252 /* Forget any recorded base line for line number display. */
1253 w
->base_line_number
= Qnil
;
1257 cancel_my_columns (w
);
1262 /* Finally, just choose place to start which centers point */
1265 /* Forget any previously recorded base line for line number display. */
1266 w
->base_line_number
= Qnil
;
1268 pos
= *vmotion (point
, - height
/ 2, width
, hscroll
, window
);
1269 try_window (window
, pos
.bufpos
);
1271 startp
= marker_position (w
->start
);
1272 w
->start_at_line_beg
=
1273 (startp
== BEGV
|| FETCH_CHAR (startp
- 1) == '\n') ? Qt
: Qnil
;
1276 if ((!NILP (w
->update_mode_line
)
1277 /* If window not full width, must redo its mode line
1278 if the window to its side is being redone */
1279 || (!just_this_one
&& width
< FRAME_WIDTH (f
) - 1)
1280 || INTEGERP (w
->base_line_pos
))
1281 && height
!= XFASTINT (w
->height
))
1282 display_mode_line (w
);
1283 if (! line_number_displayed
1284 && ! BUFFERP (w
->base_line_pos
))
1286 w
->base_line_pos
= Qnil
;
1287 w
->base_line_number
= Qnil
;
1290 /* When we reach a frame's selected window, redo the frame's menu bar. */
1291 if (!NILP (w
->update_mode_line
)
1292 #ifdef USE_X_TOOLKIT
1293 && FRAME_EXTERNAL_MENU_BAR (f
)
1295 && FRAME_MENU_BAR_LINES (f
) > 0
1297 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
1298 display_menu_bar (w
);
1301 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1303 int start
, end
, whole
;
1305 /* Calculate the start and end positions for the current window.
1306 At some point, it would be nice to choose between scrollbars
1307 which reflect the whole buffer size, with special markers
1308 indicating narrowing, and scrollbars which reflect only the
1311 Note that minibuffers sometimes aren't displaying any text. */
1312 if (! MINI_WINDOW_P (w
)
1313 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
1316 start
= startp
- BEGV
;
1317 /* I don't think this is guaranteed to be right. For the
1318 moment, we'll pretend it is. */
1319 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
1321 if (end
< start
) end
= start
;
1322 if (whole
< (end
- start
)) whole
= end
- start
;
1325 start
= end
= whole
= 0;
1327 /* Indicate what this scroll bar ought to be displaying now. */
1328 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
1330 /* Note that we actually used the scroll bar attached to this window,
1331 so it shouldn't be deleted at the end of redisplay. */
1332 (*redeem_scroll_bar_hook
) (w
);
1336 current_buffer
= old
;
1340 /* Do full redisplay on one window, starting at position `pos'. */
1343 try_window (window
, pos
)
1347 register struct window
*w
= XWINDOW (window
);
1348 register int height
= window_internal_height (w
);
1349 register int vpos
= XFASTINT (w
->top
);
1350 register int last_text_vpos
= vpos
;
1351 int tab_offset
= pos_tab_offset (w
, pos
);
1352 FRAME_PTR f
= XFRAME (w
->frame
);
1353 int width
= window_internal_width (w
) - 1;
1354 struct position val
;
1356 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1358 overlay_arrow_seen
= 0;
1359 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1361 while (--height
>= 0)
1363 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, tab_offset
);
1364 tab_offset
+= width
;
1365 if (val
.vpos
) tab_offset
= 0;
1367 if (pos
!= val
.bufpos
)
1369 /* Next line, unless prev line ended in end of buffer with no cr */
1370 = vpos
- (val
.vpos
&& (FETCH_CHAR (val
.bufpos
- 1) != '\n'
1371 #ifdef USE_TEXT_PROPERTIES
1372 || ! NILP (Fget_char_property (val
.bufpos
-1,
1380 /* If last line is continued in middle of character,
1381 include the split character in the text considered on the frame */
1382 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
1385 /* If bottom just moved off end of frame, change mode line percentage. */
1386 if (XFASTINT (w
->window_end_pos
) == 0
1388 w
->update_mode_line
= Qt
;
1390 /* Say where last char on frame will be, once redisplay is finished. */
1391 XFASTINT (w
->window_end_pos
) = Z
- pos
;
1392 XFASTINT (w
->window_end_vpos
) = last_text_vpos
- XFASTINT (w
->top
);
1393 /* But that is not valid info until redisplay finishes. */
1394 w
->window_end_valid
= Qnil
;
1397 /* Try to redisplay when buffer is modified locally,
1398 computing insert/delete line to preserve text outside
1399 the bounds of the changes.
1400 Return 1 if successful, 0 if if cannot tell what to do,
1401 or -1 to tell caller to find a new window start,
1402 or -2 to tell caller to do normal redisplay with same window start. */
1405 try_window_id (window
)
1409 register struct window
*w
= XWINDOW (window
);
1410 register int height
= window_internal_height (w
);
1411 FRAME_PTR f
= XFRAME (w
->frame
);
1412 int top
= XFASTINT (w
->top
);
1413 int start
= marker_position (w
->start
);
1414 int width
= window_internal_width (w
) - 1;
1415 int hscroll
= XINT (w
->hscroll
);
1416 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1418 register int i
, tem
;
1419 int last_text_vpos
= 0;
1422 = XTYPE (current_buffer
->selective_display
) == Lisp_Int
1423 ? XINT (current_buffer
->selective_display
)
1424 : !NILP (current_buffer
->selective_display
) ? -1 : 0;
1426 struct position val
, bp
, ep
, xp
, pp
;
1427 int scroll_amount
= 0;
1429 int tab_offset
, epto
;
1431 if (GPT
- BEG
< beg_unchanged
)
1432 beg_unchanged
= GPT
- BEG
;
1433 if (Z
- GPT
< end_unchanged
)
1434 end_unchanged
= Z
- GPT
;
1436 if (beg_unchanged
+ BEG
< start
)
1437 return 0; /* Give up if changes go above top of window */
1439 /* Find position before which nothing is changed. */
1440 bp
= *compute_motion (start
, 0, lmargin
,
1441 min (ZV
, beg_unchanged
+ BEG
), height
+ 1, 0,
1442 width
, hscroll
, pos_tab_offset (w
, start
));
1443 if (bp
.vpos
>= height
)
1445 if (point
< bp
.bufpos
&& !bp
.contin
)
1447 /* All changes are below the frame, and point is on the frame.
1448 We don't need to change the frame at all.
1449 But we need to update window_end_pos to account for
1450 any change in buffer size. */
1451 bp
= *compute_motion (start
, 0, lmargin
,
1453 width
, hscroll
, pos_tab_offset (w
, start
));
1454 XFASTINT (w
->window_end_vpos
) = height
;
1455 XFASTINT (w
->window_end_pos
) = Z
- bp
.bufpos
;
1463 /* Find beginning of that frame line. Must display from there. */
1464 bp
= *vmotion (bp
.bufpos
, 0, width
, hscroll
, window
);
1471 /* If about to start displaying at the beginning of a continuation line,
1472 really start with previous frame line, in case it was not
1473 continued when last redisplayed */
1474 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
1476 /* Likewise if we have to worry about selective display. */
1477 (selective
> 0 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
1479 bp
= *vmotion (bp
.bufpos
, -1, width
, hscroll
, window
);
1484 if (bp
.contin
&& bp
.hpos
!= lmargin
)
1486 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
1492 /* Find first visible newline after which no more is changed. */
1493 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
1495 while (tem
< ZV
- 1 && (indented_beyond_p (tem
, selective
)))
1496 tem
= find_next_newline (tem
, 1);
1498 /* Compute the cursor position after that newline. */
1499 ep
= *compute_motion (pos
, vpos
, val
.hpos
, tem
,
1500 height
, - (1 << (SHORTBITS
- 1)),
1501 width
, hscroll
, pos_tab_offset (w
, bp
.bufpos
));
1503 /* If changes reach past the text available on the frame,
1504 just display rest of frame. */
1505 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
1508 stop_vpos
= ep
.vpos
;
1510 /* If no newline before ep, the line ep is on includes some changes
1511 that must be displayed. Make sure we don't stop before it. */
1512 /* Also, if changes reach all the way until ep.bufpos,
1513 it is possible that something was deleted after the
1514 newline before it, so the following line must be redrawn. */
1515 if (stop_vpos
== ep
.vpos
1516 && (ep
.bufpos
== BEGV
1517 || FETCH_CHAR (ep
.bufpos
- 1) != '\n'
1518 || ep
.bufpos
== Z
- end_unchanged
))
1519 stop_vpos
= ep
.vpos
+ 1;
1522 overlay_arrow_seen
= 0;
1524 /* If changes do not reach to bottom of window,
1525 figure out how much to scroll the rest of the window */
1526 if (stop_vpos
< height
)
1528 /* Now determine how far up or down the rest of the window has moved */
1529 epto
= pos_tab_offset (w
, ep
.bufpos
);
1530 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1531 Z
- XFASTINT (w
->window_end_pos
),
1532 10000, 0, width
, hscroll
, epto
);
1533 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
1535 /* Is everything on frame below the changes whitespace?
1536 If so, no scrolling is really necessary. */
1537 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
1539 tem
= FETCH_CHAR (i
);
1540 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
1546 XFASTINT (w
->window_end_vpos
) += scroll_amount
;
1548 /* Before doing any scrolling, verify that point will be on frame. */
1549 if (point
> ep
.bufpos
&& !(point
<= xp
.bufpos
&& xp
.bufpos
< height
))
1551 if (point
<= xp
.bufpos
)
1553 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1554 point
, height
, - (1 << (SHORTBITS
- 1)),
1555 width
, hscroll
, epto
);
1559 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
,
1560 point
, height
, - (1 << (SHORTBITS
- 1)),
1561 width
, hscroll
, pos_tab_offset (w
, xp
.bufpos
));
1563 if (pp
.bufpos
< point
|| pp
.vpos
== height
)
1565 cursor_vpos
= pp
.vpos
+ top
;
1566 cursor_hpos
= pp
.hpos
+ XFASTINT (w
->left
);
1569 if (stop_vpos
- scroll_amount
>= height
1570 || ep
.bufpos
== xp
.bufpos
)
1572 if (scroll_amount
< 0)
1573 stop_vpos
-= scroll_amount
;
1575 /* In this path, we have altered window_end_vpos
1576 and not left it negative.
1577 We must make sure that, in case display is preempted
1578 before the frame changes to reflect what we do here,
1579 further updates will not come to try_window_id
1580 and assume the frame and window_end_vpos match. */
1581 blank_end_of_window
= 1;
1583 else if (!scroll_amount
)
1585 else if (bp
.bufpos
== Z
- end_unchanged
)
1587 /* If reprinting everything is nearly as fast as scrolling,
1588 don't bother scrolling. Can happen if lines are short. */
1589 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
1590 top
+ height
- max (0, scroll_amount
),
1592 > xp
.bufpos
- bp
.bufpos
- 20)
1593 /* Return "try normal display with same window-start."
1594 Too bad we can't prevent further scroll-thinking. */
1596 /* If pure deletion, scroll up as many lines as possible.
1597 In common case of killing a line, this can save the
1598 following line from being overwritten by scrolling
1599 and therefore having to be redrawn. */
1600 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
1601 top
+ height
- max (0, scroll_amount
),
1603 if (!tem
) stop_vpos
= height
;
1605 else if (scroll_amount
)
1607 /* If reprinting everything is nearly as fast as scrolling,
1608 don't bother scrolling. Can happen if lines are short. */
1609 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
1610 overestimate of cost of reprinting, since xp.bufpos
1611 would end up below the bottom of the window. */
1612 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
1613 top
+ height
- max (0, scroll_amount
),
1615 > xp
.bufpos
- ep
.bufpos
- 20)
1616 /* Return "try normal display with same window-start."
1617 Too bad we can't prevent further scroll-thinking. */
1619 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
1620 top
+ height
- max (0, scroll_amount
),
1622 if (!tem
) stop_vpos
= height
;
1626 /* In any case, do not display past bottom of window */
1627 if (stop_vpos
>= height
)
1633 /* Handle case where pos is before w->start --
1634 can happen if part of line had been clipped and is not clipped now */
1635 if (vpos
== 0 && pos
< marker_position (w
->start
))
1636 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1638 /* Redisplay the lines where the text was changed */
1639 last_text_vpos
= vpos
;
1640 tab_offset
= pos_tab_offset (w
, pos
);
1641 /* If we are starting display in mid-character, correct tab_offset
1642 to account for passing the line that that character really starts in. */
1643 if (val
.hpos
< lmargin
)
1644 tab_offset
+= width
;
1645 while (vpos
< stop_vpos
)
1647 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1648 tab_offset
+= width
;
1649 if (val
.vpos
) tab_offset
= 0;
1650 if (pos
!= val
.bufpos
)
1652 /* Next line, unless prev line ended in end of buffer with no cr */
1653 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
1657 /* There are two cases:
1658 1) we have displayed down to the bottom of the window
1659 2) we have scrolled lines below stop_vpos by scroll_amount */
1663 /* If last line is continued in middle of character,
1664 include the split character in the text considered on the frame */
1665 if (val
.hpos
< lmargin
)
1667 XFASTINT (w
->window_end_vpos
) = last_text_vpos
;
1668 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1671 /* If scrolling made blank lines at window bottom,
1672 redisplay to fill those lines */
1673 if (scroll_amount
< 0)
1675 /* Don't consider these lines for general-purpose scrolling.
1676 That will save time in the scrolling computation. */
1677 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
1682 vpos
= height
+ scroll_amount
;
1683 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
1685 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
1689 blank_end_of_window
= 1;
1690 tab_offset
= pos_tab_offset (w
, pos
);
1691 /* If we are starting display in mid-character, correct tab_offset
1692 to account for passing the line that that character starts in. */
1693 if (val
.hpos
< lmargin
)
1694 tab_offset
+= width
;
1696 while (vpos
< height
)
1698 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1699 tab_offset
+= width
;
1700 if (val
.vpos
) tab_offset
= 0;
1704 /* Here is a case where display_text_line sets cursor_vpos wrong.
1705 Make it be fixed up, below. */
1707 && xp
.bufpos
== point
)
1711 /* If bottom just moved off end of frame, change mode line percentage. */
1712 if (XFASTINT (w
->window_end_pos
) == 0
1714 w
->update_mode_line
= Qt
;
1716 /* Attempt to adjust end-of-text positions to new bottom line */
1719 delta
= height
- xp
.vpos
;
1721 || (delta
> 0 && xp
.bufpos
<= ZV
)
1722 || (delta
== 0 && xp
.hpos
))
1724 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1725 delta
, width
, hscroll
, window
);
1726 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1727 XFASTINT (w
->window_end_vpos
) += val
.vpos
;
1731 w
->window_end_valid
= Qnil
;
1733 /* If point was not in a line that was displayed, find it */
1734 if (cursor_vpos
< 0)
1736 val
= *compute_motion (start
, 0, lmargin
, point
, 10000, 10000,
1737 width
, hscroll
, pos_tab_offset (w
, start
));
1738 /* Admit failure if point is off frame now */
1739 if (val
.vpos
>= height
)
1741 for (vpos
= 0; vpos
< height
; vpos
++)
1742 cancel_line (vpos
+ top
, f
);
1745 cursor_vpos
= val
.vpos
+ top
;
1746 cursor_hpos
= val
.hpos
+ XFASTINT (w
->left
);
1749 FRAME_CURSOR_X (f
) = max (0, cursor_hpos
);
1750 FRAME_CURSOR_Y (f
) = cursor_vpos
;
1754 val
= *compute_motion (start
, 0, lmargin
, ZV
,
1755 height
, - (1 << (SHORTBITS
- 1)),
1756 width
, hscroll
, pos_tab_offset (w
, start
));
1757 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
1759 if (XFASTINT (w
->window_end_pos
)
1767 /* Mark a section of BUF as modified, but only for the sake of redisplay.
1768 This is useful for recording changes to overlays.
1770 We increment the buffer's modification timestamp and set the
1771 redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
1772 as if the region of text between START and END had been modified;
1773 the redisplay code will check this against the windows' timestamps,
1774 and redraw the appropriate area of the buffer.
1776 However, if the buffer is unmodified, we bump the last-save
1777 timestamp as well, so that incrementing the timestamp doesn't fool
1778 Emacs into thinking that the buffer's text has been modified.
1780 Tweaking the timestamps shouldn't hurt the first-modification
1781 timestamps recorded in the undo records; those values aren't
1782 written until just before a real text modification is made, so they
1783 will never catch the timestamp value just before this function gets
1787 redisplay_region (buf
, start
, end
)
1797 start
= end
; end
= temp
;
1800 if (buf
!= current_buffer
)
1801 windows_or_buffers_changed
= 1;
1804 if (unchanged_modified
== MODIFF
)
1806 beg_unchanged
= start
- BEG
;
1807 end_unchanged
= Z
- end
;
1811 if (Z
- end
< end_unchanged
)
1812 end_unchanged
= Z
- end
;
1813 if (start
- BEG
< beg_unchanged
)
1814 beg_unchanged
= start
- BEG
;
1818 /* Increment the buffer's time stamp, but also increment the save
1819 and autosave timestamps, so as not to screw up that timekeeping. */
1820 if (BUF_MODIFF (buf
) == buf
->save_modified
)
1821 buf
->save_modified
++;
1822 if (BUF_MODIFF (buf
) == buf
->auto_save_modified
)
1823 buf
->auto_save_modified
++;
1825 BUF_MODIFF (buf
) ++;
1829 /* Copy LEN glyphs starting address FROM to the rope TO.
1830 But don't actually copy the parts that would come in before S.
1831 Value is TO, advanced past the copied data.
1832 F is the frame we are displaying in. */
1835 copy_part_of_rope (f
, to
, s
, from
, len
, face
)
1837 register GLYPH
*to
; /* Copy to here. */
1838 register GLYPH
*s
; /* Starting point. */
1839 Lisp_Object
*from
; /* Data to copy. */
1841 int face
; /* Face to apply to glyphs which don't specify one. */
1844 register Lisp_Object
*fp
= from
;
1845 /* These cache the results of the last call to compute_glyph_face. */
1847 int last_merged
= 0;
1851 int glyph
= XFASTINT (*fp
);
1854 if (GLYPH_FACE (glyph
) == 0)
1855 /* If GLYPH has no face code, use FACE. */
1857 else if (GLYPH_FACE (glyph
) == last_code
)
1858 /* If it's same as previous glyph, use same result. */
1859 facecode
= last_merged
;
1862 /* Merge this glyph's face and remember the result. */
1863 last_code
= GLYPH_FACE (glyph
);
1864 last_merged
= facecode
= compute_glyph_face (f
, last_code
, face
);
1867 if (to
>= s
) *to
= MAKE_GLYPH (GLYPH_CHAR (glyph
), facecode
);
1874 /* Correct a glyph by replacing its specified user-level face code
1875 with a displayable computed face code. */
1878 fix_glyph (f
, glyph
, current_face
)
1883 if (GLYPH_FACE (glyph
) == 0)
1885 return MAKE_GLYPH (GLYPH_CHAR (glyph
),
1886 compute_glyph_face (f
, GLYPH_FACE (glyph
), current_face
));
1889 /* Display one line of window w, starting at position START in W's buffer.
1890 Display starting at horizontal position HPOS, which is normally zero
1891 or negative. A negative value causes output up to hpos = 0 to be discarded.
1892 This is done for negative hscroll, or when this is a continuation line
1893 and the continuation occurred in the middle of a multi-column character.
1895 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
1897 Display on position VPOS on the frame. (origin 0).
1899 Returns a STRUCT POSITION giving character to start next line with
1900 and where to display it, including a zero or negative hpos.
1901 The vpos field is not really a vpos; it is 1 unless the line is continued */
1903 struct position val_display_text_line
;
1905 static struct position
*
1906 display_text_line (w
, start
, vpos
, hpos
, taboffset
)
1913 register int pos
= start
;
1918 register unsigned char *p
;
1920 register GLYPH
*startp
;
1921 register GLYPH
*p1prev
= 0;
1922 FRAME_PTR f
= XFRAME (w
->frame
);
1923 int tab_width
= XINT (current_buffer
->tab_width
);
1924 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1925 int width
= window_internal_width (w
) - 1;
1926 struct position val
;
1929 int hscroll
= XINT (w
->hscroll
);
1930 int truncate
= hscroll
1931 || (truncate_partial_width_windows
1932 && XFASTINT (w
->width
) < FRAME_WIDTH (f
))
1933 || !NILP (current_buffer
->truncate_lines
);
1935 /* 1 if we should highlight the region. */
1936 int highlight_region
1937 = !NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
);
1938 int region_beg
, region_end
;
1941 = XTYPE (current_buffer
->selective_display
) == Lisp_Int
1942 ? XINT (current_buffer
->selective_display
)
1943 : !NILP (current_buffer
->selective_display
) ? -1 : 0;
1944 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
1945 register struct Lisp_Vector
*dp
= window_display_table (w
);
1947 Lisp_Object default_invis_vector
[3];
1948 /* Nonzero means display something where there are invisible lines.
1949 The precise value is the number of glyphs to display. */
1951 = (selective
&& dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1952 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
1953 : selective
&& !NILP (current_buffer
->selective_display_ellipses
)
1955 /* This is the sequence of Lisp objects to display
1956 when there are invisible lines. */
1957 Lisp_Object
*invis_vector_contents
1958 = (dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1959 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
1960 : default_invis_vector
);
1962 GLYPH truncator
= (dp
== 0 || XTYPE (DISP_TRUNC_GLYPH (dp
)) != Lisp_Int
1963 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
1964 GLYPH continuer
= (dp
== 0 || XTYPE (DISP_CONTINUE_GLYPH (dp
)) != Lisp_Int
1965 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
1967 /* The next buffer location at which the face should change, due
1968 to overlays or text property changes. */
1969 int next_face_change
;
1971 #ifdef USE_TEXT_PROPERTIES
1972 /* The next location where the `invisible' property changes */
1976 /* The face we're currently using. */
1977 int current_face
= 0;
1979 XFASTINT (default_invis_vector
[2]) = '.';
1980 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
1982 hpos
+= XFASTINT (w
->left
);
1983 get_display_line (f
, vpos
, XFASTINT (w
->left
));
1984 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
1986 /* Show where to highlight the region. */
1987 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
1988 /* Maybe highlight only in selected window. */
1989 && (highlight_nonselected_windows
1990 || w
== XWINDOW (selected_window
)))
1992 region_beg
= marker_position (current_buffer
->mark
);
1993 if (PT
< region_beg
)
1995 region_end
= region_beg
;
2000 w
->region_showing
= Qt
;
2003 region_beg
= region_end
= -1;
2005 if (MINI_WINDOW_P (w
) && start
== 1
2006 && vpos
== XFASTINT (w
->top
))
2009 hpos
= display_string (w
, vpos
, minibuf_prompt
, -1, hpos
,
2010 (!truncate
? continuer
: truncator
),
2012 minibuf_prompt_width
= hpos
;
2015 desired_glyphs
->bufp
[vpos
] = pos
;
2016 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2018 startp
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
2019 endp
= startp
+ width
;
2021 /* Arrange the overlays nicely for our purposes. Usually, we call
2022 display_text_line on only one line at a time, in which case this
2023 can't really hurt too much, or we call it on lines which appear
2024 one after another in the buffer, in which case all calls to
2025 recenter_overlay_lists but the first will be pretty cheap. */
2026 recenter_overlay_lists (current_buffer
, pos
);
2028 /* Loop generating characters.
2029 Stop at end of buffer, before newline,
2030 if reach or pass continuation column,
2031 or at face change. */
2033 next_face_change
= pos
;
2034 #ifdef USE_TEXT_PROPERTIES
2035 next_invisible
= pos
;
2042 /* Did we hit the end of the visible region of the buffer?
2047 /* Did we reach point? Record the cursor location. */
2048 if (pos
== point
&& cursor_vpos
< 0)
2051 cursor_hpos
= p1
- startp
;
2054 #ifdef USE_TEXT_PROPERTIES
2055 /* if the `invisible' property is set to t, we can skip to
2056 the next property change */
2057 while (pos
== next_invisible
&& pos
< end
)
2059 Lisp_Object position
, limit
, endpos
, prop
, ww
;
2060 XFASTINT (position
) = pos
;
2061 XSET (ww
, Lisp_Window
, w
);
2062 prop
= Fget_char_property (position
, Qinvisible
, ww
);
2063 /* This is just an estimate to give reasonable
2064 performance; nothing should go wrong if it is too small. */
2065 XFASTINT (limit
) = pos
+ 50;
2067 = Fnext_single_property_change (position
, Qinvisible
,
2068 Fcurrent_buffer (), limit
);
2069 if (INTEGERP (endpos
))
2070 next_invisible
= XINT (endpos
);
2072 next_invisible
= end
;
2075 if (pos
< point
&& next_invisible
>= point
)
2078 cursor_hpos
= p1
- startp
;
2080 pos
= next_invisible
;
2087 #ifdef HAVE_X_WINDOWS
2088 /* Did we hit a face change? Figure out what face we should
2089 use now. We also hit this the first time through the
2090 loop, to see what face we should start with. */
2091 if (pos
>= next_face_change
&& FRAME_X_P (f
))
2092 current_face
= compute_char_face (f
, w
, pos
,
2093 region_beg
, region_end
,
2094 &next_face_change
, pos
+ 50);
2099 #ifdef USE_TEXT_PROPERTIES
2100 if (pos
< next_invisible
&& next_invisible
< pause
)
2101 pause
= next_invisible
;
2103 if (pos
< next_face_change
&& next_face_change
< pause
)
2104 pause
= next_face_change
;
2106 /* Wouldn't you hate to read the next line to someone over
2108 if (pos
< point
&& point
< pause
)
2110 if (pos
< GPT
&& GPT
< pause
)
2113 p
= &FETCH_CHAR (pos
);
2116 if (c
>= 040 && c
< 0177
2117 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
2120 *p1
= MAKE_GLYPH (c
, current_face
);
2128 && indented_beyond_p (pos
+ 1, selective
))
2131 pos
= find_next_newline (pos
+ 1, 1);
2132 if (FETCH_CHAR (pos
- 1) == '\n')
2135 if (invis
&& selective_rlen
> 0 && p1
>= startp
)
2137 p1
+= selective_rlen
;
2138 if (p1
- startp
> width
)
2140 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
2141 (p1
- p1prev
), current_face
);
2144 /* Draw the face of the newline character as extending all the
2145 way to the end of the frame line. */
2148 *p1
++ = MAKE_GLYPH (' ', current_face
);
2156 if (p1
>= startp
&& p1
< endp
)
2157 *p1
= MAKE_GLYPH (' ', current_face
);
2160 while ((p1
- startp
+ taboffset
+ hscroll
- (hscroll
> 0))
2163 else if (c
== Ctl ('M') && selective
== -1)
2165 pos
= find_next_newline (pos
, 1);
2166 if (FETCH_CHAR (pos
- 1) == '\n')
2168 if (selective_rlen
> 0)
2170 p1
+= selective_rlen
;
2171 if (p1
- startp
> width
)
2173 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
2174 (p1
- p1prev
), current_face
);
2177 /* Draw the face of the newline character as extending all the
2178 way to the end of the frame line. */
2181 *p1
++ = MAKE_GLYPH (' ', current_face
);
2185 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
2187 p1
= copy_part_of_rope (f
, p1
, startp
,
2188 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
2189 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
2192 else if (c
< 0200 && ctl_arrow
)
2195 *p1
= fix_glyph (f
, (dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
2196 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
2199 if (p1
>= startp
&& p1
< endp
)
2200 *p1
= MAKE_GLYPH (c
^ 0100, current_face
);
2206 *p1
= fix_glyph (f
, (dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
2207 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
2210 if (p1
>= startp
&& p1
< endp
)
2211 *p1
= MAKE_GLYPH ((c
>> 6) + '0', current_face
);
2213 if (p1
>= startp
&& p1
< endp
)
2214 *p1
= MAKE_GLYPH ((7 & (c
>> 3)) + '0', current_face
);
2216 if (p1
>= startp
&& p1
< endp
)
2217 *p1
= MAKE_GLYPH ((7 & c
) + '0', current_face
);
2224 val
.hpos
= - XINT (w
->hscroll
);
2232 /* Handle continuation in middle of a character */
2233 /* by backing up over it */
2236 /* Don't back up if we never actually displayed any text.
2237 This occurs when the minibuffer prompt takes up the whole line. */
2240 /* Start the next line with that same character */
2242 /* but at negative hpos, to skip the columns output on this line. */
2243 val
.hpos
+= p1prev
- endp
;
2246 /* Keep in this line everything up to the continuation column. */
2250 /* Finish deciding which character to start the next line on,
2251 and what hpos to start it at.
2252 Also set `lastpos' to the last position which counts as "on this line"
2253 for cursor-positioning. */
2257 if (FETCH_CHAR (pos
) == '\n')
2258 /* If stopped due to a newline, start next line after it */
2261 /* Stopped due to right margin of window */
2265 *p1
++ = fix_glyph (f
, truncator
, 0);
2266 /* Truncating => start next line after next newline,
2267 and point is on this line if it is before the newline,
2268 and skip none of first char of next line */
2269 pos
= find_next_newline (pos
, 1);
2270 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
2272 lastpos
= pos
- (FETCH_CHAR (pos
- 1) == '\n');
2276 *p1
++ = fix_glyph (f
, continuer
, 0);
2283 /* If point is at eol or in invisible text at eol,
2284 record its frame location now. */
2286 if (start
<= point
&& point
<= lastpos
&& cursor_vpos
< 0)
2289 cursor_hpos
= p1
- startp
;
2292 if (cursor_vpos
== vpos
)
2294 if (cursor_hpos
< 0) cursor_hpos
= 0;
2295 if (cursor_hpos
> width
) cursor_hpos
= width
;
2296 cursor_hpos
+= XFASTINT (w
->left
);
2297 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
2299 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2300 FRAME_CURSOR_X (f
) = cursor_hpos
;
2302 if (w
== XWINDOW (selected_window
))
2304 /* Line is not continued and did not start
2305 in middle of character */
2306 if ((hpos
- XFASTINT (w
->left
)
2307 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2310 this_line_bufpos
= start
;
2311 this_line_buffer
= current_buffer
;
2312 this_line_vpos
= cursor_vpos
;
2313 this_line_start_hpos
= hpos
;
2314 this_line_endpos
= Z
- lastpos
;
2317 this_line_bufpos
= 0;
2322 /* If hscroll and line not empty, insert truncation-at-left marker */
2323 if (hscroll
&& lastpos
!= start
)
2325 *startp
= fix_glyph (f
, truncator
, 0);
2330 if (XFASTINT (w
->width
) + XFASTINT (w
->left
) != FRAME_WIDTH (f
))
2333 if (p1
< startp
) p1
= startp
;
2334 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
2336 /* Don't draw vertical bars if we're using scroll bars. They're
2337 covered up by the scroll bars, and it's distracting to see
2338 them when the scroll bar windows are flickering around to be
2340 *p1
++ = (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
2343 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
2344 p1
- desired_glyphs
->glyphs
[vpos
]);
2345 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2347 /* If the start of this line is the overlay arrow-position,
2348 then put the arrow string into the display-line. */
2350 if (XTYPE (Voverlay_arrow_position
) == Lisp_Marker
2351 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
2352 && start
== marker_position (Voverlay_arrow_position
)
2353 && XTYPE (Voverlay_arrow_string
) == Lisp_String
2354 && ! overlay_arrow_seen
)
2356 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
2358 int len
= XSTRING (Voverlay_arrow_string
)->size
;
2363 for (i
= 0; i
< len
; i
++)
2366 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
2367 arrow_end
= (startp
- desired_glyphs
->glyphs
[vpos
]) + len
;
2368 if (desired_glyphs
->used
[vpos
] < arrow_end
)
2369 desired_glyphs
->used
[vpos
] = arrow_end
;
2371 overlay_arrow_seen
= 1;
2375 val_display_text_line
= val
;
2376 return &val_display_text_line
;
2379 /* Redisplay the menu bar in the frame for window W. */
2382 display_menu_bar (w
)
2385 Lisp_Object items
, tail
;
2386 register int vpos
= 0;
2387 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2388 int maxendcol
= FRAME_WIDTH (f
);
2391 #ifndef USE_X_TOOLKIT
2392 if (FRAME_MENU_BAR_LINES (f
) <= 0)
2395 get_display_line (f
, vpos
, 0);
2397 for (tail
= FRAME_MENU_BAR_ITEMS (f
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2401 string
= XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->car
;
2403 /* Record in each item its hpos. */
2404 XFASTINT (XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->cdr
) = hpos
;
2406 if (hpos
< maxendcol
)
2407 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
2408 XSTRING (string
)->data
,
2409 XSTRING (string
)->size
,
2410 hpos
, 0, 0, hpos
, maxendcol
);
2411 /* Put a gap of 3 spaces between items. */
2412 if (hpos
< maxendcol
)
2414 int hpos1
= hpos
+ 3;
2415 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0,
2416 min (hpos1
, maxendcol
), maxendcol
);
2420 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2421 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2423 /* Fill out the line with spaces. */
2424 if (maxendcol
> hpos
)
2425 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0, maxendcol
, maxendcol
);
2427 /* Clear the rest of the lines allocated to the menu bar. */
2429 while (vpos
< FRAME_MENU_BAR_LINES (f
))
2430 get_display_line (f
, vpos
++, 0);
2431 #endif /* not USE_X_TOOLKIT */
2434 /* Display the mode line for window w */
2437 display_mode_line (w
)
2440 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
2441 register int left
= XFASTINT (w
->left
);
2442 register int right
= XFASTINT (w
->width
) + left
;
2443 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2445 line_number_displayed
= 0;
2447 get_display_line (f
, vpos
, left
);
2448 display_mode_element (w
, vpos
, left
, 0, right
, right
,
2449 current_buffer
->mode_line_format
);
2450 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2452 /* Make the mode line inverse video if the entire line
2453 is made of mode lines.
2454 I.e. if this window is full width,
2455 or if it is the child of a full width window
2456 (which implies that that window is split side-by-side
2457 and the rest of this line is mode lines of the sibling windows). */
2458 if (XFASTINT (w
->width
) == FRAME_WIDTH (f
)
2459 || XFASTINT (XWINDOW (w
->parent
)->width
) == FRAME_WIDTH (f
))
2460 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2462 #ifdef HAVE_X_WINDOWS
2463 /* I'm trying this out because I saw Unimpress use it, but it's
2464 possible that this may mess adversely with some window managers. -jla
2466 Wouldn't it be nice to use something like mode-line-format to
2467 describe frame titles? -JimB */
2469 /* Change the title of the frame to the name of the buffer displayed
2470 in the currently selected window. Don't do this for minibuffer frames,
2471 and don't do it when there's only one non-minibuffer frame. */
2473 && ! FRAME_MINIBUF_ONLY_P (f
)
2474 && w
== XWINDOW (f
->selected_window
))
2475 x_implicitly_set_name (f
, (EQ (Fnext_frame (WINDOW_FRAME (w
), Qnil
),
2478 : XBUFFER (w
->buffer
)->name
),
2483 /* Contribute ELT to the mode line for window W.
2484 How it translates into text depends on its data type.
2486 VPOS is the position of the mode line being displayed.
2488 HPOS is the position (absolute on frame) where this element's text
2489 should start. The output is truncated automatically at the right
2492 DEPTH is the depth in recursion. It is used to prevent
2493 infinite recursion here.
2495 MINENDCOL is the hpos before which the element may not end.
2496 The element is padded at the right with spaces if nec
2497 to reach this column.
2499 MAXENDCOL is the hpos past which this element may not extend.
2500 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
2501 (This is necessary to make nested padding and truncation work.)
2503 Returns the hpos of the end of the text generated by ELT.
2504 The next element will receive that value as its HPOS arg,
2505 so as to concatenate the elements. */
2508 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
2510 register int vpos
, hpos
;
2513 register int maxendcol
;
2514 register Lisp_Object elt
;
2522 #ifdef SWITCH_ENUM_BUG
2523 switch ((int) XTYPE (elt
))
2525 switch (XTYPE (elt
))
2530 /* A string: output it and check for %-constructs within it. */
2531 register unsigned char c
;
2532 register unsigned char *this = XSTRING (elt
)->data
;
2534 while (hpos
< maxendcol
&& *this)
2536 unsigned char *last
= this;
2537 while ((c
= *this++) != '\0' && c
!= '%')
2539 if (this - 1 != last
)
2541 register int lim
= --this - last
+ hpos
;
2542 hpos
= display_string (w
, vpos
, last
, -1, hpos
, 0, 1,
2543 hpos
, min (lim
, maxendcol
));
2547 register int spec_width
= 0;
2549 /* We can't allow -ve args due to the "%-" construct */
2550 /* Argument specifies minwidth but not maxwidth
2551 (maxwidth can be specified by
2552 (<negative-number> . <stuff>) mode-line elements) */
2554 while ((c
= *this++) >= '0' && c
<= '9')
2556 spec_width
= spec_width
* 10 + (c
- '0');
2560 if (spec_width
> maxendcol
)
2561 spec_width
= maxendcol
;
2564 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2565 spec_width
, maxendcol
,
2566 Vglobal_mode_string
);
2568 hpos
= display_string (w
, vpos
,
2569 decode_mode_spec (w
, c
,
2572 hpos
, 0, 1, spec_width
, maxendcol
);
2579 /* A symbol: process the value of the symbol recursively
2580 as if it appeared here directly. Avoid error if symbol void.
2581 Special case: if value of symbol is a string, output the string
2584 register Lisp_Object tem
;
2585 tem
= Fboundp (elt
);
2588 tem
= Fsymbol_value (elt
);
2589 /* If value is a string, output that string literally:
2590 don't check for % within it. */
2591 if (XTYPE (tem
) == Lisp_String
)
2592 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
2593 XSTRING (tem
)->size
,
2594 hpos
, 0, 1, minendcol
, maxendcol
);
2595 /* Give up right away for nil or t. */
2596 else if (!EQ (tem
, elt
))
2597 { elt
= tem
; goto tail_recurse
; }
2604 register Lisp_Object car
, tem
;
2606 /* A cons cell: three distinct cases.
2607 If first element is a string or a cons, process all the elements
2608 and effectively concatenate them.
2609 If first element is a negative number, truncate displaying cdr to
2610 at most that many characters. If positive, pad (with spaces)
2611 to at least that many characters.
2612 If first element is a symbol, process the cadr or caddr recursively
2613 according to whether the symbol's value is non-nil or nil. */
2614 car
= XCONS (elt
)->car
;
2615 if (XTYPE (car
) == Lisp_Symbol
)
2617 tem
= Fboundp (car
);
2618 elt
= XCONS (elt
)->cdr
;
2619 if (XTYPE (elt
) != Lisp_Cons
)
2621 /* elt is now the cdr, and we know it is a cons cell.
2622 Use its car if CAR has a non-nil value. */
2625 tem
= Fsymbol_value (car
);
2627 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
2629 /* Symbol's value is nil (or symbol is unbound)
2630 Get the cddr of the original list
2631 and if possible find the caddr and use that. */
2632 elt
= XCONS (elt
)->cdr
;
2635 else if (XTYPE (elt
) != Lisp_Cons
)
2637 elt
= XCONS (elt
)->car
;
2640 else if (XTYPE (car
) == Lisp_Int
)
2642 register int lim
= XINT (car
);
2643 elt
= XCONS (elt
)->cdr
;
2645 /* Negative int means reduce maximum width.
2646 DO NOT change MINENDCOL here!
2647 (20 -10 . foo) should truncate foo to 10 col
2648 and then pad to 20. */
2649 maxendcol
= min (maxendcol
, hpos
- lim
);
2652 /* Padding specified. Don't let it be more than
2655 if (lim
> maxendcol
)
2657 /* If that's more padding than already wanted, queue it.
2658 But don't reduce padding already specified even if
2659 that is beyond the current truncation point. */
2660 if (lim
> minendcol
)
2665 else if (XTYPE (car
) == Lisp_String
|| XTYPE (car
) == Lisp_Cons
)
2667 register int limit
= 50;
2668 /* LIMIT is to protect against circular lists. */
2669 while (XTYPE (elt
) == Lisp_Cons
&& --limit
> 0
2670 && hpos
< maxendcol
)
2672 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2675 elt
= XCONS (elt
)->cdr
;
2683 return (display_string (w
, vpos
, "*invalid*", -1, hpos
, 0, 1,
2684 minendcol
, maxendcol
));
2688 if (minendcol
> hpos
)
2689 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 1, minendcol
, maxendcol
);
2693 /* Return a string for the output of a mode line %-spec for window W,
2694 generated by character C and width MAXWIDTH. */
2696 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
2699 decode_mode_spec (w
, c
, maxwidth
)
2702 register int maxwidth
;
2704 Lisp_Object obj
= Qnil
;
2705 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2706 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
2708 if (maxwidth
> FRAME_WIDTH (f
))
2709 maxwidth
= FRAME_WIDTH (f
);
2714 obj
= current_buffer
->name
;
2716 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
2718 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
2719 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
2720 decode_mode_spec_buf
[maxwidth
] = '\0';
2721 return decode_mode_spec_buf
;
2727 obj
= current_buffer
->filename
;
2731 else if (XTYPE (obj
) == Lisp_String
&& XSTRING (obj
)->size
> maxwidth
)
2733 bcopy ("...", decode_mode_spec_buf
, 3);
2734 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
2735 decode_mode_spec_buf
+ 3, maxwidth
- 3);
2736 return decode_mode_spec_buf
;
2743 int startpos
= marker_position (w
->start
);
2744 int line
, linepos
, topline
;
2747 int height
= XFASTINT (w
->height
);
2749 /* If we decided that this buffer isn't suitable for line numbers,
2750 don't forget that too fast. */
2751 if (EQ (w
->base_line_pos
, w
->buffer
))
2754 /* If the buffer is very big, don't waste time. */
2755 if (ZV
- BEGV
> line_number_display_limit
)
2757 w
->base_line_pos
= Qnil
;
2758 w
->base_line_number
= Qnil
;
2762 if (!NILP (w
->base_line_number
)
2763 && !NILP (w
->base_line_pos
)
2764 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
2766 line
= XFASTINT (w
->base_line_number
);
2767 linepos
= XFASTINT (w
->base_line_pos
);
2775 /* Count lines from base line to window start position. */
2776 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
2778 topline
= nlines
+ line
;
2780 /* Determine a new base line, if the old one is too close
2781 or too far away, or if we did not have one.
2782 "Too close" means it's plausible a scroll-down would
2784 if (startpos
== BEGV
)
2786 XFASTINT (w
->base_line_number
) = topline
;
2787 XFASTINT (w
->base_line_pos
) = BEGV
;
2789 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
2794 int distance
= (height
* 2 + 30) * 200;
2796 if (startpos
- distance
> limit
)
2797 limit
= startpos
- distance
;
2799 nlines
= display_count_lines (startpos
, limit
,
2802 /* If we couldn't find the lines we wanted within
2804 give up on line numbers for this window. */
2805 if (position
== startpos
- distance
)
2807 w
->base_line_pos
= w
->buffer
;
2808 w
->base_line_number
= Qnil
;
2812 XFASTINT (w
->base_line_number
) = topline
- nlines
;
2813 XFASTINT (w
->base_line_pos
) = position
;
2816 /* Now count lines from the start pos to point. */
2817 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
2819 /* Record that we did display the line number. */
2820 line_number_displayed
= 1;
2822 /* Make the string to show. */
2823 sprintf (decode_mode_spec_buf
, "%d", topline
+ nlines
);
2824 return decode_mode_spec_buf
;
2829 obj
= current_buffer
->mode_name
;
2833 if (BEGV
> BEG
|| ZV
< Z
)
2838 if (!NILP (current_buffer
->read_only
))
2840 if (MODIFF
> current_buffer
->save_modified
)
2845 if (MODIFF
> current_buffer
->save_modified
)
2850 /* status of process */
2851 obj
= Fget_buffer_process (Fcurrent_buffer ());
2853 return "no process";
2855 obj
= Fsymbol_name (Fprocess_status (obj
));
2859 case 't': /* indicate TEXT or BINARY */
2861 decode_mode_spec_buf
[0]
2862 = NILP (current_buffer
->buffer_file_type
) ? "T" : "B";
2863 decode_mode_spec_buf
[1] = 0;
2864 return decode_mode_spec_buf
;
2865 #else /* not MSDOS */
2867 #endif /* not MSDOS */
2871 int pos
= marker_position (w
->start
);
2872 int total
= ZV
- BEGV
;
2874 if (XFASTINT (w
->window_end_pos
) <= Z
- ZV
)
2881 else if (pos
<= BEGV
)
2885 total
= ((pos
- BEGV
) * 100 + total
- 1) / total
;
2886 /* We can't normally display a 3-digit number,
2887 so get us a 2-digit number that is close. */
2890 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
2891 return decode_mode_spec_buf
;
2895 /* Display percentage of size above the bottom of the screen. */
2898 int toppos
= marker_position (w
->start
);
2899 int botpos
= Z
- XFASTINT (w
->window_end_pos
);
2900 int total
= ZV
- BEGV
;
2911 total
= ((botpos
- BEGV
) * 100 + total
- 1) / total
;
2912 /* We can't normally display a 3-digit number,
2913 so get us a 2-digit number that is close. */
2917 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
2919 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
2920 return decode_mode_spec_buf
;
2932 if (command_loop_level
> 5)
2934 p
= decode_mode_spec_buf
;
2935 for (i
= 0; i
< command_loop_level
; i
++)
2938 return decode_mode_spec_buf
;
2946 if (command_loop_level
> 5)
2948 p
= decode_mode_spec_buf
;
2949 for (i
= 0; i
< command_loop_level
; i
++)
2952 return decode_mode_spec_buf
;
2960 if (maxwidth
< sizeof (lots_of_dashes
))
2961 return lots_of_dashes
;
2964 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
2968 return decode_mode_spec_buf
;
2972 if (XTYPE (obj
) == Lisp_String
)
2973 return (char *) XSTRING (obj
)->data
;
2978 /* Count up to N lines starting from FROM.
2979 But don't go beyond LIMIT.
2980 Return the number of lines thus found (always positive).
2981 Store the position after what was found into *POS_PTR. */
2984 display_count_lines (from
, limit
, n
, pos_ptr
)
2997 *pos_ptr
= scan_buffer ('\n', from
, n
, &shortage
, 0);
3003 /* When scanning backwards, scan_buffer stops *after* the last newline
3004 it finds, but does count it. Compensate for that. */
3005 return - n
- shortage
- (*pos_ptr
!= limit
);
3006 return n
- shortage
;
3009 /* Display STRING on one line of window W, starting at HPOS.
3010 Display at position VPOS. Caller should have done get_display_line.
3011 If VPOS == -1, display it as the current frame's title.
3012 LENGTH is the length of STRING, or -1 meaning STRING is null-terminated.
3014 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
3016 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
3017 MAXCOL is the last column ok to end at. Truncate here.
3018 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
3019 Both count from the left edge of the frame, as does HPOS.
3020 The right edge of W is an implicit maximum.
3021 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
3023 OBEY_WINDOW_WIDTH says to put spaces or vertical bars
3024 at the place where the current window ends in this line
3025 and not display anything beyond there. Otherwise, only MAXCOL
3026 controls where to stop output.
3028 Returns ending hpos. */
3031 display_string (w
, vpos
, string
, length
, hpos
, truncate
,
3032 obey_window_width
, mincol
, maxcol
)
3034 unsigned char *string
;
3038 int obey_window_width
;
3043 int hscroll
= XINT (w
->hscroll
);
3044 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
3045 register GLYPH
*start
;
3046 register GLYPH
*end
;
3047 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3048 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
3049 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
3050 int window_width
= XFASTINT (w
->width
);
3052 /* Use the standard display table, not the window's display table.
3053 We don't want the mode line in rot13. */
3054 register struct Lisp_Vector
*dp
= 0;
3056 if (XTYPE (Vstandard_display_table
) == Lisp_Vector
3057 && XVECTOR (Vstandard_display_table
)->size
== DISP_TABLE_SIZE
)
3058 dp
= XVECTOR (Vstandard_display_table
);
3060 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
3063 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
3065 if (obey_window_width
)
3067 end
= start
+ window_width
- (truncate
!= 0);
3069 if ((window_width
+ XFASTINT (w
->left
)) != FRAME_WIDTH (f
))
3071 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3075 for (i
= 0; i
< VERTICAL_SCROLL_BAR_WIDTH
; i
++)
3083 if (! obey_window_width
3084 || (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
))
3085 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
3087 if (maxcol
>= 0 && mincol
> maxcol
)
3095 /* Specified length. */
3098 /* Unspecified length (null-terminated string). */
3102 if (c
>= 040 && c
< 0177
3103 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
3113 if (p1
>= start
&& p1
< end
)
3117 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
3119 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
3121 p1
= copy_part_of_rope (f
, p1
, start
,
3122 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
3123 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
3126 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
3129 *p1
= fix_glyph (f
, (dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
3130 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
3133 if (p1
>= start
&& p1
< end
)
3140 *p1
= fix_glyph (f
, (dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
3141 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
3144 if (p1
>= start
&& p1
< end
)
3145 *p1
= (c
>> 6) + '0';
3147 if (p1
>= start
&& p1
< end
)
3148 *p1
= (7 & (c
>> 3)) + '0';
3150 if (p1
>= start
&& p1
< end
)
3151 *p1
= (7 & c
) + '0';
3156 if (c
&& length
> 0)
3159 if (truncate
) *p1
++ = fix_glyph (f
, truncate
, 0);
3161 else if (mincol
>= 0)
3163 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
3169 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
3171 if (len
> desired_glyphs
->used
[vpos
])
3172 desired_glyphs
->used
[vpos
] = len
;
3173 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
3182 staticpro (&last_arrow_position
);
3183 staticpro (&last_arrow_string
);
3184 last_arrow_position
= Qnil
;
3185 last_arrow_string
= Qnil
;
3187 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
3188 "String (or mode line construct) included (normally) in `mode-line-format'.");
3189 Vglobal_mode_string
= Qnil
;
3191 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
3192 "Marker for where to display an arrow on top of the buffer text.\n\
3193 This must be the beginning of a line in order to work.\n\
3194 See also `overlay-arrow-string'.");
3195 Voverlay_arrow_position
= Qnil
;
3197 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
3198 "String to display as an arrow. See also `overlay-arrow-position'.");
3199 Voverlay_arrow_string
= Qnil
;
3201 DEFVAR_INT ("scroll-step", &scroll_step
,
3202 "*The number of lines to try scrolling a window by when point moves out.\n\
3203 If that fails to bring point back on frame, point is centered instead.\n\
3204 If this is zero, point is always centered after it moves off frame.");
3206 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
3208 DEFVAR_BOOL ("truncate-partial-width-windows",
3209 &truncate_partial_width_windows
,
3210 "*Non-nil means truncate lines in all windows less than full frame wide.");
3211 truncate_partial_width_windows
= 1;
3213 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
3214 "*Non-nil means use inverse video for the mode line.");
3215 mode_line_inverse_video
= 1;
3217 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
3218 "*Maximum buffer size for which line number should be displayed.");
3219 line_number_display_limit
= 1000000;
3221 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
3222 "*Non-nil means highlight region even in nonselected windows.");
3223 highlight_nonselected_windows
= 1;
3226 /* initialize the window system */
3229 Lisp_Object root_window
;
3230 #ifndef COMPILER_REGISTER_BUG
3232 #endif /* COMPILER_REGISTER_BUG */
3233 struct window
*mini_w
;
3235 this_line_bufpos
= 0;
3237 mini_w
= XWINDOW (minibuf_window
);
3238 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
3240 echo_area_glyphs
= 0;
3241 previous_echo_glyphs
= 0;
3243 if (!noninteractive
)
3245 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
3246 XFASTINT (XWINDOW (root_window
)->top
) = 0;
3247 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
3248 XFASTINT (mini_w
->top
) = FRAME_HEIGHT (f
) - 1;
3249 set_window_height (minibuf_window
, 1, 0);
3251 XFASTINT (XWINDOW (root_window
)->width
) = FRAME_WIDTH (f
);
3252 XFASTINT (mini_w
->width
) = FRAME_WIDTH (f
);