1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993 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"
38 extern int interrupt_input
;
39 extern int command_loop_level
;
41 /* Nonzero means print newline before next minibuffer message. */
43 int noninteractive_need_newline
;
45 #define min(a, b) ((a) < (b) ? (a) : (b))
46 #define max(a, b) ((a) > (b) ? (a) : (b))
48 /* The buffer position of the first character appearing
49 entirely or partially on the current frame line.
50 Or zero, which disables the optimization for the current frame line. */
51 static int this_line_bufpos
;
53 /* Number of characters past the end of this line,
54 including the terminating newline */
55 static int this_line_endpos
;
57 /* The vertical position of this frame line. */
58 static int this_line_vpos
;
60 /* Hpos value for start of display on this frame line.
61 Usually zero, but negative if first character really began
63 static int this_line_start_hpos
;
65 /* Buffer that this_line variables are describing. */
66 static struct buffer
*this_line_buffer
;
68 /* Set by try_window_id to the vpos of first of any lines
69 scrolled on to the bottom of the frame. These lines should
70 not be included in any general scroll computation. */
71 static int scroll_bottom_vpos
;
73 /* Value of echo_area_glyphs when it was last acted on.
74 If this is nonzero, there is a message on the frame
75 in the minibuffer and it should be erased as soon
76 as it is no longer requested to appear. */
77 char *previous_echo_glyphs
;
79 /* Nonzero means truncate lines in all windows less wide than the frame */
80 int truncate_partial_width_windows
;
82 Lisp_Object Vglobal_mode_string
;
84 /* Marker for where to display an arrow on top of the buffer text. */
85 Lisp_Object Voverlay_arrow_position
;
87 /* String to display for the arrow. */
88 Lisp_Object Voverlay_arrow_string
;
90 /* Values of those variables at last redisplay. */
91 static Lisp_Object last_arrow_position
, last_arrow_string
;
93 /* Nonzero if overlay arrow has been displayed once in this window. */
94 static int overlay_arrow_seen
;
96 /* Nonzero means highlight the region even in nonselected windows. */
97 static int highlight_nonselected_windows
;
99 /* If cursor motion alone moves point off frame,
100 Try scrolling this many lines up or down if that will bring it back. */
103 /* Nonzero if try_window_id has made blank lines at window bottom
104 since the last redisplay that paused */
105 static int blank_end_of_window
;
107 /* Number of windows showing the buffer of the selected window.
108 keyboard.c refers to this. */
111 /* display_text_line sets these to the frame position (origin 0) of point,
112 whether the window is selected or not.
113 Set one to -1 first to determine whether point was found afterwards. */
115 static int cursor_vpos
;
116 static int cursor_hpos
;
120 /* Nonzero means display mode line highlighted */
121 int mode_line_inverse_video
;
123 static void echo_area_display ();
124 void mark_window_display_accurate ();
125 static void redisplay_windows ();
126 static void redisplay_window ();
127 static void update_menu_bars ();
128 static void update_menu_bar ();
129 static void try_window ();
130 static int try_window_id ();
131 static struct position
*display_text_line ();
132 static void display_mode_line ();
133 static int display_mode_element ();
134 static char *fmodetrunc ();
135 static char *decode_mode_spec ();
136 static int display_string ();
137 static void display_menu_bar ();
138 static int display_count_lines ();
140 /* Prompt to display in front of the minibuffer contents */
141 char *minibuf_prompt
;
143 /* Width in columns of current minibuffer prompt. */
144 int minibuf_prompt_width
;
146 /* Message to display instead of minibuffer contents
147 This is what the functions error and message make,
148 and command echoing uses it as well.
149 It overrides the minibuf_prompt as well as the buffer. */
150 char *echo_area_glyphs
;
152 /* This is the length of the message in echo_area_glyphs. */
153 int echo_area_glyphs_length
;
155 /* true iff we should redraw the mode lines on the next redisplay */
156 int update_mode_lines
;
158 /* Smallest number of characters before the gap
159 at any time since last redisplay that finished.
160 Valid for current buffer when try_window_id can be called. */
163 /* Smallest number of characters after the gap
164 at any time since last redisplay that finished.
165 Valid for current buffer when try_window_id can be called. */
168 /* MODIFF as of last redisplay that finished;
169 if it matches MODIFF, beg_unchanged and end_unchanged
170 contain no useful information */
171 int unchanged_modified
;
173 /* Nonzero if head_clip or tail_clip of current buffer has changed
174 since last redisplay that finished */
177 /* Nonzero if window sizes or contents have changed
178 since last redisplay that finished */
179 int windows_or_buffers_changed
;
181 /* Nonzero after display_mode_line if %l was used
182 and it displayed a line number. */
183 int line_number_displayed
;
185 /* Maximum buffer size for which to display line numbers. */
186 int line_number_display_limit
;
188 /* Specify m, a string, as a message in the minibuf. If m is 0, clear out
189 any existing message, and let the minibuffer text show through. */
197 if (noninteractive_need_newline
)
199 noninteractive_need_newline
= 0;
200 if (cursor_in_echo_area
!= 0)
201 fprintf (stderr
, "%s", m
);
203 fprintf (stderr
, "%s\n", m
);
206 /* A null message buffer means that the frame hasn't really been
207 initialized yet. Error messages get reported properly by
208 cmd_error, so this must be just an informative message; toss it. */
209 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
212 Lisp_Object minibuf_frame
;
214 choose_minibuf_frame ();
215 minibuf_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
216 FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame
));
217 if (FRAME_VISIBLE_P (selected_frame
)
218 && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame
)))
219 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window
)));
224 echo_area_glyphs
= m
;
225 echo_area_glyphs_length
= strlen (m
);
228 echo_area_glyphs
= previous_echo_glyphs
= 0;
230 do_pending_window_change ();
231 echo_area_display ();
232 update_frame (XFRAME (XWINDOW (minibuf_window
)->frame
), 1, 1);
233 do_pending_window_change ();
237 /* Display an echo area message M with a specified length of LEN chars.
238 This way, null characters can be included. */
247 if (noninteractive_need_newline
)
249 noninteractive_need_newline
= 0;
250 fwrite (m
, len
, 1, stderr
);
251 if (cursor_in_echo_area
== 0)
252 fprintf (stderr
, "\n");
255 /* A null message buffer means that the frame hasn't really been
256 initialized yet. Error messages get reported properly by
257 cmd_error, so this must be just an informative message; toss it. */
258 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
261 Lisp_Object minibuf_frame
;
263 choose_minibuf_frame ();
264 minibuf_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
265 FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame
));
266 if (FRAME_VISIBLE_P (selected_frame
)
267 && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame
)))
268 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window
)));
273 echo_area_glyphs
= m
;
274 echo_area_glyphs_length
= len
;
277 echo_area_glyphs
= previous_echo_glyphs
= 0;
279 do_pending_window_change ();
280 echo_area_display ();
281 update_frame (XFRAME (XWINDOW (minibuf_window
)->frame
), 1, 1);
282 do_pending_window_change ();
286 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
287 zero if being used by message. */
288 int message_buf_print
;
290 /* Dump an informative message to the minibuf. If m is 0, clear out
291 any existing message, and let the minibuffer text show through. */
294 message (m
, a1
, a2
, a3
)
301 if (noninteractive_need_newline
)
303 noninteractive_need_newline
= 0;
304 fprintf (stderr
, m
, a1
, a2
, a3
);
305 if (cursor_in_echo_area
== 0)
306 fprintf (stderr
, "\n");
310 else if (INTERACTIVE
)
312 /* The frame whose minibuffer we're going to display the message on.
313 It may be larger than the selected frame, so we need
314 to use its buffer, not the selected frame's buffer. */
315 FRAME_PTR echo_frame
;
317 choose_minibuf_frame ();
318 echo_frame
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
320 echo_frame
= selected_frame
;
323 /* A null message buffer means that the frame hasn't really been
324 initialized yet. Error messages get reported properly by
325 cmd_error, so this must be just an informative message; toss it. */
326 if (FRAME_MESSAGE_BUF (echo_frame
))
337 len
= doprnt (FRAME_MESSAGE_BUF (echo_frame
),
338 FRAME_WIDTH (echo_frame
), m
, 0, 3, a
);
340 len
= doprnt (FRAME_MESSAGE_BUF (echo_frame
),
341 FRAME_WIDTH (echo_frame
), m
, 0, 3, &a1
);
342 #endif /* NO_ARG_ARRAY */
344 message2 (FRAME_MESSAGE_BUF (echo_frame
), len
);
349 /* Print should start at the beginning of the message
351 message_buf_print
= 0;
363 choose_minibuf_frame ();
366 f
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
368 if (! FRAME_VISIBLE_P (f
))
373 redraw_garbaged_frames ();
377 if (echo_area_glyphs
|| minibuf_level
== 0)
379 vpos
= XFASTINT (XWINDOW (minibuf_window
)->top
);
380 get_display_line (f
, vpos
, 0);
381 display_string (XWINDOW (minibuf_window
), vpos
,
382 echo_area_glyphs
? echo_area_glyphs
: "",
383 echo_area_glyphs
? echo_area_glyphs_length
: -1,
384 0, 0, 0, FRAME_WIDTH (f
));
386 /* If desired cursor location is on this line, put it at end of text */
387 if (FRAME_CURSOR_Y (f
) == vpos
)
388 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
390 /* Fill the rest of the minibuffer window with blank lines. */
395 i
< vpos
+ XFASTINT (XWINDOW (minibuf_window
)->height
); i
++)
397 get_display_line (f
, i
, 0);
398 display_string (XWINDOW (minibuf_window
), vpos
,
399 "", 0, 0, 0, 0, FRAME_WIDTH (f
));
403 else if (!EQ (minibuf_window
, selected_window
))
404 windows_or_buffers_changed
++;
406 if (EQ (minibuf_window
, selected_window
))
407 this_line_bufpos
= 0;
409 previous_echo_glyphs
= echo_area_glyphs
;
412 /* Prepare for redisplay by updating menu-bar item lists when appropriate.
413 This can't be done in `redisplay' itself because it can call eval. */
418 register struct window
*w
= XWINDOW (selected_window
);
424 /* Set the visible flags for all frames.
425 Do this before checking for resized or garbaged frames; they want
426 to know if their frames are visible.
427 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
429 Lisp_Object tail
, frame
;
431 FOR_EACH_FRAME (tail
, frame
)
432 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
435 /* Notice any pending interrupt request to change frame size. */
436 do_pending_window_change ();
440 redraw_garbaged_frames ();
444 if (clip_changed
|| windows_or_buffers_changed
)
447 /* Detect case that we need to write a star in the mode line. */
448 if (XFASTINT (w
->last_modified
) < MODIFF
449 && XFASTINT (w
->last_modified
) <= current_buffer
->save_modified
)
451 w
->update_mode_line
= Qt
;
452 if (buffer_shared
> 1)
456 all_windows
= update_mode_lines
|| buffer_shared
> 1;
458 /* If specs for an arrow have changed, do thorough redisplay
459 to ensure we remove any arrow that should no longer exist. */
460 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
461 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
462 all_windows
= 1, clip_changed
= 1;
464 /* Update the menu bar item lists, if appropriate.
465 This has to be done before any actual redisplay
466 or generation of display lines. */
469 Lisp_Object tail
, frame
;
471 FOR_EACH_FRAME (tail
, frame
)
473 FRAME_PTR f
= XFRAME (frame
);
475 if (FRAME_VISIBLE_P (f
))
476 update_menu_bars (FRAME_ROOT_WINDOW (f
));
479 else if (FRAME_VISIBLE_P (selected_frame
))
480 update_menu_bar (selected_window
);
483 /* Do a frame update, taking possible shortcuts into account.
484 This is the main external entry point for redisplay.
486 If the last redisplay displayed an echo area message and that
487 message is no longer requested, we clear the echo area
488 or bring back the minibuffer if that is in use.
490 Do not call eval from within this function.
491 Calls to eval after the call to echo_area_display would confuse
492 the display_line mechanism and would cause a crash.
493 Calls to eval before that point will work most of the time,
494 but can still lose, because this function
495 can be called from signal handlers; with alarms set up;
496 or with synchronous processes running.
498 See Fcall_process; if you called it from here, it could be
499 entered recursively. */
504 register struct window
*w
= XWINDOW (selected_window
);
508 register int tlbufpos
, tlendpos
;
510 extern int input_pending
;
515 /* Set the visible flags for all frames.
516 Do this before checking for resized or garbaged frames; they want
517 to know if their frames are visible.
518 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
520 Lisp_Object tail
, frame
;
522 FOR_EACH_FRAME (tail
, frame
)
523 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
526 /* Notice any pending interrupt request to change frame size. */
527 do_pending_window_change ();
531 redraw_garbaged_frames ();
535 if (clip_changed
|| windows_or_buffers_changed
)
538 /* Detect case that we need to write a star in the mode line. */
539 if (XFASTINT (w
->last_modified
) < MODIFF
540 && XFASTINT (w
->last_modified
) <= current_buffer
->save_modified
)
542 w
->update_mode_line
= Qt
;
543 if (buffer_shared
> 1)
547 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
549 all_windows
= update_mode_lines
|| buffer_shared
> 1;
551 /* If specs for an arrow have changed, do thorough redisplay
552 to ensure we remove any arrow that should no longer exist. */
553 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
554 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
555 all_windows
= 1, clip_changed
= 1;
557 /* Normally the message* functions will have already displayed and
558 updated the echo area, but the frame may have been trashed, or
559 the update may have been preempted, so display the echo area
561 if (echo_area_glyphs
|| previous_echo_glyphs
)
563 echo_area_display ();
567 /* If showing region, and mark has changed, must redisplay whole window. */
568 if (((!NILP (Vtransient_mark_mode
)
569 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
570 != !NILP (w
->region_showing
))
571 || (!NILP (w
->region_showing
)
572 && !EQ (w
->region_showing
,
573 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
574 this_line_bufpos
= -1;
576 tlbufpos
= this_line_bufpos
;
577 tlendpos
= this_line_endpos
;
578 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
579 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
580 /* Make sure recorded data applies to current buffer, etc */
581 && this_line_buffer
== current_buffer
582 && current_buffer
== XBUFFER (w
->buffer
)
583 && NILP (w
->force_start
)
584 /* Point must be on the line that we have info recorded about */
586 && point
<= Z
- tlendpos
587 /* All text outside that line, including its final newline,
589 && (XFASTINT (w
->last_modified
) >= MODIFF
590 || (beg_unchanged
>= tlbufpos
- 1
592 /* If selective display, can't optimize
593 if the changes start at the beginning of the line. */
594 && ((XTYPE (current_buffer
->selective_display
) == Lisp_Int
595 && XINT (current_buffer
->selective_display
) > 0
596 ? (beg_unchanged
>= tlbufpos
599 && end_unchanged
>= tlendpos
600 && Z
- GPT
>= tlendpos
)))
602 if (tlbufpos
> BEGV
&& FETCH_CHAR (tlbufpos
- 1) != '\n'
604 || FETCH_CHAR (tlbufpos
) == '\n'))
605 /* Former continuation line has disappeared by becoming empty */
607 else if (XFASTINT (w
->last_modified
) < MODIFF
608 || MINI_WINDOW_P (w
))
611 overlay_arrow_seen
= 0;
612 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
613 pos_tab_offset (w
, tlbufpos
));
614 /* If line contains point, is not continued,
615 and ends at same distance from eob as before, we win */
616 if (cursor_vpos
>= 0 && this_line_bufpos
617 && this_line_endpos
== tlendpos
)
619 if (XFASTINT (w
->width
) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w
))))
620 preserve_other_columns (w
);
626 else if (point
== XFASTINT (w
->last_point
))
630 do_pending_window_change ();
635 /* If highlighting the region, we can't just move the cursor. */
636 else if (! (!NILP (Vtransient_mark_mode
)
637 && !NILP (current_buffer
->mark_active
))
638 && NILP (w
->region_showing
))
640 pos
= *compute_motion (tlbufpos
, 0,
641 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
642 point
, 2, - (1 << (SHORTBITS
- 1)),
643 window_internal_width (w
) - 1,
645 pos_tab_offset (w
, tlbufpos
));
648 FRAME_CURSOR_X (selected_frame
)
649 = XFASTINT (w
->left
) + max (pos
.hpos
, 0);
650 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
657 /* Text changed drastically or point moved off of line */
658 cancel_line (this_line_vpos
, selected_frame
);
661 this_line_bufpos
= 0;
662 all_windows
|= buffer_shared
> 1;
666 Lisp_Object tail
, frame
;
668 #ifdef HAVE_X_WINDOWS
669 /* Since we're doing a thorough redisplay, we might as well
670 recompute all our display faces. */
671 clear_face_vector ();
674 /* Recompute # windows showing selected buffer.
675 This will be incremented each time such a window is displayed. */
678 FOR_EACH_FRAME (tail
, frame
)
680 FRAME_PTR f
= XFRAME (frame
);
682 /* Mark all the scroll bars to be removed; we'll redeem the ones
683 we want when we redisplay their windows. */
684 if (condemn_scroll_bars_hook
)
685 (*condemn_scroll_bars_hook
) (f
);
687 if (FRAME_VISIBLE_P (f
))
688 redisplay_windows (FRAME_ROOT_WINDOW (f
));
690 /* Any scroll bars which redisplay_windows should have nuked
691 should now go away. */
692 if (judge_scroll_bars_hook
)
693 (*judge_scroll_bars_hook
) (f
);
696 else if (FRAME_VISIBLE_P (selected_frame
))
698 redisplay_window (selected_window
, 1);
699 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
700 preserve_other_columns (w
);
704 /* Prevent various kinds of signals during display update.
705 stdio is not robust about handling signals,
706 which can cause an apparent I/O error. */
718 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
722 if (XTYPE (XCONS (tail
)->car
) != Lisp_Frame
)
725 f
= XFRAME (XCONS (tail
)->car
);
726 if (FRAME_VISIBLE_P (f
))
728 pause
|= update_frame (f
, 0, 0);
730 mark_window_display_accurate (f
->root_window
, 1);
735 #endif /* MULTI_FRAME */
737 if (FRAME_VISIBLE_P (selected_frame
))
738 pause
= update_frame (selected_frame
, 0, 0);
740 /* We may have called echo_area_display at the top of this
741 function. If the echo area is on another frame, that may
742 have put text on a frame other than the selected one, so the
743 above call to update_frame would not have caught it. Catch
746 FRAME_PTR mini_frame
=
747 XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
749 if (mini_frame
!= selected_frame
)
750 pause
|= update_frame (mini_frame
, 0, 0);
754 /* If frame does not match, prevent doing single-line-update next time.
755 Also, don't forget to check every line to update the arrow. */
758 this_line_bufpos
= 0;
759 if (!NILP (last_arrow_position
))
761 last_arrow_position
= Qt
;
762 last_arrow_string
= Qt
;
764 /* If we pause after scrolling, some lines in current_frame
765 may be null, so preserve_other_columns won't be able to
766 preserve all the vertical-bar separators. So, avoid using it
768 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
769 update_mode_lines
= 1;
772 /* Now text on frame agrees with windows, so
773 put info into the windows for partial redisplay to follow */
777 register struct buffer
*b
= XBUFFER (w
->buffer
);
779 blank_end_of_window
= 0;
781 unchanged_modified
= BUF_MODIFF (b
);
782 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
783 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
785 XFASTINT (w
->last_point
) = BUF_PT (b
);
786 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (selected_frame
);
787 XFASTINT (w
->last_point_y
) = FRAME_CURSOR_Y (selected_frame
);
790 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
793 w
->update_mode_line
= Qnil
;
794 XFASTINT (w
->last_modified
) = BUF_MODIFF (b
);
795 w
->window_end_valid
= Qt
;
796 last_arrow_position
= Voverlay_arrow_position
;
797 last_arrow_string
= Voverlay_arrow_string
;
799 update_mode_lines
= 0;
800 windows_or_buffers_changed
= 0;
803 /* Start SIGIO interrupts coming again.
804 Having them off during the code above
805 makes it less likely one will discard output,
806 but not impossible, since there might be stuff
807 in the system buffer here.
808 But it is much hairier to try to do anything about that. */
814 /* Change frame size now if a change is pending. */
815 do_pending_window_change ();
818 /* Redisplay, but leave alone any recent echo area message
819 unless another message has been requested in its place.
821 This is useful in situations where you need to redisplay but no
822 user action has occurred, making it inappropriate for the message
823 area to be cleared. See tracking_off and
824 wait_reading_process_input for examples of these situations. */
826 redisplay_preserve_echo_area ()
828 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
830 echo_area_glyphs
= previous_echo_glyphs
;
832 echo_area_glyphs
= 0;
839 mark_window_display_accurate (window
, flag
)
843 register struct window
*w
;
845 for (;!NILP (window
); window
= w
->next
)
847 if (XTYPE (window
) != Lisp_Window
) abort ();
848 w
= XWINDOW (window
);
850 if (!NILP (w
->buffer
))
852 XFASTINT (w
->last_modified
)
854 : XBUFFER (w
->buffer
) == current_buffer
855 ? MODIFF
: BUF_MODIFF (XBUFFER (w
->buffer
));
857 /* Record if we are showing a region, so can make sure to
858 update it fully at next redisplay. */
859 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
860 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
861 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
865 w
->window_end_valid
= Qt
;
866 w
->update_mode_line
= Qnil
;
868 if (!NILP (w
->vchild
))
869 mark_window_display_accurate (w
->vchild
, flag
);
870 if (!NILP (w
->hchild
))
871 mark_window_display_accurate (w
->hchild
, flag
);
876 last_arrow_position
= Voverlay_arrow_position
;
877 last_arrow_string
= Voverlay_arrow_string
;
881 /* t is unequal to any useful value of Voverlay_arrow_... */
882 last_arrow_position
= Qt
;
883 last_arrow_string
= Qt
;
887 /* Update the menu bar item lists for WINDOW
888 and its subwindows and siblings.
889 This has to be done before we start to fill in any display lines,
890 because it can call eval. */
893 update_menu_bars (window
)
896 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
897 update_menu_bar (window
, 0);
900 /* Update the menu bar item list for window WINDOW and its subwindows. */
903 update_menu_bar (window
, just_this_one
)
907 register struct window
*w
= XWINDOW (window
);
908 struct buffer
*old
= current_buffer
;
909 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
911 /* If this is a combination window, do its children; that's all. */
913 if (!NILP (w
->vchild
))
915 update_menu_bars (w
->vchild
);
918 if (!NILP (w
->hchild
))
920 update_menu_bars (w
->hchild
);
923 if (NILP (w
->buffer
))
926 if (update_mode_lines
)
927 w
->update_mode_line
= Qt
;
929 /* When we reach a frame's selected window, redo the frame's menu bar. */
930 if (!NILP (w
->update_mode_line
)
931 && FRAME_MENU_BAR_LINES (f
) > 0
932 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
934 /* If the user has switched buffers or windows, we need to
935 recompute to reflect the new bindings. But we'll
936 recompute when update_mode_lines is set too; that means
937 that people can use force-mode-line-update to request
938 that the menu bar be recomputed. The adverse effect on
939 the rest of the redisplay algorithm is about the same as
940 windows_or_buffers_changed anyway. */
941 if (windows_or_buffers_changed
943 || (XFASTINT (w
->last_modified
) < MODIFF
944 && (XFASTINT (w
->last_modified
)
945 <= XBUFFER (w
->buffer
)->save_modified
)))
947 struct buffer
*prev
= current_buffer
;
948 current_buffer
= XBUFFER (w
->buffer
);
949 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items ();
950 current_buffer
= prev
;
957 /* Redisplay WINDOW and its subwindows and siblings. */
960 redisplay_windows (window
)
963 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
964 redisplay_window (window
, 0);
967 /* Redisplay window WINDOW and its subwindows. */
970 redisplay_window (window
, just_this_one
)
974 register struct window
*w
= XWINDOW (window
);
975 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
977 register int lpoint
= point
;
978 struct buffer
*old
= current_buffer
;
979 register int width
= window_internal_width (w
) - 1;
981 register int hscroll
= XINT (w
->hscroll
);
985 int window_needs_modeline
;
987 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
989 /* If this is a combination window, do its children; that's all. */
991 if (!NILP (w
->vchild
))
993 redisplay_windows (w
->vchild
);
996 if (!NILP (w
->hchild
))
998 redisplay_windows (w
->hchild
);
1001 if (NILP (w
->buffer
))
1004 height
= window_internal_height (w
);
1006 if (MINI_WINDOW_P (w
))
1008 if (w
== XWINDOW (minibuf_window
))
1010 if (echo_area_glyphs
)
1011 /* We've already displayed the echo area glyphs, if any. */
1012 goto finish_scroll_bars
;
1016 /* This is a minibuffer, but it's not the currently active one, so
1018 int vpos
= XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1021 for (i
= 0; i
< height
; i
++)
1023 get_display_line (f
, vpos
+ i
, 0);
1024 display_string (w
, vpos
+ i
, "", 0, 0, 0, 0, width
);
1027 goto finish_scroll_bars
;
1031 if (update_mode_lines
)
1032 w
->update_mode_line
= Qt
;
1034 /* Otherwise set up data on this window; select its buffer and point value */
1036 current_buffer
= XBUFFER (w
->buffer
);
1039 /* Count number of windows showing the selected buffer. */
1042 && current_buffer
== XBUFFER (XWINDOW (selected_window
)->buffer
))
1045 /* POINT refers normally to the selected window.
1046 For any other window, set up appropriate value. */
1048 if (!EQ (window
, selected_window
))
1050 SET_PT (marker_position (w
->pointm
));
1054 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
1056 else if (point
> (ZV
- 1))
1059 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
1063 /* If window-start is screwed up, choose a new one. */
1064 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
1067 startp
= marker_position (w
->start
);
1069 /* Handle case where place to start displaying has been specified,
1070 unless the specified location is outside the accessible range. */
1071 if (!NILP (w
->force_start
))
1073 /* Forget any recorded base line for line number display. */
1074 w
->base_line_number
= Qnil
;
1075 w
->update_mode_line
= Qt
;
1076 w
->force_start
= Qnil
;
1077 XFASTINT (w
->last_modified
) = 0;
1078 if (startp
< BEGV
) startp
= BEGV
;
1079 if (startp
> ZV
) startp
= ZV
;
1080 try_window (window
, startp
);
1081 if (cursor_vpos
< 0)
1083 /* ??? What should happen here if highlighting a region? */
1084 /* If point does not appear, move point so it does appear */
1085 pos
= *compute_motion (startp
, 0,
1086 ((EQ (window
, minibuf_window
) && startp
== 1)
1087 ? minibuf_prompt_width
: 0)
1089 (hscroll
? 1 - hscroll
: 0),
1091 - (1 << (SHORTBITS
- 1)),
1092 width
, hscroll
, pos_tab_offset (w
, startp
));
1093 SET_PT (pos
.bufpos
);
1094 if (w
!= XWINDOW (selected_window
))
1095 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
1098 if (current_buffer
== old
)
1100 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
1101 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1107 /* Handle case where text has not changed, only point,
1108 and it has not moved off the frame */
1110 /* This code is not used for minibuffer for the sake of
1111 the case of redisplaying to replace an echo area message;
1112 since in that case the minibuffer contents per se are usually unchanged.
1113 This code is of no real use in the minibuffer since
1114 the handling of this_line_bufpos, etc.,
1115 in redisplay handles the same cases. */
1117 if (XFASTINT (w
->last_modified
) >= MODIFF
1118 && point
>= startp
&& !clip_changed
1119 && (just_this_one
|| XFASTINT (w
->width
) == FRAME_WIDTH (f
))
1120 /* Can't use this case if highlighting a region. */
1121 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1122 && NILP (w
->region_showing
)
1123 && !EQ (window
, minibuf_window
))
1125 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0),
1126 point
, height
+ 1, 10000, width
, hscroll
,
1127 pos_tab_offset (w
, startp
));
1129 if (pos
.vpos
< height
)
1131 /* Ok, point is still on frame */
1132 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
1134 /* These variables are supposed to be origin 1 */
1135 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
1136 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1138 /* This doesn't do the trick, because if a window to the right of
1139 this one must be redisplayed, this does nothing because there
1140 is nothing in DesiredFrame yet, and then the other window is
1141 redisplayed, making likes that are empty in this window's columns.
1142 if (XFASTINT (w->width) != FRAME_WIDTH (f))
1143 preserve_my_columns (w);
1147 /* Don't bother trying redisplay with same start;
1148 we already know it will lose */
1150 /* If current starting point was originally the beginning of a line
1151 but no longer is, find a new starting point. */
1152 else if (!NILP (w
->start_at_line_beg
)
1154 || FETCH_CHAR (startp
- 1) == '\n'))
1158 else if (just_this_one
&& !MINI_WINDOW_P (w
)
1160 && XFASTINT (w
->last_modified
)
1161 /* or else vmotion on first line won't work. */
1162 && ! NILP (w
->start_at_line_beg
)
1163 && ! EQ (w
->window_end_valid
, Qnil
)
1164 && do_id
&& !clip_changed
1165 && !blank_end_of_window
1166 && XFASTINT (w
->width
) == FRAME_WIDTH (f
)
1167 /* Can't use this case if highlighting a region. */
1168 && !(!NILP (Vtransient_mark_mode
)
1169 && !NILP (current_buffer
->mark_active
))
1170 && NILP (w
->region_showing
)
1171 && EQ (last_arrow_position
, Voverlay_arrow_position
)
1172 && EQ (last_arrow_string
, Voverlay_arrow_string
)
1173 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
1176 /* tem > 0 means success. tem == -1 means choose new start.
1177 tem == -2 means try again with same start,
1178 and nothing but whitespace follows the changed stuff.
1179 tem == 0 means try again with same start. */
1183 else if (startp
>= BEGV
&& startp
<= ZV
1184 /* Avoid starting display at end of buffer! */
1185 && (startp
< ZV
|| startp
== BEGV
1186 || (XFASTINT (w
->last_modified
) >= MODIFF
)))
1188 /* Try to redisplay starting at same place as before */
1189 /* If point has not moved off frame, accept the results */
1190 try_window (window
, startp
);
1191 if (cursor_vpos
>= 0)
1193 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1194 /* Forget any recorded base line for line number display. */
1195 w
->base_line_number
= Qnil
;
1199 cancel_my_columns (w
);
1202 XFASTINT (w
->last_modified
) = 0;
1203 w
->update_mode_line
= Qt
;
1205 /* Try to scroll by specified few lines */
1207 if (scroll_step
&& !clip_changed
)
1211 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1212 scroll_step
, width
, hscroll
, window
);
1213 if (pos
.vpos
>= height
)
1217 pos
= *vmotion (startp
, point
< startp
? - scroll_step
: scroll_step
,
1218 width
, hscroll
, window
);
1220 if (point
>= pos
.bufpos
)
1222 try_window (window
, pos
.bufpos
);
1223 if (cursor_vpos
>= 0)
1225 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1226 /* Forget any recorded base line for line number display. */
1227 w
->base_line_number
= Qnil
;
1231 cancel_my_columns (w
);
1236 /* Finally, just choose place to start which centers point */
1239 /* Forget any previously recorded base line for line number display. */
1240 w
->base_line_number
= Qnil
;
1242 pos
= *vmotion (point
, - height
/ 2, width
, hscroll
, window
);
1243 try_window (window
, pos
.bufpos
);
1245 startp
= marker_position (w
->start
);
1246 w
->start_at_line_beg
=
1247 (startp
== BEGV
|| FETCH_CHAR (startp
- 1) == '\n') ? Qt
: Qnil
;
1250 if ((!NILP (w
->update_mode_line
)
1251 /* If window not full width, must redo its mode line
1252 if the window to its side is being redone */
1253 || (!just_this_one
&& width
< FRAME_WIDTH (f
) - 1)
1254 || INTEGERP (w
->base_line_pos
))
1255 && height
!= XFASTINT (w
->height
))
1256 display_mode_line (w
);
1257 if (! line_number_displayed
1258 && ! BUFFERP (w
->base_line_pos
))
1260 w
->base_line_pos
= Qnil
;
1261 w
->base_line_number
= Qnil
;
1264 /* When we reach a frame's selected window, redo the frame's menu bar. */
1265 if (!NILP (w
->update_mode_line
)
1266 && FRAME_MENU_BAR_LINES (f
) > 0
1267 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
1268 display_menu_bar (w
);
1271 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1273 int start
, end
, whole
;
1275 /* Calculate the start and end positions for the current window.
1276 At some point, it would be nice to choose between scrollbars
1277 which reflect the whole buffer size, with special markers
1278 indicating narrowing, and scrollbars which reflect only the
1281 Note that minibuffers sometimes aren't displaying any text. */
1282 if (! MINI_WINDOW_P (w
)
1283 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
1286 start
= startp
- BEGV
;
1287 /* I don't think this is guaranteed to be right. For the
1288 moment, we'll pretend it is. */
1289 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
1291 if (end
< start
) end
= start
;
1292 if (whole
< (end
- start
)) whole
= end
- start
;
1295 start
= end
= whole
= 0;
1297 /* Indicate what this scroll bar ought to be displaying now. */
1298 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
1300 /* Note that we actually used the scroll bar attached to this window,
1301 so it shouldn't be deleted at the end of redisplay. */
1302 (*redeem_scroll_bar_hook
) (w
);
1306 current_buffer
= old
;
1310 /* Do full redisplay on one window, starting at position `pos'. */
1313 try_window (window
, pos
)
1317 register struct window
*w
= XWINDOW (window
);
1318 register int height
= window_internal_height (w
);
1319 register int vpos
= XFASTINT (w
->top
);
1320 register int last_text_vpos
= vpos
;
1321 int tab_offset
= pos_tab_offset (w
, pos
);
1322 FRAME_PTR f
= XFRAME (w
->frame
);
1323 int width
= window_internal_width (w
) - 1;
1324 struct position val
;
1326 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1328 overlay_arrow_seen
= 0;
1329 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1331 while (--height
>= 0)
1333 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, tab_offset
);
1334 tab_offset
+= width
;
1335 if (val
.vpos
) tab_offset
= 0;
1337 if (pos
!= val
.bufpos
)
1339 /* Next line, unless prev line ended in end of buffer with no cr */
1340 = vpos
- (val
.vpos
&& (FETCH_CHAR (val
.bufpos
- 1) != '\n'
1341 || ! NILP (Fget_text_property (val
.bufpos
-1,
1343 Fcurrent_buffer ()))));
1347 /* If last line is continued in middle of character,
1348 include the split character in the text considered on the frame */
1349 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
1352 /* If bottom just moved off end of frame, change mode line percentage. */
1353 if (XFASTINT (w
->window_end_pos
) == 0
1355 w
->update_mode_line
= Qt
;
1357 /* Say where last char on frame will be, once redisplay is finished. */
1358 XFASTINT (w
->window_end_pos
) = Z
- pos
;
1359 XFASTINT (w
->window_end_vpos
) = last_text_vpos
- XFASTINT (w
->top
);
1360 /* But that is not valid info until redisplay finishes. */
1361 w
->window_end_valid
= Qnil
;
1364 /* Try to redisplay when buffer is modified locally,
1365 computing insert/delete line to preserve text outside
1366 the bounds of the changes.
1367 Return 1 if successful, 0 if if cannot tell what to do,
1368 or -1 to tell caller to find a new window start,
1369 or -2 to tell caller to do normal redisplay with same window start. */
1372 try_window_id (window
)
1376 register struct window
*w
= XWINDOW (window
);
1377 register int height
= window_internal_height (w
);
1378 FRAME_PTR f
= XFRAME (w
->frame
);
1379 int top
= XFASTINT (w
->top
);
1380 int start
= marker_position (w
->start
);
1381 int width
= window_internal_width (w
) - 1;
1382 int hscroll
= XINT (w
->hscroll
);
1383 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1385 register int i
, tem
;
1386 int last_text_vpos
= 0;
1389 struct position val
, bp
, ep
, xp
, pp
;
1390 int scroll_amount
= 0;
1392 int tab_offset
, epto
;
1394 if (GPT
- BEG
< beg_unchanged
)
1395 beg_unchanged
= GPT
- BEG
;
1396 if (Z
- GPT
< end_unchanged
)
1397 end_unchanged
= Z
- GPT
;
1399 if (beg_unchanged
+ 1 < start
)
1400 return 0; /* Give up if changes go above top of window */
1402 /* Find position before which nothing is changed. */
1403 bp
= *compute_motion (start
, 0, lmargin
,
1404 beg_unchanged
+ 1, height
+ 1, 0, width
, hscroll
,
1405 pos_tab_offset (w
, start
));
1406 if (bp
.vpos
>= height
)
1408 if (point
< bp
.bufpos
&& !bp
.contin
)
1410 /* All changes are below the frame, and point is on the frame.
1411 We don't need to change the frame at all.
1412 But we need to update window_end_pos to account for
1413 any change in buffer size. */
1414 bp
= *compute_motion (start
, 0, lmargin
,
1416 width
, hscroll
, pos_tab_offset (w
, start
));
1417 XFASTINT (w
->window_end_vpos
) = height
;
1418 XFASTINT (w
->window_end_pos
) = Z
- bp
.bufpos
;
1426 /* Find beginning of that frame line. Must display from there. */
1427 bp
= *vmotion (bp
.bufpos
, 0, width
, hscroll
, window
);
1434 /* If about to start displaying at the beginning of a continuation line,
1435 really start with previous frame line, in case it was not
1436 continued when last redisplayed */
1437 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
1439 /* Likewise if we have to worry about selective display. */
1440 (XTYPE (current_buffer
->selective_display
) == Lisp_Int
1441 && XINT (current_buffer
->selective_display
) > 0
1442 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
1444 bp
= *vmotion (bp
.bufpos
, -1, width
, hscroll
, window
);
1449 if (bp
.contin
&& bp
.hpos
!= lmargin
)
1451 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
1457 /* Find first visible newline after which no more is changed. */
1458 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
1459 if (XTYPE (current_buffer
->selective_display
) == Lisp_Int
1460 && XINT (current_buffer
->selective_display
) > 0)
1462 && (position_indentation (tem
)
1463 >= XINT (current_buffer
->selective_display
)))
1464 tem
= find_next_newline (tem
, 1);
1466 /* Compute the cursor position after that newline. */
1467 ep
= *compute_motion (pos
, vpos
, val
.hpos
, tem
,
1468 height
, - (1 << (SHORTBITS
- 1)),
1469 width
, hscroll
, pos_tab_offset (w
, bp
.bufpos
));
1471 /* If changes reach past the text available on the frame,
1472 just display rest of frame. */
1473 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
1476 stop_vpos
= ep
.vpos
;
1478 /* If no newline before ep, the line ep is on includes some changes
1479 that must be displayed. Make sure we don't stop before it. */
1480 /* Also, if changes reach all the way until ep.bufpos,
1481 it is possible that something was deleted after the
1482 newline before it, so the following line must be redrawn. */
1483 if (stop_vpos
== ep
.vpos
1484 && (ep
.bufpos
== BEGV
1485 || FETCH_CHAR (ep
.bufpos
- 1) != '\n'
1486 || ep
.bufpos
== Z
- end_unchanged
))
1487 stop_vpos
= ep
.vpos
+ 1;
1490 overlay_arrow_seen
= 0;
1492 /* If changes do not reach to bottom of window,
1493 figure out how much to scroll the rest of the window */
1494 if (stop_vpos
< height
)
1496 /* Now determine how far up or down the rest of the window has moved */
1497 epto
= pos_tab_offset (w
, ep
.bufpos
);
1498 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1499 Z
- XFASTINT (w
->window_end_pos
),
1500 10000, 0, width
, hscroll
, epto
);
1501 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
1503 /* Is everything on frame below the changes whitespace?
1504 If so, no scrolling is really necessary. */
1505 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
1507 tem
= FETCH_CHAR (i
);
1508 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
1514 XFASTINT (w
->window_end_vpos
) += scroll_amount
;
1516 /* Before doing any scrolling, verify that point will be on frame. */
1517 if (point
> ep
.bufpos
&& !(point
<= xp
.bufpos
&& xp
.bufpos
< height
))
1519 if (point
<= xp
.bufpos
)
1521 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1522 point
, height
, - (1 << (SHORTBITS
- 1)),
1523 width
, hscroll
, epto
);
1527 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
,
1528 point
, height
, - (1 << (SHORTBITS
- 1)),
1529 width
, hscroll
, pos_tab_offset (w
, xp
.bufpos
));
1531 if (pp
.bufpos
< point
|| pp
.vpos
== height
)
1533 cursor_vpos
= pp
.vpos
+ top
;
1534 cursor_hpos
= pp
.hpos
+ XFASTINT (w
->left
);
1537 if (stop_vpos
- scroll_amount
>= height
1538 || ep
.bufpos
== xp
.bufpos
)
1540 if (scroll_amount
< 0)
1541 stop_vpos
-= scroll_amount
;
1543 /* In this path, we have altered window_end_vpos
1544 and not left it negative.
1545 We must make sure that, in case display is preempted
1546 before the frame changes to reflect what we do here,
1547 further updates will not come to try_window_id
1548 and assume the frame and window_end_vpos match. */
1549 blank_end_of_window
= 1;
1551 else if (!scroll_amount
)
1553 else if (bp
.bufpos
== Z
- end_unchanged
)
1555 /* If reprinting everything is nearly as fast as scrolling,
1556 don't bother scrolling. Can happen if lines are short. */
1557 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
1558 top
+ height
- max (0, scroll_amount
),
1560 > xp
.bufpos
- bp
.bufpos
- 20)
1561 /* Return "try normal display with same window-start."
1562 Too bad we can't prevent further scroll-thinking. */
1564 /* If pure deletion, scroll up as many lines as possible.
1565 In common case of killing a line, this can save the
1566 following line from being overwritten by scrolling
1567 and therefore having to be redrawn. */
1568 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
1569 top
+ height
- max (0, scroll_amount
),
1571 if (!tem
) stop_vpos
= height
;
1573 else if (scroll_amount
)
1575 /* If reprinting everything is nearly as fast as scrolling,
1576 don't bother scrolling. Can happen if lines are short. */
1577 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
1578 overestimate of cost of reprinting, since xp.bufpos
1579 would end up below the bottom of the window. */
1580 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
1581 top
+ height
- max (0, scroll_amount
),
1583 > xp
.bufpos
- ep
.bufpos
- 20)
1584 /* Return "try normal display with same window-start."
1585 Too bad we can't prevent further scroll-thinking. */
1587 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
1588 top
+ height
- max (0, scroll_amount
),
1590 if (!tem
) stop_vpos
= height
;
1594 /* In any case, do not display past bottom of window */
1595 if (stop_vpos
>= height
)
1601 /* Handle case where pos is before w->start --
1602 can happen if part of line had been clipped and is not clipped now */
1603 if (vpos
== 0 && pos
< marker_position (w
->start
))
1604 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1606 /* Redisplay the lines where the text was changed */
1607 last_text_vpos
= vpos
;
1608 tab_offset
= pos_tab_offset (w
, pos
);
1609 /* If we are starting display in mid-character, correct tab_offset
1610 to account for passing the line that that character really starts in. */
1611 if (val
.hpos
< lmargin
)
1612 tab_offset
+= width
;
1613 while (vpos
< stop_vpos
)
1615 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1616 tab_offset
+= width
;
1617 if (val
.vpos
) tab_offset
= 0;
1618 if (pos
!= val
.bufpos
)
1620 /* Next line, unless prev line ended in end of buffer with no cr */
1621 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
1625 /* There are two cases:
1626 1) we have displayed down to the bottom of the window
1627 2) we have scrolled lines below stop_vpos by scroll_amount */
1631 /* If last line is continued in middle of character,
1632 include the split character in the text considered on the frame */
1633 if (val
.hpos
< lmargin
)
1635 XFASTINT (w
->window_end_vpos
) = last_text_vpos
;
1636 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1639 /* If scrolling made blank lines at window bottom,
1640 redisplay to fill those lines */
1641 if (scroll_amount
< 0)
1643 /* Don't consider these lines for general-purpose scrolling.
1644 That will save time in the scrolling computation. */
1645 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
1650 vpos
= height
+ scroll_amount
;
1651 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
1653 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
1657 blank_end_of_window
= 1;
1658 tab_offset
= pos_tab_offset (w
, pos
);
1659 /* If we are starting display in mid-character, correct tab_offset
1660 to account for passing the line that that character starts in. */
1661 if (val
.hpos
< lmargin
)
1662 tab_offset
+= width
;
1664 while (vpos
< height
)
1666 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1667 tab_offset
+= width
;
1668 if (val
.vpos
) tab_offset
= 0;
1672 /* Here is a case where display_text_line sets cursor_vpos wrong.
1673 Make it be fixed up, below. */
1675 && xp
.bufpos
== point
)
1679 /* If bottom just moved off end of frame, change mode line percentage. */
1680 if (XFASTINT (w
->window_end_pos
) == 0
1682 w
->update_mode_line
= Qt
;
1684 /* Attempt to adjust end-of-text positions to new bottom line */
1687 delta
= height
- xp
.vpos
;
1689 || (delta
> 0 && xp
.bufpos
<= ZV
)
1690 || (delta
== 0 && xp
.hpos
))
1692 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1693 delta
, width
, hscroll
, window
);
1694 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1695 XFASTINT (w
->window_end_vpos
) += val
.vpos
;
1699 w
->window_end_valid
= Qnil
;
1701 /* If point was not in a line that was displayed, find it */
1702 if (cursor_vpos
< 0)
1704 val
= *compute_motion (start
, 0, lmargin
, point
, 10000, 10000,
1705 width
, hscroll
, pos_tab_offset (w
, start
));
1706 /* Admit failure if point is off frame now */
1707 if (val
.vpos
>= height
)
1709 for (vpos
= 0; vpos
< height
; vpos
++)
1710 cancel_line (vpos
+ top
, f
);
1713 cursor_vpos
= val
.vpos
+ top
;
1714 cursor_hpos
= val
.hpos
+ XFASTINT (w
->left
);
1717 FRAME_CURSOR_X (f
) = max (0, cursor_hpos
);
1718 FRAME_CURSOR_Y (f
) = cursor_vpos
;
1722 val
= *compute_motion (start
, 0, lmargin
, ZV
,
1723 height
, - (1 << (SHORTBITS
- 1)),
1724 width
, hscroll
, pos_tab_offset (w
, start
));
1725 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
1727 if (XFASTINT (w
->window_end_pos
)
1735 /* Mark a section of BUF as modified, but only for the sake of redisplay.
1736 This is useful for recording changes to overlays.
1738 We increment the buffer's modification timestamp and set the
1739 redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
1740 as if the region of text between START and END had been modified;
1741 the redisplay code will check this against the windows' timestamps,
1742 and redraw the appropriate area of the buffer.
1744 However, if the buffer is unmodified, we bump the last-save
1745 timestamp as well, so that incrementing the timestamp doesn't fool
1746 Emacs into thinking that the buffer's text has been modified.
1748 Tweaking the timestamps shouldn't hurt the first-modification
1749 timestamps recorded in the undo records; those values aren't
1750 written until just before a real text modification is made, so they
1751 will never catch the timestamp value just before this function gets
1755 redisplay_region (buf
, start
, end
)
1765 start
= end
; end
= temp
;
1768 if (buf
!= current_buffer
)
1769 windows_or_buffers_changed
= 1;
1772 if (unchanged_modified
== MODIFF
)
1774 beg_unchanged
= start
- BEG
;
1775 end_unchanged
= Z
- end
;
1779 if (Z
- end
< end_unchanged
)
1780 end_unchanged
= Z
- end
;
1781 if (start
- BEG
< beg_unchanged
)
1782 beg_unchanged
= start
- BEG
;
1786 /* Increment the buffer's time stamp, but also increment the save
1787 and autosave timestamps, so as not to screw up that timekeeping. */
1788 if (BUF_MODIFF (buf
) == buf
->save_modified
)
1789 buf
->save_modified
++;
1790 if (BUF_MODIFF (buf
) == buf
->auto_save_modified
)
1791 buf
->auto_save_modified
++;
1793 BUF_MODIFF (buf
) ++;
1797 /* Copy glyphs from the vector FROM to the rope T.
1798 But don't actually copy the parts that would come in before S.
1799 Value is T, advanced past the copied data. */
1802 copy_rope (t
, s
, from
, face
)
1803 register GLYPH
*t
; /* Copy to here. */
1804 register GLYPH
*s
; /* Starting point. */
1805 Lisp_Object from
; /* Data to copy; known to be a vector. */
1806 int face
; /* Face to apply to glyphs which don't specify one. */
1808 register int n
= XVECTOR (from
)->size
;
1809 register Lisp_Object
*f
= XVECTOR (from
)->contents
;
1813 int glyph
= XFASTINT (*f
);
1815 if (t
>= s
) *t
= MAKE_GLYPH (GLYPH_CHAR (glyph
),
1817 ? GLYPH_FACE (glyph
)
1825 /* Copy exactly LEN glyphs from FROM into data at T.
1826 But don't alter words before S. */
1829 copy_part_of_rope (t
, s
, from
, len
, face
)
1830 register GLYPH
*t
; /* Copy to here. */
1831 register GLYPH
*s
; /* Starting point. */
1832 Lisp_Object
*from
; /* Data to copy. */
1834 int face
; /* Face to apply to glyphs which don't specify one. */
1837 register Lisp_Object
*f
= from
;
1841 int glyph
= XFASTINT (*f
);
1843 if (t
>= s
) *t
= MAKE_GLYPH (GLYPH_CHAR (glyph
),
1845 ? GLYPH_FACE (glyph
)
1853 /* Display one line of window w, starting at position START in W's buffer.
1854 Display starting at horizontal position HPOS, which is normally zero
1855 or negative. A negative value causes output up to hpos = 0 to be discarded.
1856 This is done for negative hscroll, or when this is a continuation line
1857 and the continuation occurred in the middle of a multi-column character.
1859 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
1861 Display on position VPOS on the frame. (origin 0).
1863 Returns a STRUCT POSITION giving character to start next line with
1864 and where to display it, including a zero or negative hpos.
1865 The vpos field is not really a vpos; it is 1 unless the line is continued */
1867 struct position val_display_text_line
;
1869 static struct position
*
1870 display_text_line (w
, start
, vpos
, hpos
, taboffset
)
1877 register int pos
= start
;
1882 register unsigned char *p
;
1884 register GLYPH
*startp
;
1885 register GLYPH
*p1prev
= 0;
1886 FRAME_PTR f
= XFRAME (w
->frame
);
1887 int tab_width
= XINT (current_buffer
->tab_width
);
1888 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1889 int width
= window_internal_width (w
) - 1;
1890 struct position val
;
1893 int hscroll
= XINT (w
->hscroll
);
1894 int truncate
= hscroll
1895 || (truncate_partial_width_windows
1896 && XFASTINT (w
->width
) < FRAME_WIDTH (f
))
1897 || !NILP (current_buffer
->truncate_lines
);
1899 /* 1 if we should highlight the region. */
1900 int highlight_region
1901 = !NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
);
1902 int region_beg
, region_end
;
1905 = XTYPE (current_buffer
->selective_display
) == Lisp_Int
1906 ? XINT (current_buffer
->selective_display
)
1907 : !NILP (current_buffer
->selective_display
) ? -1 : 0;
1908 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
1909 register struct Lisp_Vector
*dp
= window_display_table (w
);
1911 Lisp_Object default_invis_vector
[3];
1912 /* Nonzero means display something where there are invisible lines.
1913 The precise value is the number of glyphs to display. */
1915 = (selective
&& dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1916 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
1917 : selective
&& !NILP (current_buffer
->selective_display_ellipses
)
1919 /* This is the sequence of Lisp objects to display
1920 when there are invisible lines. */
1921 Lisp_Object
*invis_vector_contents
1922 = (dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1923 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
1924 : default_invis_vector
);
1926 GLYPH truncator
= (dp
== 0 || XTYPE (DISP_TRUNC_GLYPH (dp
)) != Lisp_Int
1927 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
1928 GLYPH continuer
= (dp
== 0 || XTYPE (DISP_CONTINUE_GLYPH (dp
)) != Lisp_Int
1929 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
1931 /* The next buffer location at which the face should change, due
1932 to overlays or text property changes. */
1933 int next_face_change
;
1935 #ifdef USE_TEXT_PROPERTIES
1936 /* The next location where the `invisible' property changes */
1940 /* The face we're currently using. */
1941 int current_face
= 0;
1943 XFASTINT (default_invis_vector
[2]) = '.';
1944 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
1946 hpos
+= XFASTINT (w
->left
);
1947 get_display_line (f
, vpos
, XFASTINT (w
->left
));
1948 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
1950 /* Show where to highlight the region. */
1951 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
1952 /* Maybe highlight only in selected window. */
1953 && (highlight_nonselected_windows
1954 || w
== XWINDOW (selected_window
)))
1956 region_beg
= marker_position (current_buffer
->mark
);
1957 if (PT
< region_beg
)
1959 region_end
= region_beg
;
1964 w
->region_showing
= Qt
;
1967 region_beg
= region_end
= -1;
1969 if (MINI_WINDOW_P (w
) && start
== 1
1970 && vpos
== XFASTINT (w
->top
))
1973 hpos
= display_string (w
, vpos
, minibuf_prompt
, -1, hpos
,
1974 (!truncate
? continuer
: truncator
),
1976 minibuf_prompt_width
= hpos
;
1979 desired_glyphs
->bufp
[vpos
] = pos
;
1980 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
1982 startp
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
1983 endp
= startp
+ width
;
1985 /* Arrange the overlays nicely for our purposes. Usually, we call
1986 display_text_line on only one line at a time, in which case this
1987 can't really hurt too much, or we call it on lines which appear
1988 one after another in the buffer, in which case all calls to
1989 recenter_overlay_lists but the first will be pretty cheap. */
1990 recenter_overlay_lists (current_buffer
, pos
);
1992 /* Loop generating characters.
1993 Stop at end of buffer, before newline,
1994 if reach or pass continuation column,
1995 or at face change. */
1997 next_face_change
= pos
;
1998 #ifdef USE_TEXT_PROPERTIES
1999 next_invisible
= pos
;
2006 /* Did we hit the end of the visible region of the buffer?
2011 /* Did we reach point? Record the cursor location. */
2012 if (pos
== point
&& cursor_vpos
< 0)
2015 cursor_hpos
= p1
- startp
;
2018 #ifdef USE_TEXT_PROPERTIES
2019 /* if the `invisible' property is set to t, we can skip to
2020 the next property change */
2021 while (pos
== next_invisible
&& pos
< end
)
2023 Lisp_Object position
, limit
, endpos
, prop
;
2024 XFASTINT (position
) = pos
;
2025 prop
= Fget_text_property (position
, Qinvisible
,
2026 Fcurrent_buffer ());
2027 /* This is just an estimate to give reasonable
2028 performance; nothing should go wrong if it is too small. */
2029 XFASTINT (limit
) = pos
+ 50;
2031 = Fnext_single_property_change (position
, Qinvisible
,
2032 Fcurrent_buffer (), limit
);
2033 if (INTEGERP (endpos
))
2034 next_invisible
= XINT (endpos
);
2036 next_invisible
= end
;
2039 if (pos
< point
&& next_invisible
>= point
)
2042 cursor_hpos
= p1
- startp
;
2044 pos
= next_invisible
;
2051 #ifdef HAVE_X_WINDOWS
2052 /* Did we hit a face change? Figure out what face we should
2053 use now. We also hit this the first time through the
2054 loop, to see what face we should start with. */
2055 if (pos
>= next_face_change
&& FRAME_X_P (f
))
2056 current_face
= compute_char_face (f
, w
, pos
,
2057 region_beg
, region_end
,
2058 &next_face_change
, pos
+ 50);
2063 #ifdef USE_TEXT_PROPERTIES
2064 if (pos
< next_invisible
&& next_invisible
< pause
)
2065 pause
= next_invisible
;
2067 if (pos
< next_face_change
&& next_face_change
< pause
)
2068 pause
= next_face_change
;
2070 /* Wouldn't you hate to read the next line to someone over
2072 if (pos
< point
&& point
< pause
)
2074 if (pos
< GPT
&& GPT
< pause
)
2077 p
= &FETCH_CHAR (pos
);
2080 if (c
>= 040 && c
< 0177
2081 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
2084 *p1
= MAKE_GLYPH (c
, current_face
);
2092 && position_indentation (pos
+ 1) >= selective
)
2095 pos
= find_next_newline (pos
+ 1, 1);
2096 if (FETCH_CHAR (pos
- 1) == '\n')
2099 if (invis
&& selective_rlen
> 0 && p1
>= startp
)
2101 p1
+= selective_rlen
;
2102 if (p1
- startp
> width
)
2104 copy_part_of_rope (p1prev
, p1prev
, invis_vector_contents
,
2105 (p1
- p1prev
), current_face
);
2108 /* Draw the face of the newline character as extending all the
2109 way to the end of the frame line. */
2112 *p1
++ = MAKE_GLYPH (' ', current_face
);
2120 if (p1
>= startp
&& p1
< endp
)
2121 *p1
= MAKE_GLYPH (' ', current_face
);
2124 while ((p1
- startp
+ taboffset
+ hscroll
- (hscroll
> 0))
2127 else if (c
== Ctl ('M') && selective
== -1)
2129 pos
= find_next_newline (pos
, 1);
2130 if (FETCH_CHAR (pos
- 1) == '\n')
2132 if (selective_rlen
> 0)
2134 p1
+= selective_rlen
;
2135 if (p1
- startp
> width
)
2137 copy_part_of_rope (p1prev
, p1prev
, invis_vector_contents
,
2138 (p1
- p1prev
), current_face
);
2141 /* Draw the face of the newline character as extending all the
2142 way to the end of the frame line. */
2145 *p1
++ = MAKE_GLYPH (' ', current_face
);
2149 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
2151 p1
= copy_rope (p1
, startp
, DISP_CHAR_VECTOR (dp
, c
), current_face
);
2153 else if (c
< 0200 && ctl_arrow
)
2156 *p1
= MAKE_GLYPH ((dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
2157 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
2160 if (p1
>= startp
&& p1
< endp
)
2161 *p1
= MAKE_GLYPH (c
^ 0100, current_face
);
2167 *p1
= MAKE_GLYPH ((dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
2168 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
2171 if (p1
>= startp
&& p1
< endp
)
2172 *p1
= MAKE_GLYPH ((c
>> 6) + '0', current_face
);
2174 if (p1
>= startp
&& p1
< endp
)
2175 *p1
= MAKE_GLYPH ((7 & (c
>> 3)) + '0', current_face
);
2177 if (p1
>= startp
&& p1
< endp
)
2178 *p1
= MAKE_GLYPH ((7 & c
) + '0', current_face
);
2185 val
.hpos
= - XINT (w
->hscroll
);
2193 /* Handle continuation in middle of a character */
2194 /* by backing up over it */
2197 /* Don't back up if we never actually displayed any text.
2198 This occurs when the minibuffer prompt takes up the whole line. */
2201 /* Start the next line with that same character */
2203 /* but at negative hpos, to skip the columns output on this line. */
2204 val
.hpos
+= p1prev
- endp
;
2207 /* Keep in this line everything up to the continuation column. */
2211 /* Finish deciding which character to start the next line on,
2212 and what hpos to start it at.
2213 Also set `lastpos' to the last position which counts as "on this line"
2214 for cursor-positioning. */
2218 if (FETCH_CHAR (pos
) == '\n')
2219 /* If stopped due to a newline, start next line after it */
2222 /* Stopped due to right margin of window */
2227 /* Truncating => start next line after next newline,
2228 and point is on this line if it is before the newline,
2229 and skip none of first char of next line */
2230 pos
= find_next_newline (pos
, 1);
2231 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
2233 lastpos
= pos
- (FETCH_CHAR (pos
- 1) == '\n');
2244 /* If point is at eol or in invisible text at eol,
2245 record its frame location now. */
2247 if (start
<= point
&& point
<= lastpos
&& cursor_vpos
< 0)
2250 cursor_hpos
= p1
- startp
;
2253 if (cursor_vpos
== vpos
)
2255 if (cursor_hpos
< 0) cursor_hpos
= 0;
2256 if (cursor_hpos
> width
) cursor_hpos
= width
;
2257 cursor_hpos
+= XFASTINT (w
->left
);
2258 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
2260 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2261 FRAME_CURSOR_X (f
) = cursor_hpos
;
2263 if (w
== XWINDOW (selected_window
))
2265 /* Line is not continued and did not start
2266 in middle of character */
2267 if ((hpos
- XFASTINT (w
->left
)
2268 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2271 this_line_bufpos
= start
;
2272 this_line_buffer
= current_buffer
;
2273 this_line_vpos
= cursor_vpos
;
2274 this_line_start_hpos
= hpos
;
2275 this_line_endpos
= Z
- lastpos
;
2278 this_line_bufpos
= 0;
2283 /* If hscroll and line not empty, insert truncation-at-left marker */
2284 if (hscroll
&& lastpos
!= start
)
2286 *startp
= truncator
;
2291 if (XFASTINT (w
->width
) + XFASTINT (w
->left
) != FRAME_WIDTH (f
))
2294 if (p1
< startp
) p1
= startp
;
2295 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
2297 /* Don't draw vertical bars if we're using scroll bars. They're
2298 covered up by the scroll bars, and it's distracting to see
2299 them when the scroll bar windows are flickering around to be
2301 *p1
++ = (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
2304 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
2305 p1
- desired_glyphs
->glyphs
[vpos
]);
2306 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2308 /* If the start of this line is the overlay arrow-position,
2309 then put the arrow string into the display-line. */
2311 if (XTYPE (Voverlay_arrow_position
) == Lisp_Marker
2312 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
2313 && start
== marker_position (Voverlay_arrow_position
)
2314 && XTYPE (Voverlay_arrow_string
) == Lisp_String
2315 && ! overlay_arrow_seen
)
2317 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
2319 int len
= XSTRING (Voverlay_arrow_string
)->size
;
2324 for (i
= 0; i
< len
; i
++)
2327 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
2328 arrow_end
= (startp
- desired_glyphs
->glyphs
[vpos
]) + len
;
2329 if (desired_glyphs
->used
[vpos
] < arrow_end
)
2330 desired_glyphs
->used
[vpos
] = arrow_end
;
2332 overlay_arrow_seen
= 1;
2336 val_display_text_line
= val
;
2337 return &val_display_text_line
;
2340 /* Redisplay the menu bar in the frame for window W. */
2343 display_menu_bar (w
)
2346 Lisp_Object items
, tail
;
2347 register int vpos
= 0;
2348 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2349 int maxendcol
= FRAME_WIDTH (f
);
2352 if (FRAME_MENU_BAR_LINES (f
) <= 0)
2355 get_display_line (f
, vpos
, 0);
2357 for (tail
= FRAME_MENU_BAR_ITEMS (f
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2361 string
= XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->car
;
2363 /* Record in each item its hpos. */
2364 XFASTINT (XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->cdr
) = hpos
;
2366 if (hpos
< maxendcol
)
2367 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
2368 XSTRING (string
)->data
,
2369 XSTRING (string
)->size
,
2370 hpos
, 0, hpos
, maxendcol
);
2371 /* Put a gap of 3 spaces between items. */
2372 if (hpos
< maxendcol
)
2374 int hpos1
= hpos
+ 3;
2375 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0,
2376 min (hpos1
, maxendcol
), maxendcol
);
2380 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2381 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2383 /* Fill out the line with spaces. */
2384 if (maxendcol
> hpos
)
2385 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, maxendcol
, -1);
2387 /* Clear the rest of the lines allocated to the menu bar. */
2389 while (vpos
< FRAME_MENU_BAR_LINES (f
))
2390 get_display_line (f
, vpos
++, 0);
2393 /* Display the mode line for window w */
2396 display_mode_line (w
)
2399 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
2400 register int left
= XFASTINT (w
->left
);
2401 register int right
= XFASTINT (w
->width
) + left
;
2402 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2404 line_number_displayed
= 0;
2406 get_display_line (f
, vpos
, left
);
2407 display_mode_element (w
, vpos
, left
, 0, right
, right
,
2408 current_buffer
->mode_line_format
);
2409 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2411 /* Make the mode line inverse video if the entire line
2412 is made of mode lines.
2413 I.e. if this window is full width,
2414 or if it is the child of a full width window
2415 (which implies that that window is split side-by-side
2416 and the rest of this line is mode lines of the sibling windows). */
2417 if (XFASTINT (w
->width
) == FRAME_WIDTH (f
)
2418 || XFASTINT (XWINDOW (w
->parent
)->width
) == FRAME_WIDTH (f
))
2419 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2421 #ifdef HAVE_X_WINDOWS
2422 /* I'm trying this out because I saw Unimpress use it, but it's
2423 possible that this may mess adversely with some window managers. -jla
2425 Wouldn't it be nice to use something like mode-line-format to
2426 describe frame titles? -JimB */
2428 /* Change the title of the frame to the name of the buffer displayed
2429 in the currently selected window. Don't do this for minibuffer frames,
2430 and don't do it when there's only one non-minibuffer frame. */
2432 && ! FRAME_MINIBUF_ONLY_P (f
)
2433 && w
== XWINDOW (f
->selected_window
))
2434 x_implicitly_set_name (f
, (EQ (Fnext_frame (WINDOW_FRAME (w
), Qnil
),
2437 : XBUFFER (w
->buffer
)->name
),
2442 /* Contribute ELT to the mode line for window W.
2443 How it translates into text depends on its data type.
2445 VPOS is the position of the mode line being displayed.
2447 HPOS is the position (absolute on frame) where this element's text
2448 should start. The output is truncated automatically at the right
2451 DEPTH is the depth in recursion. It is used to prevent
2452 infinite recursion here.
2454 MINENDCOL is the hpos before which the element may not end.
2455 The element is padded at the right with spaces if nec
2456 to reach this column.
2458 MAXENDCOL is the hpos past which this element may not extend.
2459 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
2460 (This is necessary to make nested padding and truncation work.)
2462 Returns the hpos of the end of the text generated by ELT.
2463 The next element will receive that value as its HPOS arg,
2464 so as to concatenate the elements. */
2467 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
2469 register int vpos
, hpos
;
2472 register int maxendcol
;
2473 register Lisp_Object elt
;
2481 #ifdef SWITCH_ENUM_BUG
2482 switch ((int) XTYPE (elt
))
2484 switch (XTYPE (elt
))
2489 /* A string: output it and check for %-constructs within it. */
2490 register unsigned char c
;
2491 register unsigned char *this = XSTRING (elt
)->data
;
2493 while (hpos
< maxendcol
&& *this)
2495 unsigned char *last
= this;
2496 while ((c
= *this++) != '\0' && c
!= '%')
2498 if (this - 1 != last
)
2500 register int lim
= --this - last
+ hpos
;
2501 hpos
= display_string (w
, vpos
, last
, -1, hpos
, 0, hpos
,
2502 min (lim
, maxendcol
));
2506 register int spec_width
= 0;
2508 /* We can't allow -ve args due to the "%-" construct */
2509 /* Argument specifies minwidth but not maxwidth
2510 (maxwidth can be specified by
2511 (<negative-number> . <stuff>) mode-line elements) */
2513 while ((c
= *this++) >= '0' && c
<= '9')
2515 spec_width
= spec_width
* 10 + (c
- '0');
2519 if (spec_width
> maxendcol
)
2520 spec_width
= maxendcol
;
2523 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2524 spec_width
, maxendcol
,
2525 Vglobal_mode_string
);
2527 hpos
= display_string (w
, vpos
,
2528 decode_mode_spec (w
, c
,
2531 hpos
, 0, spec_width
, maxendcol
);
2538 /* A symbol: process the value of the symbol recursively
2539 as if it appeared here directly. Avoid error if symbol void.
2540 Special case: if value of symbol is a string, output the string
2543 register Lisp_Object tem
;
2544 tem
= Fboundp (elt
);
2547 tem
= Fsymbol_value (elt
);
2548 /* If value is a string, output that string literally:
2549 don't check for % within it. */
2550 if (XTYPE (tem
) == Lisp_String
)
2551 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
2552 XSTRING (tem
)->size
,
2553 hpos
, 0, minendcol
, maxendcol
);
2554 /* Give up right away for nil or t. */
2555 else if (!EQ (tem
, elt
))
2556 { elt
= tem
; goto tail_recurse
; }
2563 register Lisp_Object car
, tem
;
2565 /* A cons cell: three distinct cases.
2566 If first element is a string or a cons, process all the elements
2567 and effectively concatenate them.
2568 If first element is a negative number, truncate displaying cdr to
2569 at most that many characters. If positive, pad (with spaces)
2570 to at least that many characters.
2571 If first element is a symbol, process the cadr or caddr recursively
2572 according to whether the symbol's value is non-nil or nil. */
2573 car
= XCONS (elt
)->car
;
2574 if (XTYPE (car
) == Lisp_Symbol
)
2576 tem
= Fboundp (car
);
2577 elt
= XCONS (elt
)->cdr
;
2578 if (XTYPE (elt
) != Lisp_Cons
)
2580 /* elt is now the cdr, and we know it is a cons cell.
2581 Use its car if CAR has a non-nil value. */
2584 tem
= Fsymbol_value (car
);
2586 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
2588 /* Symbol's value is nil (or symbol is unbound)
2589 Get the cddr of the original list
2590 and if possible find the caddr and use that. */
2591 elt
= XCONS (elt
)->cdr
;
2594 else if (XTYPE (elt
) != Lisp_Cons
)
2596 elt
= XCONS (elt
)->car
;
2599 else if (XTYPE (car
) == Lisp_Int
)
2601 register int lim
= XINT (car
);
2602 elt
= XCONS (elt
)->cdr
;
2604 /* Negative int means reduce maximum width.
2605 DO NOT change MINENDCOL here!
2606 (20 -10 . foo) should truncate foo to 10 col
2607 and then pad to 20. */
2608 maxendcol
= min (maxendcol
, hpos
- lim
);
2611 /* Padding specified. Don't let it be more than
2614 if (lim
> maxendcol
)
2616 /* If that's more padding than already wanted, queue it.
2617 But don't reduce padding already specified even if
2618 that is beyond the current truncation point. */
2619 if (lim
> minendcol
)
2624 else if (XTYPE (car
) == Lisp_String
|| XTYPE (car
) == Lisp_Cons
)
2626 register int limit
= 50;
2627 /* LIMIT is to protect against circular lists. */
2628 while (XTYPE (elt
) == Lisp_Cons
&& --limit
> 0
2629 && hpos
< maxendcol
)
2631 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2634 elt
= XCONS (elt
)->cdr
;
2642 return (display_string (w
, vpos
, "*invalid*", -1, hpos
, 0,
2643 minendcol
, maxendcol
));
2647 if (minendcol
> hpos
)
2648 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, minendcol
, -1);
2652 /* Return a string for the output of a mode line %-spec for window W,
2653 generated by character C and width MAXWIDTH. */
2655 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
2658 decode_mode_spec (w
, c
, maxwidth
)
2661 register int maxwidth
;
2663 Lisp_Object obj
= Qnil
;
2664 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2665 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
2667 if (maxwidth
> FRAME_WIDTH (f
))
2668 maxwidth
= FRAME_WIDTH (f
);
2673 obj
= current_buffer
->name
;
2675 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
2677 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
2678 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
2679 decode_mode_spec_buf
[maxwidth
] = '\0';
2680 return decode_mode_spec_buf
;
2686 obj
= current_buffer
->filename
;
2690 else if (XTYPE (obj
) == Lisp_String
&& XSTRING (obj
)->size
> maxwidth
)
2692 bcopy ("...", decode_mode_spec_buf
, 3);
2693 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
2694 decode_mode_spec_buf
+ 3, maxwidth
- 3);
2695 return decode_mode_spec_buf
;
2702 int startpos
= marker_position (w
->start
);
2703 int line
, linepos
, topline
;
2706 int height
= XFASTINT (w
->height
);
2708 /* If we decided that this buffer isn't suitable for line numbers,
2709 don't forget that too fast. */
2710 if (EQ (w
->base_line_pos
, w
->buffer
))
2713 /* If the buffer is very big, don't waste time. */
2714 if (ZV
- BEGV
> line_number_display_limit
)
2716 w
->base_line_pos
= Qnil
;
2717 w
->base_line_number
= Qnil
;
2721 if (!NILP (w
->base_line_number
)
2722 && !NILP (w
->base_line_pos
)
2723 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
2725 line
= XFASTINT (w
->base_line_number
);
2726 linepos
= XFASTINT (w
->base_line_pos
);
2734 /* Count lines from base line to window start position. */
2735 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
2737 topline
= nlines
+ line
;
2739 /* Determine a new base line, if the old one is too close
2740 or too far away, or if we did not have one.
2741 "Too close" means it's plausible a scroll-down would
2743 if (startpos
== BEGV
)
2745 XFASTINT (w
->base_line_number
) = topline
;
2746 XFASTINT (w
->base_line_pos
) = BEGV
;
2748 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
2753 int distance
= (height
* 2 + 30) * 200;
2755 if (startpos
- distance
> limit
)
2756 limit
= startpos
- distance
;
2758 nlines
= display_count_lines (startpos
, limit
,
2761 /* If we couldn't find the lines we wanted within
2763 give up on line numbers for this window. */
2764 if (position
== startpos
- distance
)
2766 w
->base_line_pos
= w
->buffer
;
2767 w
->base_line_number
= Qnil
;
2771 XFASTINT (w
->base_line_number
) = topline
- nlines
;
2772 XFASTINT (w
->base_line_pos
) = position
;
2775 /* Now count lines from the start pos to point. */
2776 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
2778 /* Record that we did display the line number. */
2779 line_number_displayed
= 1;
2781 /* Make the string to show. */
2782 sprintf (decode_mode_spec_buf
, "%d", topline
+ nlines
);
2783 return decode_mode_spec_buf
;
2788 obj
= current_buffer
->mode_name
;
2792 if (BEGV
> BEG
|| ZV
< Z
)
2797 if (!NILP (current_buffer
->read_only
))
2799 if (MODIFF
> current_buffer
->save_modified
)
2804 /* status of process */
2805 obj
= Fget_buffer_process (Fcurrent_buffer ());
2807 return "no process";
2808 obj
= Fsymbol_name (Fprocess_status (obj
));
2813 int pos
= marker_position (w
->start
);
2814 int total
= ZV
- BEGV
;
2816 if (XFASTINT (w
->window_end_pos
) <= Z
- ZV
)
2823 else if (pos
<= BEGV
)
2827 total
= ((pos
- BEGV
) * 100 + total
- 1) / total
;
2828 /* We can't normally display a 3-digit number,
2829 so get us a 2-digit number that is close. */
2832 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
2833 return decode_mode_spec_buf
;
2845 if (command_loop_level
> 5)
2847 p
= decode_mode_spec_buf
;
2848 for (i
= 0; i
< command_loop_level
; i
++)
2851 return decode_mode_spec_buf
;
2859 if (command_loop_level
> 5)
2861 p
= decode_mode_spec_buf
;
2862 for (i
= 0; i
< command_loop_level
; i
++)
2865 return decode_mode_spec_buf
;
2873 if (maxwidth
< sizeof (lots_of_dashes
))
2874 return lots_of_dashes
;
2877 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
2881 return decode_mode_spec_buf
;
2885 if (XTYPE (obj
) == Lisp_String
)
2886 return (char *) XSTRING (obj
)->data
;
2891 /* Count up to N lines starting from FROM.
2892 But don't go beyond LIMIT.
2893 Return the number of lines thus found (always positive).
2894 Store the position after what was found into *POS_PTR. */
2897 display_count_lines (from
, limit
, n
, pos_ptr
)
2910 *pos_ptr
= scan_buffer ('\n', from
, n
, &shortage
);
2916 /* When scanning backwards, scan_buffer stops *after* the last newline
2917 it finds, but does count it. Compensate for that. */
2918 return - n
- shortage
- (*pos_ptr
!= limit
);
2919 return n
- shortage
;
2922 /* Display STRING on one line of window W, starting at HPOS.
2923 Display at position VPOS. Caller should have done get_display_line.
2924 If VPOS == -1, display it as the current frame's title.
2925 LENGTH is the length of STRING, or -1 meaning STRING is null-terminated.
2927 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
2929 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
2930 MAXCOL is the last column ok to end at. Truncate here.
2931 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
2932 Both count from the left edge of the frame, as does HPOS.
2933 The right edge of W is an implicit maximum.
2934 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
2936 Returns ending hpos */
2939 display_string (w
, vpos
, string
, length
, hpos
, truncate
, mincol
, maxcol
)
2941 unsigned char *string
;
2949 int hscroll
= XINT (w
->hscroll
);
2950 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
2951 register GLYPH
*start
;
2952 register GLYPH
*end
;
2953 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2954 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
2955 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2956 int window_width
= XFASTINT (w
->width
);
2958 /* Use the standard display table, not the window's display table.
2959 We don't want the mode line in rot13. */
2960 register struct Lisp_Vector
*dp
= 0;
2962 if (XTYPE (Vstandard_display_table
) == Lisp_Vector
2963 && XVECTOR (Vstandard_display_table
)->size
== DISP_TABLE_SIZE
)
2964 dp
= XVECTOR (Vstandard_display_table
);
2966 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
2969 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
2970 end
= start
+ window_width
- (truncate
!= 0);
2972 if ((window_width
+ XFASTINT (w
->left
)) != FRAME_WIDTH (f
))
2974 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2978 for (i
= 0; i
< VERTICAL_SCROLL_BAR_WIDTH
; i
++)
2985 if (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
)
2986 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
2987 if (maxcol
>= 0 && mincol
> maxcol
)
2995 /* Specified length. */
2998 /* Unspecified length (null-terminated string). */
3002 if (c
>= 040 && c
< 0177
3003 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
3013 if (p1
>= start
&& p1
< end
)
3017 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
3019 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
3020 p1
= copy_rope (p1
, start
, DISP_CHAR_VECTOR (dp
, c
), 0);
3021 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
3024 *p1
= (dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
3025 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^');
3027 if (p1
>= start
&& p1
< end
)
3034 *p1
= (dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
3035 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\');
3037 if (p1
>= start
&& p1
< end
)
3038 *p1
= (c
>> 6) + '0';
3040 if (p1
>= start
&& p1
< end
)
3041 *p1
= (7 & (c
>> 3)) + '0';
3043 if (p1
>= start
&& p1
< end
)
3044 *p1
= (7 & c
) + '0';
3049 if (c
&& length
> 0)
3052 if (truncate
) *p1
++ = truncate
;
3054 else if (mincol
>= 0)
3056 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
3062 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
3064 if (len
> desired_glyphs
->used
[vpos
])
3065 desired_glyphs
->used
[vpos
] = len
;
3066 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
3075 staticpro (&last_arrow_position
);
3076 staticpro (&last_arrow_string
);
3077 last_arrow_position
= Qnil
;
3078 last_arrow_string
= Qnil
;
3080 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
3081 "String (or mode line construct) included (normally) in `mode-line-format'.");
3082 Vglobal_mode_string
= Qnil
;
3084 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
3085 "Marker for where to display an arrow on top of the buffer text.\n\
3086 This must be the beginning of a line in order to work.\n\
3087 See also `overlay-arrow-string'.");
3088 Voverlay_arrow_position
= Qnil
;
3090 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
3091 "String to display as an arrow. See also `overlay-arrow-position'.");
3092 Voverlay_arrow_string
= Qnil
;
3094 DEFVAR_INT ("scroll-step", &scroll_step
,
3095 "*The number of lines to try scrolling a window by when point moves out.\n\
3096 If that fails to bring point back on frame, point is centered instead.\n\
3097 If this is zero, point is always centered after it moves off frame.");
3099 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
3101 DEFVAR_BOOL ("truncate-partial-width-windows",
3102 &truncate_partial_width_windows
,
3103 "*Non-nil means truncate lines in all windows less than full frame wide.");
3104 truncate_partial_width_windows
= 1;
3106 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
3107 "*Non-nil means use inverse video for the mode line.");
3108 mode_line_inverse_video
= 1;
3110 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
3111 "*Maximum buffer size for which line number should be displayed.");
3112 line_number_display_limit
= 1000000;
3114 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
3115 "*Non-nil means highlight region even in nonselected windows.");
3116 highlight_nonselected_windows
= 1;
3119 /* initialize the window system */
3122 Lisp_Object root_window
;
3123 #ifndef COMPILER_REGISTER_BUG
3125 #endif /* COMPILER_REGISTER_BUG */
3126 struct window
*mini_w
;
3128 this_line_bufpos
= 0;
3130 mini_w
= XWINDOW (minibuf_window
);
3131 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
3133 echo_area_glyphs
= 0;
3134 previous_echo_glyphs
= 0;
3136 if (!noninteractive
)
3138 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
3139 XFASTINT (XWINDOW (root_window
)->top
) = 0;
3140 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
3141 XFASTINT (mini_w
->top
) = FRAME_HEIGHT (f
) - 1;
3142 set_window_height (minibuf_window
, 1, 0);
3144 XFASTINT (XWINDOW (root_window
)->width
) = FRAME_WIDTH (f
);
3145 XFASTINT (mini_w
->width
) = FRAME_WIDTH (f
);