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 try_window ();
128 static int try_window_id ();
129 static struct position
*display_text_line ();
130 static void display_mode_line ();
131 static int display_mode_element ();
132 static char *fmodetrunc ();
133 static char *decode_mode_spec ();
134 static int display_string ();
135 static void display_menu_bar ();
136 static int display_count_lines ();
138 /* Prompt to display in front of the minibuffer contents */
139 char *minibuf_prompt
;
141 /* Width in columns of current minibuffer prompt. */
142 int minibuf_prompt_width
;
144 /* Message to display instead of minibuffer contents
145 This is what the functions error and message make,
146 and command echoing uses it as well.
147 It overrides the minibuf_prompt as well as the buffer. */
148 char *echo_area_glyphs
;
150 /* true iff we should redraw the mode lines on the next redisplay */
151 int update_mode_lines
;
153 /* Smallest number of characters before the gap
154 at any time since last redisplay that finished.
155 Valid for current buffer when try_window_id can be called. */
158 /* Smallest number of characters after the gap
159 at any time since last redisplay that finished.
160 Valid for current buffer when try_window_id can be called. */
163 /* MODIFF as of last redisplay that finished;
164 if it matches MODIFF, beg_unchanged and end_unchanged
165 contain no useful information */
166 int unchanged_modified
;
168 /* Nonzero if head_clip or tail_clip of current buffer has changed
169 since last redisplay that finished */
172 /* Nonzero if window sizes or contents have changed
173 since last redisplay that finished */
174 int windows_or_buffers_changed
;
176 /* Nonzero after display_mode_line if %l was used
177 and it displayed a line number. */
178 int line_number_displayed
;
180 /* Maximum buffer size for which to display line numbers. */
181 int line_number_display_limit
;
183 /* Specify m, a string, as a message in the minibuf. If m is 0, clear out
184 any existing message, and let the minibuffer text show through. */
191 if (noninteractive_need_newline
)
193 noninteractive_need_newline
= 0;
194 if (cursor_in_echo_area
!= 0)
195 fprintf (stderr
, "%s", m
);
197 fprintf (stderr
, "%s\n", m
);
200 /* A null message buffer means that the frame hasn't really been
201 initialized yet. Error messages get reported properly by
202 cmd_error, so this must be just an informative message; toss it. */
203 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
206 Lisp_Object minibuf_frame
;
208 choose_minibuf_frame ();
209 minibuf_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
210 FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame
));
211 if (FRAME_VISIBLE_P (selected_frame
)
212 && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame
)))
213 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window
)));
217 echo_area_glyphs
= m
;
219 echo_area_glyphs
= previous_echo_glyphs
= 0;
221 do_pending_window_change ();
222 echo_area_display ();
223 update_frame (XFRAME (XWINDOW (minibuf_window
)->frame
), 1, 1);
224 do_pending_window_change ();
228 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
229 zero if being used by message. */
230 int message_buf_print
;
232 /* Dump an informative message to the minibuf. If m is 0, clear out
233 any existing message, and let the minibuffer text show through. */
236 message (m
, a1
, a2
, a3
)
243 if (noninteractive_need_newline
)
245 noninteractive_need_newline
= 0;
246 fprintf (stderr
, m
, a1
, a2
, a3
);
247 if (cursor_in_echo_area
== 0)
248 fprintf (stderr
, "\n");
252 else if (INTERACTIVE
)
254 /* The frame whose minibuffer we're going to display the message on.
255 It may be larger than the selected frame, so we need
256 to use its buffer, not the selected frame's buffer. */
257 FRAME_PTR echo_frame
;
259 choose_minibuf_frame ();
260 echo_frame
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
262 echo_frame
= selected_frame
;
265 /* A null message buffer means that the frame hasn't really been
266 initialized yet. Error messages get reported properly by
267 cmd_error, so this must be just an informative message; toss it. */
268 if (FRAME_MESSAGE_BUF (echo_frame
))
279 doprnt (FRAME_MESSAGE_BUF (echo_frame
),
280 FRAME_WIDTH (echo_frame
), m
, 0, 3, a
);
282 doprnt (FRAME_MESSAGE_BUF (echo_frame
),
283 FRAME_WIDTH (echo_frame
), m
, 0, 3, &a1
);
284 #endif /* NO_ARG_ARRAY */
287 message1 (FRAME_MESSAGE_BUF (echo_frame
));
292 /* Print should start at the beginning of the message
294 message_buf_print
= 0;
306 choose_minibuf_frame ();
309 f
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
311 if (! FRAME_VISIBLE_P (f
))
316 redraw_garbaged_frames ();
320 if (echo_area_glyphs
|| minibuf_level
== 0)
322 vpos
= XFASTINT (XWINDOW (minibuf_window
)->top
);
323 get_display_line (f
, vpos
, 0);
324 display_string (XWINDOW (minibuf_window
), vpos
,
325 echo_area_glyphs
? echo_area_glyphs
: "",
326 0, 0, 0, FRAME_WIDTH (f
));
328 /* If desired cursor location is on this line, put it at end of text */
329 if (FRAME_CURSOR_Y (f
) == vpos
)
330 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
332 /* Fill the rest of the minibuffer window with blank lines. */
337 i
< vpos
+ XFASTINT (XWINDOW (minibuf_window
)->height
); i
++)
339 get_display_line (f
, i
, 0);
340 display_string (XWINDOW (minibuf_window
), vpos
,
341 "", 0, 0, 0, FRAME_WIDTH (f
));
345 else if (!EQ (minibuf_window
, selected_window
))
346 windows_or_buffers_changed
++;
348 if (EQ (minibuf_window
, selected_window
))
349 this_line_bufpos
= 0;
351 previous_echo_glyphs
= echo_area_glyphs
;
354 /* Do a frame update, taking possible shortcuts into account.
355 This is the main external entry point for redisplay.
357 If the last redisplay displayed an echo area message and that
358 message is no longer requested, we clear the echo area
359 or bring back the minibuffer if that is in use.
361 Everyone would like to have a hook here to call eval,
362 but that cannot be done safely without a lot of changes elsewhere.
363 This can be called from signal handlers; with alarms set up;
364 or with synchronous processes running.
365 See the function `echo' in keyboard.c.
366 See Fcall_process; if you called it from here, it could be
367 entered recursively. */
372 register struct window
*w
= XWINDOW (selected_window
);
376 register int tlbufpos
, tlendpos
;
378 extern int input_pending
;
383 /* Set the visible flags for all frames.
384 Do this before checking for resized or garbaged frames; they want
385 to know if their frames are visible.
386 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
388 Lisp_Object tail
, frame
;
390 FOR_EACH_FRAME (tail
, frame
)
391 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
394 /* Notice any pending interrupt request to change frame size. */
395 do_pending_window_change ();
399 redraw_garbaged_frames ();
403 /* Normally the message* functions will have already displayed and
404 updated the echo area, but the frame may have been trashed, or
405 the update may have been preempted, so display the echo area
407 if (echo_area_glyphs
|| previous_echo_glyphs
)
409 echo_area_display ();
413 if (clip_changed
|| windows_or_buffers_changed
)
416 /* Detect case that we need to write a star in the mode line. */
417 if (XFASTINT (w
->last_modified
) < MODIFF
418 && XFASTINT (w
->last_modified
) <= current_buffer
->save_modified
)
420 w
->update_mode_line
= Qt
;
421 if (buffer_shared
> 1)
425 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
427 all_windows
= update_mode_lines
|| buffer_shared
> 1;
429 /* If specs for an arrow have changed, do thorough redisplay
430 to ensure we remove any arrow that should no longer exist. */
431 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
432 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
433 all_windows
= 1, clip_changed
= 1;
435 /* If showing region, and mark has changed, must redisplay whole window. */
436 if (((!NILP (Vtransient_mark_mode
)
437 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
438 != !NILP (w
->region_showing
))
439 || (!NILP (w
->region_showing
)
440 && !EQ (w
->region_showing
,
441 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
442 this_line_bufpos
= -1;
444 tlbufpos
= this_line_bufpos
;
445 tlendpos
= this_line_endpos
;
446 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
447 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
448 /* Make sure recorded data applies to current buffer, etc */
449 && this_line_buffer
== current_buffer
450 && current_buffer
== XBUFFER (w
->buffer
)
451 && NILP (w
->force_start
)
452 /* Point must be on the line that we have info recorded about */
454 && point
<= Z
- tlendpos
455 /* All text outside that line, including its final newline,
457 && (XFASTINT (w
->last_modified
) >= MODIFF
458 || (beg_unchanged
>= tlbufpos
- 1
460 /* If selective display, can't optimize
461 if the changes start at the beginning of the line. */
462 && ((XTYPE (current_buffer
->selective_display
) == Lisp_Int
463 && XINT (current_buffer
->selective_display
) > 0
464 ? (beg_unchanged
>= tlbufpos
467 && end_unchanged
>= tlendpos
468 && Z
- GPT
>= tlendpos
)))
470 if (tlbufpos
> BEGV
&& FETCH_CHAR (tlbufpos
- 1) != '\n'
472 || FETCH_CHAR (tlbufpos
) == '\n'))
473 /* Former continuation line has disappeared by becoming empty */
475 else if (XFASTINT (w
->last_modified
) < MODIFF
476 || MINI_WINDOW_P (w
))
479 overlay_arrow_seen
= 0;
480 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
481 pos_tab_offset (w
, tlbufpos
));
482 /* If line contains point, is not continued,
483 and ends at same distance from eob as before, we win */
484 if (cursor_vpos
>= 0 && this_line_bufpos
485 && this_line_endpos
== tlendpos
)
487 if (XFASTINT (w
->width
) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w
))))
488 preserve_other_columns (w
);
494 else if (point
== XFASTINT (w
->last_point
))
498 do_pending_window_change ();
503 /* If highlighting the region, we can't just move the cursor. */
504 else if (! (!NILP (Vtransient_mark_mode
)
505 && !NILP (current_buffer
->mark_active
))
506 && NILP (w
->region_showing
))
508 pos
= *compute_motion (tlbufpos
, 0,
509 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
510 point
, 2, - (1 << (SHORTBITS
- 1)),
511 window_internal_width (w
) - 1,
513 pos_tab_offset (w
, tlbufpos
));
516 FRAME_CURSOR_X (selected_frame
)
517 = XFASTINT (w
->left
) + max (pos
.hpos
, 0);
518 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
525 /* Text changed drastically or point moved off of line */
526 cancel_line (this_line_vpos
, selected_frame
);
529 this_line_bufpos
= 0;
530 all_windows
|= buffer_shared
> 1;
534 Lisp_Object tail
, frame
;
536 #ifdef HAVE_X_WINDOWS
537 /* Since we're doing a thorough redisplay, we might as well
538 recompute all our display faces. */
539 clear_face_vector ();
542 /* Recompute # windows showing selected buffer.
543 This will be incremented each time such a window is displayed. */
546 FOR_EACH_FRAME (tail
, frame
)
548 FRAME_PTR f
= XFRAME (frame
);
550 /* Mark all the scroll bars to be removed; we'll redeem the ones
551 we want when we redisplay their windows. */
552 if (condemn_scroll_bars_hook
)
553 (*condemn_scroll_bars_hook
) (f
);
555 if (FRAME_VISIBLE_P (f
))
556 redisplay_windows (FRAME_ROOT_WINDOW (f
));
558 /* Any scroll bars which redisplay_windows should have nuked
559 should now go away. */
560 if (judge_scroll_bars_hook
)
561 (*judge_scroll_bars_hook
) (f
);
564 else if (FRAME_VISIBLE_P (selected_frame
))
566 redisplay_window (selected_window
, 1);
567 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
568 preserve_other_columns (w
);
572 /* Prevent various kinds of signals during display update.
573 stdio is not robust about handling signals,
574 which can cause an apparent I/O error. */
586 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
590 if (XTYPE (XCONS (tail
)->car
) != Lisp_Frame
)
593 f
= XFRAME (XCONS (tail
)->car
);
594 if (FRAME_VISIBLE_P (f
))
596 pause
|= update_frame (f
, 0, 0);
598 mark_window_display_accurate (f
->root_window
, 1);
603 #endif /* MULTI_FRAME */
605 if (FRAME_VISIBLE_P (selected_frame
))
606 pause
= update_frame (selected_frame
, 0, 0);
608 /* We may have called echo_area_display at the top of this
609 function. If the echo area is on another frame, that may
610 have put text on a frame other than the selected one, so the
611 above call to update_frame would not have caught it. Catch
614 FRAME_PTR mini_frame
=
615 XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
617 if (mini_frame
!= selected_frame
)
618 pause
|= update_frame (mini_frame
, 0, 0);
622 /* If frame does not match, prevent doing single-line-update next time.
623 Also, don't forget to check every line to update the arrow. */
626 this_line_bufpos
= 0;
627 if (!NILP (last_arrow_position
))
629 last_arrow_position
= Qt
;
630 last_arrow_string
= Qt
;
632 /* If we pause after scrolling, some lines in current_frame
633 may be null, so preserve_other_columns won't be able to
634 preserve all the vertical-bar separators. So, avoid using it
636 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
637 update_mode_lines
= 1;
640 /* Now text on frame agrees with windows, so
641 put info into the windows for partial redisplay to follow */
645 register struct buffer
*b
= XBUFFER (w
->buffer
);
647 blank_end_of_window
= 0;
649 unchanged_modified
= BUF_MODIFF (b
);
650 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
651 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
653 XFASTINT (w
->last_point
) = BUF_PT (b
);
654 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (selected_frame
);
655 XFASTINT (w
->last_point_y
) = FRAME_CURSOR_Y (selected_frame
);
658 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
661 w
->update_mode_line
= Qnil
;
662 XFASTINT (w
->last_modified
) = BUF_MODIFF (b
);
663 w
->window_end_valid
= Qt
;
664 last_arrow_position
= Voverlay_arrow_position
;
665 last_arrow_string
= Voverlay_arrow_string
;
667 update_mode_lines
= 0;
668 windows_or_buffers_changed
= 0;
671 /* Start SIGIO interrupts coming again.
672 Having them off during the code above
673 makes it less likely one will discard output,
674 but not impossible, since there might be stuff
675 in the system buffer here.
676 But it is much hairier to try to do anything about that. */
682 /* Change frame size now if a change is pending. */
683 do_pending_window_change ();
686 /* Redisplay, but leave alone any recent echo area message
687 unless another message has been requested in its place.
689 This is useful in situations where you need to redisplay but no
690 user action has occurred, making it inappropriate for the message
691 area to be cleared. See tracking_off and
692 wait_reading_process_input for examples of these situations. */
694 redisplay_preserve_echo_area ()
696 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
698 echo_area_glyphs
= previous_echo_glyphs
;
700 echo_area_glyphs
= 0;
707 mark_window_display_accurate (window
, flag
)
711 register struct window
*w
;
713 for (;!NILP (window
); window
= w
->next
)
715 if (XTYPE (window
) != Lisp_Window
) abort ();
716 w
= XWINDOW (window
);
718 if (!NILP (w
->buffer
))
720 XFASTINT (w
->last_modified
)
722 : XBUFFER (w
->buffer
) == current_buffer
723 ? MODIFF
: BUF_MODIFF (XBUFFER (w
->buffer
));
725 /* Record if we are showing a region, so can make sure to
726 update it fully at next redisplay. */
727 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
728 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
729 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
733 w
->window_end_valid
= Qt
;
734 w
->update_mode_line
= Qnil
;
736 if (!NILP (w
->vchild
))
737 mark_window_display_accurate (w
->vchild
, flag
);
738 if (!NILP (w
->hchild
))
739 mark_window_display_accurate (w
->hchild
, flag
);
744 last_arrow_position
= Voverlay_arrow_position
;
745 last_arrow_string
= Voverlay_arrow_string
;
749 /* t is unequal to any useful value of Voverlay_arrow_... */
750 last_arrow_position
= Qt
;
751 last_arrow_string
= Qt
;
758 redisplay_windows (window
)
761 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
762 redisplay_window (window
, 0);
766 redisplay_window (window
, just_this_one
)
770 register struct window
*w
= XWINDOW (window
);
771 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
773 register int lpoint
= point
;
774 struct buffer
*old
= current_buffer
;
775 register int width
= window_internal_width (w
) - 1;
777 register int hscroll
= XINT (w
->hscroll
);
781 int window_needs_modeline
;
783 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
785 /* If this is a combination window, do its children; that's all. */
787 if (!NILP (w
->vchild
))
789 redisplay_windows (w
->vchild
);
792 if (!NILP (w
->hchild
))
794 redisplay_windows (w
->hchild
);
797 if (NILP (w
->buffer
))
800 height
= window_internal_height (w
);
802 if (MINI_WINDOW_P (w
))
804 if (w
== XWINDOW (minibuf_window
))
806 if (echo_area_glyphs
)
807 /* We've already displayed the echo area glyphs, if any. */
808 goto finish_scroll_bars
;
812 /* This is a minibuffer, but it's not the currently active one, so
814 int vpos
= XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
817 for (i
= 0; i
< height
; i
++)
819 get_display_line (f
, vpos
+ i
, 0);
820 display_string (w
, vpos
+ i
, "", 0, 0, 0, width
);
823 goto finish_scroll_bars
;
827 if (update_mode_lines
)
828 w
->update_mode_line
= Qt
;
830 /* Otherwise set up data on this window; select its buffer and point value */
832 current_buffer
= XBUFFER (w
->buffer
);
835 /* Count number of windows showing the selected buffer. */
838 && current_buffer
== XBUFFER (XWINDOW (selected_window
)->buffer
))
841 /* POINT refers normally to the selected window.
842 For any other window, set up appropriate value. */
844 if (!EQ (window
, selected_window
))
846 SET_PT (marker_position (w
->pointm
));
850 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
852 else if (point
> (ZV
- 1))
855 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
859 /* If window-start is screwed up, choose a new one. */
860 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
863 startp
= marker_position (w
->start
);
865 /* Handle case where place to start displaying has been specified,
866 unless the specified location is outside the accessible range. */
867 if (!NILP (w
->force_start
))
869 /* Forget any recorded base line for line number display. */
870 w
->base_line_number
= Qnil
;
871 w
->update_mode_line
= Qt
;
872 w
->force_start
= Qnil
;
873 XFASTINT (w
->last_modified
) = 0;
874 if (startp
< BEGV
) startp
= BEGV
;
875 if (startp
> ZV
) startp
= ZV
;
876 try_window (window
, startp
);
879 /* ??? What should happen here if highlighting a region? */
880 /* If point does not appear, move point so it does appear */
881 pos
= *compute_motion (startp
, 0,
882 ((EQ (window
, minibuf_window
) && startp
== 1)
883 ? minibuf_prompt_width
: 0)
885 (hscroll
? 1 - hscroll
: 0),
887 - (1 << (SHORTBITS
- 1)),
888 width
, hscroll
, pos_tab_offset (w
, startp
));
890 if (w
!= XWINDOW (FRAME_SELECTED_WINDOW (f
)))
891 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
895 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
896 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
902 /* Handle case where text has not changed, only point,
903 and it has not moved off the frame */
905 /* This code is not used for minibuffer for the sake of
906 the case of redisplaying to replace an echo area message;
907 since in that case the minibuffer contents per se are usually unchanged.
908 This code is of no real use in the minibuffer since
909 the handling of this_line_bufpos, etc.,
910 in redisplay handles the same cases. */
912 if (XFASTINT (w
->last_modified
) >= MODIFF
913 && point
>= startp
&& !clip_changed
914 && (just_this_one
|| XFASTINT (w
->width
) == FRAME_WIDTH (f
))
915 /* Can't use this case if highlighting a region. */
916 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
917 && NILP (w
->region_showing
)
918 && !EQ (window
, minibuf_window
))
920 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0),
921 point
, height
+ 1, 10000, width
, hscroll
,
922 pos_tab_offset (w
, startp
));
924 if (pos
.vpos
< height
)
926 /* Ok, point is still on frame */
927 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
929 /* These variables are supposed to be origin 1 */
930 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
931 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
933 /* This doesn't do the trick, because if a window to the right of
934 this one must be redisplayed, this does nothing because there
935 is nothing in DesiredFrame yet, and then the other window is
936 redisplayed, making likes that are empty in this window's columns.
937 if (XFASTINT (w->width) != FRAME_WIDTH (f))
938 preserve_my_columns (w);
942 /* Don't bother trying redisplay with same start;
943 we already know it will lose */
945 /* If current starting point was originally the beginning of a line
946 but no longer is, find a new starting point. */
947 else if (!NILP (w
->start_at_line_beg
)
949 || FETCH_CHAR (startp
- 1) == '\n'))
953 else if (just_this_one
&& !MINI_WINDOW_P (w
)
955 && XFASTINT (w
->last_modified
)
956 /* or else vmotion on first line won't work. */
957 && ! NILP (w
->start_at_line_beg
)
958 && ! EQ (w
->window_end_valid
, Qnil
)
959 && do_id
&& !clip_changed
960 && !blank_end_of_window
961 && XFASTINT (w
->width
) == FRAME_WIDTH (f
)
962 /* Can't use this case if highlighting a region. */
963 && !(!NILP (Vtransient_mark_mode
)
964 && !NILP (current_buffer
->mark_active
))
965 && NILP (w
->region_showing
)
966 && EQ (last_arrow_position
, Voverlay_arrow_position
)
967 && EQ (last_arrow_string
, Voverlay_arrow_string
)
968 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
971 /* tem > 0 means success. tem == -1 means choose new start.
972 tem == -2 means try again with same start,
973 and nothing but whitespace follows the changed stuff.
974 tem == 0 means try again with same start. */
978 else if (startp
>= BEGV
&& startp
<= ZV
979 /* Avoid starting display at end of buffer! */
980 && (startp
< ZV
|| startp
== BEGV
981 || (XFASTINT (w
->last_modified
) >= MODIFF
)))
983 /* Try to redisplay starting at same place as before */
984 /* If point has not moved off frame, accept the results */
985 try_window (window
, startp
);
986 if (cursor_vpos
>= 0)
988 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
989 /* Forget any recorded base line for line number display. */
990 w
->base_line_number
= Qnil
;
994 cancel_my_columns (w
);
997 XFASTINT (w
->last_modified
) = 0;
998 w
->update_mode_line
= Qt
;
1000 /* Try to scroll by specified few lines */
1002 if (scroll_step
&& !clip_changed
)
1006 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1007 scroll_step
, width
, hscroll
, window
);
1008 if (pos
.vpos
>= height
)
1012 pos
= *vmotion (startp
, point
< startp
? - scroll_step
: scroll_step
,
1013 width
, hscroll
, window
);
1015 if (point
>= pos
.bufpos
)
1017 try_window (window
, pos
.bufpos
);
1018 if (cursor_vpos
>= 0)
1020 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1021 /* Forget any recorded base line for line number display. */
1022 w
->base_line_number
= Qnil
;
1026 cancel_my_columns (w
);
1031 /* Finally, just choose place to start which centers point */
1034 /* Forget any previously recorded base line for line number display. */
1035 w
->base_line_number
= Qnil
;
1037 pos
= *vmotion (point
, - height
/ 2, width
, hscroll
, window
);
1038 try_window (window
, pos
.bufpos
);
1040 startp
= marker_position (w
->start
);
1041 w
->start_at_line_beg
=
1042 (startp
== BEGV
|| FETCH_CHAR (startp
- 1) == '\n') ? Qt
: Qnil
;
1045 if ((!NILP (w
->update_mode_line
)
1046 /* If window not full width, must redo its mode line
1047 if the window to its side is being redone */
1048 || (!just_this_one
&& width
< FRAME_WIDTH (f
) - 1)
1049 || INTEGERP (w
->base_line_pos
))
1050 && height
!= XFASTINT (w
->height
))
1051 display_mode_line (w
);
1052 if (! line_number_displayed
1053 && ! BUFFERP (w
->base_line_pos
))
1055 w
->base_line_pos
= Qnil
;
1056 w
->base_line_number
= Qnil
;
1059 /* When we reach a frame's selected window, redo the frame's menu bar. */
1060 if (!NILP (w
->update_mode_line
)
1061 && FRAME_MENU_BAR_LINES (f
) > 0
1062 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
1063 display_menu_bar (w
);
1066 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1068 int start
, end
, whole
;
1070 /* Calculate the start and end positions for the current window.
1071 At some point, it would be nice to choose between scrollbars
1072 which reflect the whole buffer size, with special markers
1073 indicating narrowing, and scrollbars which reflect only the
1076 Note that minibuffers sometimes aren't displaying any text. */
1077 if (! MINI_WINDOW_P (w
)
1078 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
1081 start
= startp
- BEGV
;
1082 /* I don't think this is guaranteed to be right. For the
1083 moment, we'll pretend it is. */
1084 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
1086 if (end
< start
) end
= start
;
1087 if (whole
< (end
- start
)) whole
= end
- start
;
1090 start
= end
= whole
= 0;
1092 /* Indicate what this scroll bar ought to be displaying now. */
1093 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
1095 /* Note that we actually used the scroll bar attached to this window,
1096 so it shouldn't be deleted at the end of redisplay. */
1097 (*redeem_scroll_bar_hook
) (w
);
1101 current_buffer
= old
;
1105 /* Do full redisplay on one window, starting at position `pos'. */
1108 try_window (window
, pos
)
1112 register struct window
*w
= XWINDOW (window
);
1113 register int height
= window_internal_height (w
);
1114 register int vpos
= XFASTINT (w
->top
);
1115 register int last_text_vpos
= vpos
;
1116 int tab_offset
= pos_tab_offset (w
, pos
);
1117 FRAME_PTR f
= XFRAME (w
->frame
);
1118 int width
= window_internal_width (w
) - 1;
1119 struct position val
;
1121 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1123 overlay_arrow_seen
= 0;
1124 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1126 while (--height
>= 0)
1128 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, tab_offset
);
1129 tab_offset
+= width
;
1130 if (val
.vpos
) tab_offset
= 0;
1132 if (pos
!= val
.bufpos
)
1134 /* Next line, unless prev line ended in end of buffer with no cr */
1135 = vpos
- (val
.vpos
&& (FETCH_CHAR (val
.bufpos
- 1) != '\n'
1136 || ! NILP (Fget_text_property (val
.bufpos
-1,
1138 Fcurrent_buffer ()))));
1142 /* If last line is continued in middle of character,
1143 include the split character in the text considered on the frame */
1144 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
1147 /* If bottom just moved off end of frame, change mode line percentage. */
1148 if (XFASTINT (w
->window_end_pos
) == 0
1150 w
->update_mode_line
= Qt
;
1152 /* Say where last char on frame will be, once redisplay is finished. */
1153 XFASTINT (w
->window_end_pos
) = Z
- pos
;
1154 XFASTINT (w
->window_end_vpos
) = last_text_vpos
- XFASTINT (w
->top
);
1155 /* But that is not valid info until redisplay finishes. */
1156 w
->window_end_valid
= Qnil
;
1159 /* Try to redisplay when buffer is modified locally,
1160 computing insert/delete line to preserve text outside
1161 the bounds of the changes.
1162 Return 1 if successful, 0 if if cannot tell what to do,
1163 or -1 to tell caller to find a new window start,
1164 or -2 to tell caller to do normal redisplay with same window start. */
1167 try_window_id (window
)
1171 register struct window
*w
= XWINDOW (window
);
1172 register int height
= window_internal_height (w
);
1173 FRAME_PTR f
= XFRAME (w
->frame
);
1174 int top
= XFASTINT (w
->top
);
1175 int start
= marker_position (w
->start
);
1176 int width
= window_internal_width (w
) - 1;
1177 int hscroll
= XINT (w
->hscroll
);
1178 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1180 register int i
, tem
;
1181 int last_text_vpos
= 0;
1184 struct position val
, bp
, ep
, xp
, pp
;
1185 int scroll_amount
= 0;
1187 int tab_offset
, epto
;
1189 if (GPT
- BEG
< beg_unchanged
)
1190 beg_unchanged
= GPT
- BEG
;
1191 if (Z
- GPT
< end_unchanged
)
1192 end_unchanged
= Z
- GPT
;
1194 if (beg_unchanged
+ 1 < start
)
1195 return 0; /* Give up if changes go above top of window */
1197 /* Find position before which nothing is changed. */
1198 bp
= *compute_motion (start
, 0, lmargin
,
1199 beg_unchanged
+ 1, height
+ 1, 0, width
, hscroll
,
1200 pos_tab_offset (w
, start
));
1201 if (bp
.vpos
>= height
)
1203 if (point
< bp
.bufpos
&& !bp
.contin
)
1205 /* All changes are below the frame, and point is on the frame.
1206 We don't need to change the frame at all.
1207 But we need to update window_end_pos to account for
1208 any change in buffer size. */
1209 bp
= *compute_motion (start
, 0, lmargin
,
1211 width
, hscroll
, pos_tab_offset (w
, start
));
1212 XFASTINT (w
->window_end_vpos
) = height
;
1213 XFASTINT (w
->window_end_pos
) = Z
- bp
.bufpos
;
1221 /* Find beginning of that frame line. Must display from there. */
1222 bp
= *vmotion (bp
.bufpos
, 0, width
, hscroll
, window
);
1229 /* If about to start displaying at the beginning of a continuation line,
1230 really start with previous frame line, in case it was not
1231 continued when last redisplayed */
1232 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
1234 /* Likewise if we have to worry about selective display. */
1235 (XTYPE (current_buffer
->selective_display
) == Lisp_Int
1236 && XINT (current_buffer
->selective_display
) > 0
1237 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
1239 bp
= *vmotion (bp
.bufpos
, -1, width
, hscroll
, window
);
1244 if (bp
.contin
&& bp
.hpos
!= lmargin
)
1246 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
1252 /* Find first visible newline after which no more is changed. */
1253 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
1254 if (XTYPE (current_buffer
->selective_display
) == Lisp_Int
1255 && XINT (current_buffer
->selective_display
) > 0)
1257 && (position_indentation (tem
)
1258 >= XINT (current_buffer
->selective_display
)))
1259 tem
= find_next_newline (tem
, 1);
1261 /* Compute the cursor position after that newline. */
1262 ep
= *compute_motion (pos
, vpos
, val
.hpos
, tem
,
1263 height
, - (1 << (SHORTBITS
- 1)),
1264 width
, hscroll
, pos_tab_offset (w
, bp
.bufpos
));
1266 /* If changes reach past the text available on the frame,
1267 just display rest of frame. */
1268 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
1271 stop_vpos
= ep
.vpos
;
1273 /* If no newline before ep, the line ep is on includes some changes
1274 that must be displayed. Make sure we don't stop before it. */
1275 /* Also, if changes reach all the way until ep.bufpos,
1276 it is possible that something was deleted after the
1277 newline before it, so the following line must be redrawn. */
1278 if (stop_vpos
== ep
.vpos
1279 && (ep
.bufpos
== BEGV
1280 || FETCH_CHAR (ep
.bufpos
- 1) != '\n'
1281 || ep
.bufpos
== Z
- end_unchanged
))
1282 stop_vpos
= ep
.vpos
+ 1;
1285 overlay_arrow_seen
= 0;
1287 /* If changes do not reach to bottom of window,
1288 figure out how much to scroll the rest of the window */
1289 if (stop_vpos
< height
)
1291 /* Now determine how far up or down the rest of the window has moved */
1292 epto
= pos_tab_offset (w
, ep
.bufpos
);
1293 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1294 Z
- XFASTINT (w
->window_end_pos
),
1295 10000, 0, width
, hscroll
, epto
);
1296 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
1298 /* Is everything on frame below the changes whitespace?
1299 If so, no scrolling is really necessary. */
1300 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
1302 tem
= FETCH_CHAR (i
);
1303 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
1309 XFASTINT (w
->window_end_vpos
) += scroll_amount
;
1311 /* Before doing any scrolling, verify that point will be on frame. */
1312 if (point
> ep
.bufpos
&& !(point
<= xp
.bufpos
&& xp
.bufpos
< height
))
1314 if (point
<= xp
.bufpos
)
1316 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1317 point
, height
, - (1 << (SHORTBITS
- 1)),
1318 width
, hscroll
, epto
);
1322 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
,
1323 point
, height
, - (1 << (SHORTBITS
- 1)),
1324 width
, hscroll
, pos_tab_offset (w
, xp
.bufpos
));
1326 if (pp
.bufpos
< point
|| pp
.vpos
== height
)
1328 cursor_vpos
= pp
.vpos
+ top
;
1329 cursor_hpos
= pp
.hpos
+ XFASTINT (w
->left
);
1332 if (stop_vpos
- scroll_amount
>= height
1333 || ep
.bufpos
== xp
.bufpos
)
1335 if (scroll_amount
< 0)
1336 stop_vpos
-= scroll_amount
;
1338 /* In this path, we have altered window_end_vpos
1339 and not left it negative.
1340 We must make sure that, in case display is preempted
1341 before the frame changes to reflect what we do here,
1342 further updates will not come to try_window_id
1343 and assume the frame and window_end_vpos match. */
1344 blank_end_of_window
= 1;
1346 else if (!scroll_amount
)
1348 else if (bp
.bufpos
== Z
- end_unchanged
)
1350 /* If reprinting everything is nearly as fast as scrolling,
1351 don't bother scrolling. Can happen if lines are short. */
1352 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
1353 top
+ height
- max (0, scroll_amount
),
1355 > xp
.bufpos
- bp
.bufpos
- 20)
1356 /* Return "try normal display with same window-start."
1357 Too bad we can't prevent further scroll-thinking. */
1359 /* If pure deletion, scroll up as many lines as possible.
1360 In common case of killing a line, this can save the
1361 following line from being overwritten by scrolling
1362 and therefore having to be redrawn. */
1363 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
1364 top
+ height
- max (0, scroll_amount
),
1366 if (!tem
) stop_vpos
= height
;
1368 else if (scroll_amount
)
1370 /* If reprinting everything is nearly as fast as scrolling,
1371 don't bother scrolling. Can happen if lines are short. */
1372 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
1373 overestimate of cost of reprinting, since xp.bufpos
1374 would end up below the bottom of the window. */
1375 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
1376 top
+ height
- max (0, scroll_amount
),
1378 > xp
.bufpos
- ep
.bufpos
- 20)
1379 /* Return "try normal display with same window-start."
1380 Too bad we can't prevent further scroll-thinking. */
1382 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
1383 top
+ height
- max (0, scroll_amount
),
1385 if (!tem
) stop_vpos
= height
;
1389 /* In any case, do not display past bottom of window */
1390 if (stop_vpos
>= height
)
1396 /* Handle case where pos is before w->start --
1397 can happen if part of line had been clipped and is not clipped now */
1398 if (vpos
== 0 && pos
< marker_position (w
->start
))
1399 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1401 /* Redisplay the lines where the text was changed */
1402 last_text_vpos
= vpos
;
1403 tab_offset
= pos_tab_offset (w
, pos
);
1404 /* If we are starting display in mid-character, correct tab_offset
1405 to account for passing the line that that character really starts in. */
1406 if (val
.hpos
< lmargin
)
1407 tab_offset
+= width
;
1408 while (vpos
< stop_vpos
)
1410 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1411 tab_offset
+= width
;
1412 if (val
.vpos
) tab_offset
= 0;
1413 if (pos
!= val
.bufpos
)
1415 /* Next line, unless prev line ended in end of buffer with no cr */
1416 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
1420 /* There are two cases:
1421 1) we have displayed down to the bottom of the window
1422 2) we have scrolled lines below stop_vpos by scroll_amount */
1426 /* If last line is continued in middle of character,
1427 include the split character in the text considered on the frame */
1428 if (val
.hpos
< lmargin
)
1430 XFASTINT (w
->window_end_vpos
) = last_text_vpos
;
1431 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1434 /* If scrolling made blank lines at window bottom,
1435 redisplay to fill those lines */
1436 if (scroll_amount
< 0)
1438 /* Don't consider these lines for general-purpose scrolling.
1439 That will save time in the scrolling computation. */
1440 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
1445 vpos
= height
+ scroll_amount
;
1446 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
1448 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
1452 blank_end_of_window
= 1;
1453 tab_offset
= pos_tab_offset (w
, pos
);
1454 /* If we are starting display in mid-character, correct tab_offset
1455 to account for passing the line that that character starts in. */
1456 if (val
.hpos
< lmargin
)
1457 tab_offset
+= width
;
1459 while (vpos
< height
)
1461 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1462 tab_offset
+= width
;
1463 if (val
.vpos
) tab_offset
= 0;
1467 /* Here is a case where display_text_line sets cursor_vpos wrong.
1468 Make it be fixed up, below. */
1470 && xp
.bufpos
== point
)
1474 /* If bottom just moved off end of frame, change mode line percentage. */
1475 if (XFASTINT (w
->window_end_pos
) == 0
1477 w
->update_mode_line
= Qt
;
1479 /* Attempt to adjust end-of-text positions to new bottom line */
1482 delta
= height
- xp
.vpos
;
1484 || (delta
> 0 && xp
.bufpos
<= ZV
)
1485 || (delta
== 0 && xp
.hpos
))
1487 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1488 delta
, width
, hscroll
, window
);
1489 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1490 XFASTINT (w
->window_end_vpos
) += val
.vpos
;
1494 w
->window_end_valid
= Qnil
;
1496 /* If point was not in a line that was displayed, find it */
1497 if (cursor_vpos
< 0)
1499 val
= *compute_motion (start
, 0, lmargin
, point
, 10000, 10000,
1500 width
, hscroll
, pos_tab_offset (w
, start
));
1501 /* Admit failure if point is off frame now */
1502 if (val
.vpos
>= height
)
1504 for (vpos
= 0; vpos
< height
; vpos
++)
1505 cancel_line (vpos
+ top
, f
);
1508 cursor_vpos
= val
.vpos
+ top
;
1509 cursor_hpos
= val
.hpos
+ XFASTINT (w
->left
);
1512 FRAME_CURSOR_X (f
) = max (0, cursor_hpos
);
1513 FRAME_CURSOR_Y (f
) = cursor_vpos
;
1517 val
= *compute_motion (start
, 0, lmargin
, ZV
,
1518 height
, - (1 << (SHORTBITS
- 1)),
1519 width
, hscroll
, pos_tab_offset (w
, start
));
1520 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
1522 if (XFASTINT (w
->window_end_pos
)
1530 /* Mark a section of BUF as modified, but only for the sake of redisplay.
1531 This is useful for recording changes to overlays.
1533 We increment the buffer's modification timestamp and set the
1534 redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
1535 as if the region of text between START and END had been modified;
1536 the redisplay code will check this against the windows' timestamps,
1537 and redraw the appropriate area of the buffer.
1539 However, if the buffer is unmodified, we bump the last-save
1540 timestamp as well, so that incrementing the timestamp doesn't fool
1541 Emacs into thinking that the buffer's text has been modified.
1543 Tweaking the timestamps shouldn't hurt the first-modification
1544 timestamps recorded in the undo records; those values aren't
1545 written until just before a real text modification is made, so they
1546 will never catch the timestamp value just before this function gets
1550 redisplay_region (buf
, start
, end
)
1560 start
= end
; end
= temp
;
1563 if (buf
!= current_buffer
)
1564 windows_or_buffers_changed
= 1;
1567 if (unchanged_modified
== MODIFF
)
1569 beg_unchanged
= start
- BEG
;
1570 end_unchanged
= Z
- end
;
1574 if (Z
- end
< end_unchanged
)
1575 end_unchanged
= Z
- end
;
1576 if (start
- BEG
< beg_unchanged
)
1577 beg_unchanged
= start
- BEG
;
1581 /* Increment the buffer's time stamp, but also increment the save
1582 and autosave timestamps, so as not to screw up that timekeeping. */
1583 if (BUF_MODIFF (buf
) == buf
->save_modified
)
1584 buf
->save_modified
++;
1585 if (BUF_MODIFF (buf
) == buf
->auto_save_modified
)
1586 buf
->auto_save_modified
++;
1588 BUF_MODIFF (buf
) ++;
1592 /* Copy glyphs from the vector FROM to the rope T.
1593 But don't actually copy the parts that would come in before S.
1594 Value is T, advanced past the copied data. */
1597 copy_rope (t
, s
, from
, face
)
1598 register GLYPH
*t
; /* Copy to here. */
1599 register GLYPH
*s
; /* Starting point. */
1600 Lisp_Object from
; /* Data to copy; known to be a vector. */
1601 int face
; /* Face to apply to glyphs which don't specify one. */
1603 register int n
= XVECTOR (from
)->size
;
1604 register Lisp_Object
*f
= XVECTOR (from
)->contents
;
1608 int glyph
= XFASTINT (*f
);
1610 if (t
>= s
) *t
= MAKE_GLYPH (GLYPH_CHAR (glyph
),
1612 ? GLYPH_FACE (glyph
)
1620 /* Copy exactly LEN glyphs from FROM into data at T.
1621 But don't alter words before S. */
1624 copy_part_of_rope (t
, s
, from
, len
, face
)
1625 register GLYPH
*t
; /* Copy to here. */
1626 register GLYPH
*s
; /* Starting point. */
1627 Lisp_Object
*from
; /* Data to copy. */
1629 int face
; /* Face to apply to glyphs which don't specify one. */
1632 register Lisp_Object
*f
= from
;
1636 int glyph
= XFASTINT (*f
);
1638 if (t
>= s
) *t
= MAKE_GLYPH (GLYPH_CHAR (glyph
),
1640 ? GLYPH_FACE (glyph
)
1648 /* Display one line of window w, starting at position START in W's buffer.
1649 Display starting at horizontal position HPOS, which is normally zero
1650 or negative. A negative value causes output up to hpos = 0 to be discarded.
1651 This is done for negative hscroll, or when this is a continuation line
1652 and the continuation occurred in the middle of a multi-column character.
1654 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
1656 Display on position VPOS on the frame. (origin 0).
1658 Returns a STRUCT POSITION giving character to start next line with
1659 and where to display it, including a zero or negative hpos.
1660 The vpos field is not really a vpos; it is 1 unless the line is continued */
1662 struct position val_display_text_line
;
1664 static struct position
*
1665 display_text_line (w
, start
, vpos
, hpos
, taboffset
)
1672 register int pos
= start
;
1677 register unsigned char *p
;
1679 register GLYPH
*startp
;
1680 register GLYPH
*p1prev
= 0;
1681 FRAME_PTR f
= XFRAME (w
->frame
);
1682 int tab_width
= XINT (current_buffer
->tab_width
);
1683 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1684 int width
= window_internal_width (w
) - 1;
1685 struct position val
;
1688 int hscroll
= XINT (w
->hscroll
);
1689 int truncate
= hscroll
1690 || (truncate_partial_width_windows
1691 && XFASTINT (w
->width
) < FRAME_WIDTH (f
))
1692 || !NILP (current_buffer
->truncate_lines
);
1694 /* 1 if we should highlight the region. */
1695 int highlight_region
1696 = !NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
);
1697 int region_beg
, region_end
;
1700 = XTYPE (current_buffer
->selective_display
) == Lisp_Int
1701 ? XINT (current_buffer
->selective_display
)
1702 : !NILP (current_buffer
->selective_display
) ? -1 : 0;
1703 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
1704 register struct Lisp_Vector
*dp
= window_display_table (w
);
1706 Lisp_Object default_invis_vector
[3];
1707 /* Nonzero means display something where there are invisible lines.
1708 The precise value is the number of glyphs to display. */
1710 = (selective
&& dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1711 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
1712 : selective
&& !NILP (current_buffer
->selective_display_ellipses
)
1714 /* This is the sequence of Lisp objects to display
1715 when there are invisible lines. */
1716 Lisp_Object
*invis_vector_contents
1717 = (dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1718 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
1719 : default_invis_vector
);
1721 GLYPH truncator
= (dp
== 0 || XTYPE (DISP_TRUNC_GLYPH (dp
)) != Lisp_Int
1722 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
1723 GLYPH continuer
= (dp
== 0 || XTYPE (DISP_CONTINUE_GLYPH (dp
)) != Lisp_Int
1724 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
1726 /* The next buffer location at which the face should change, due
1727 to overlays or text property changes. */
1728 int next_face_change
;
1730 #ifdef USE_TEXT_PROPERTIES
1731 /* The next location where the `invisible' property changes */
1735 /* The face we're currently using. */
1736 int current_face
= 0;
1738 XFASTINT (default_invis_vector
[2]) = '.';
1739 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
1741 hpos
+= XFASTINT (w
->left
);
1742 get_display_line (f
, vpos
, XFASTINT (w
->left
));
1743 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
1745 /* Show where to highlight the region. */
1746 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
1747 /* Maybe highlight only in selected window. */
1748 && (highlight_nonselected_windows
1749 || w
== XWINDOW (selected_window
)))
1751 region_beg
= marker_position (current_buffer
->mark
);
1752 if (PT
< region_beg
)
1754 region_end
= region_beg
;
1759 w
->region_showing
= Qt
;
1762 region_beg
= region_end
= -1;
1764 if (MINI_WINDOW_P (w
) && start
== 1
1765 && vpos
== XFASTINT (w
->top
))
1768 hpos
= display_string (w
, vpos
, minibuf_prompt
, hpos
,
1769 (!truncate
? continuer
: truncator
),
1771 minibuf_prompt_width
= hpos
;
1774 desired_glyphs
->bufp
[vpos
] = pos
;
1775 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
1777 startp
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
1778 endp
= startp
+ width
;
1780 /* Arrange the overlays nicely for our purposes. Usually, we call
1781 display_text_line on only one line at a time, in which case this
1782 can't really hurt too much, or we call it on lines which appear
1783 one after another in the buffer, in which case all calls to
1784 recenter_overlay_lists but the first will be pretty cheap. */
1785 recenter_overlay_lists (current_buffer
, pos
);
1787 /* Loop generating characters.
1788 Stop at end of buffer, before newline,
1789 if reach or pass continuation column,
1790 or at face change. */
1792 next_face_change
= pos
;
1793 #ifdef USE_TEXT_PROPERTIES
1794 next_invisible
= pos
;
1801 /* Did we hit the end of the visible region of the buffer?
1806 /* Did we reach point? Record the cursor location. */
1807 if (pos
== point
&& cursor_vpos
< 0)
1810 cursor_hpos
= p1
- startp
;
1813 #ifdef USE_TEXT_PROPERTIES
1814 /* if the `invisible' property is set to t, we can skip to
1815 the next property change */
1816 while (pos
== next_invisible
&& pos
< end
)
1818 Lisp_Object position
, limit
, endpos
, prop
;
1819 XFASTINT (position
) = pos
;
1820 prop
= Fget_text_property (position
, Qinvisible
,
1821 Fcurrent_buffer ());
1822 /* This is just an estimate to give reasonable
1823 performance; nothing should go wrong if it is too small. */
1824 XFASTINT (limit
) = pos
+ 50;
1826 = Fnext_single_property_change (position
, Qinvisible
,
1827 Fcurrent_buffer (), limit
);
1828 if (INTEGERP (endpos
))
1829 next_invisible
= XINT (endpos
);
1831 next_invisible
= end
;
1834 if (pos
< point
&& next_invisible
>= point
)
1837 cursor_hpos
= p1
- startp
;
1839 pos
= next_invisible
;
1846 #ifdef HAVE_X_WINDOWS
1847 /* Did we hit a face change? Figure out what face we should
1848 use now. We also hit this the first time through the
1849 loop, to see what face we should start with. */
1850 if (pos
>= next_face_change
&& FRAME_X_P (f
))
1851 current_face
= compute_char_face (f
, w
, pos
,
1852 region_beg
, region_end
,
1853 &next_face_change
, pos
+ 50);
1858 #ifdef USE_TEXT_PROPERTIES
1859 if (pos
< next_invisible
&& next_invisible
< pause
)
1860 pause
= next_invisible
;
1862 if (pos
< next_face_change
&& next_face_change
< pause
)
1863 pause
= next_face_change
;
1865 /* Wouldn't you hate to read the next line to someone over
1867 if (pos
< point
&& point
< pause
)
1869 if (pos
< GPT
&& GPT
< pause
)
1872 p
= &FETCH_CHAR (pos
);
1875 if (c
>= 040 && c
< 0177
1876 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
1879 *p1
= MAKE_GLYPH (c
, current_face
);
1887 && position_indentation (pos
+ 1) >= selective
)
1890 pos
= find_next_newline (pos
+ 1, 1);
1891 if (FETCH_CHAR (pos
- 1) == '\n')
1894 if (invis
&& selective_rlen
> 0 && p1
>= startp
)
1896 p1
+= selective_rlen
;
1897 if (p1
- startp
> width
)
1899 copy_part_of_rope (p1prev
, p1prev
, invis_vector_contents
,
1900 (p1
- p1prev
), current_face
);
1903 /* Draw the face of the newline character as extending all the
1904 way to the end of the frame line. */
1907 *p1
++ = MAKE_GLYPH (' ', current_face
);
1915 if (p1
>= startp
&& p1
< endp
)
1916 *p1
= MAKE_GLYPH (' ', current_face
);
1919 while ((p1
- startp
+ taboffset
+ hscroll
- (hscroll
> 0))
1922 else if (c
== Ctl ('M') && selective
== -1)
1924 pos
= find_next_newline (pos
, 1);
1925 if (FETCH_CHAR (pos
- 1) == '\n')
1927 if (selective_rlen
> 0)
1929 p1
+= selective_rlen
;
1930 if (p1
- startp
> width
)
1932 copy_part_of_rope (p1prev
, p1prev
, invis_vector_contents
,
1933 (p1
- p1prev
), current_face
);
1936 /* Draw the face of the newline character as extending all the
1937 way to the end of the frame line. */
1940 *p1
++ = MAKE_GLYPH (' ', current_face
);
1944 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
1946 p1
= copy_rope (p1
, startp
, DISP_CHAR_VECTOR (dp
, c
), current_face
);
1948 else if (c
< 0200 && ctl_arrow
)
1951 *p1
= MAKE_GLYPH ((dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
1952 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
1955 if (p1
>= startp
&& p1
< endp
)
1956 *p1
= MAKE_GLYPH (c
^ 0100, current_face
);
1962 *p1
= MAKE_GLYPH ((dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
1963 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
1966 if (p1
>= startp
&& p1
< endp
)
1967 *p1
= MAKE_GLYPH ((c
>> 6) + '0', current_face
);
1969 if (p1
>= startp
&& p1
< endp
)
1970 *p1
= MAKE_GLYPH ((7 & (c
>> 3)) + '0', current_face
);
1972 if (p1
>= startp
&& p1
< endp
)
1973 *p1
= MAKE_GLYPH ((7 & c
) + '0', current_face
);
1980 val
.hpos
= - XINT (w
->hscroll
);
1988 /* Handle continuation in middle of a character */
1989 /* by backing up over it */
1992 /* Don't back up if we never actually displayed any text.
1993 This occurs when the minibuffer prompt takes up the whole line. */
1996 /* Start the next line with that same character */
1998 /* but at negative hpos, to skip the columns output on this line. */
1999 val
.hpos
+= p1prev
- endp
;
2002 /* Keep in this line everything up to the continuation column. */
2006 /* Finish deciding which character to start the next line on,
2007 and what hpos to start it at.
2008 Also set `lastpos' to the last position which counts as "on this line"
2009 for cursor-positioning. */
2013 if (FETCH_CHAR (pos
) == '\n')
2014 /* If stopped due to a newline, start next line after it */
2017 /* Stopped due to right margin of window */
2022 /* Truncating => start next line after next newline,
2023 and point is on this line if it is before the newline,
2024 and skip none of first char of next line */
2025 pos
= find_next_newline (pos
, 1);
2026 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
2028 lastpos
= pos
- (FETCH_CHAR (pos
- 1) == '\n');
2039 /* If point is at eol or in invisible text at eol,
2040 record its frame location now. */
2042 if (start
<= point
&& point
<= lastpos
&& cursor_vpos
< 0)
2045 cursor_hpos
= p1
- startp
;
2048 if (cursor_vpos
== vpos
)
2050 if (cursor_hpos
< 0) cursor_hpos
= 0;
2051 if (cursor_hpos
> width
) cursor_hpos
= width
;
2052 cursor_hpos
+= XFASTINT (w
->left
);
2053 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
2055 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2056 FRAME_CURSOR_X (f
) = cursor_hpos
;
2058 if (w
== XWINDOW (selected_window
))
2060 /* Line is not continued and did not start
2061 in middle of character */
2062 if ((hpos
- XFASTINT (w
->left
)
2063 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2066 this_line_bufpos
= start
;
2067 this_line_buffer
= current_buffer
;
2068 this_line_vpos
= cursor_vpos
;
2069 this_line_start_hpos
= hpos
;
2070 this_line_endpos
= Z
- lastpos
;
2073 this_line_bufpos
= 0;
2078 /* If hscroll and line not empty, insert truncation-at-left marker */
2079 if (hscroll
&& lastpos
!= start
)
2081 *startp
= truncator
;
2086 if (XFASTINT (w
->width
) + XFASTINT (w
->left
) != FRAME_WIDTH (f
))
2089 if (p1
< startp
) p1
= startp
;
2090 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
2092 /* Don't draw vertical bars if we're using scroll bars. They're
2093 covered up by the scroll bars, and it's distracting to see
2094 them when the scroll bar windows are flickering around to be
2096 *p1
++ = (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
2099 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
2100 p1
- desired_glyphs
->glyphs
[vpos
]);
2101 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2103 /* If the start of this line is the overlay arrow-position,
2104 then put the arrow string into the display-line. */
2106 if (XTYPE (Voverlay_arrow_position
) == Lisp_Marker
2107 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
2108 && start
== marker_position (Voverlay_arrow_position
)
2109 && XTYPE (Voverlay_arrow_string
) == Lisp_String
2110 && ! overlay_arrow_seen
)
2112 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
2114 int len
= XSTRING (Voverlay_arrow_string
)->size
;
2119 for (i
= 0; i
< len
; i
++)
2122 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
2123 arrow_end
= (startp
- desired_glyphs
->glyphs
[vpos
]) + len
;
2124 if (desired_glyphs
->used
[vpos
] < arrow_end
)
2125 desired_glyphs
->used
[vpos
] = arrow_end
;
2127 overlay_arrow_seen
= 1;
2131 val_display_text_line
= val
;
2132 return &val_display_text_line
;
2135 /* Redisplay the menu bar in the frame for window W. */
2138 display_menu_bar (w
)
2141 Lisp_Object items
, tail
;
2142 register int vpos
= 0;
2143 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2144 int maxendcol
= FRAME_WIDTH (f
);
2147 if (FRAME_MENU_BAR_LINES (f
) <= 0)
2150 get_display_line (f
, vpos
, 0);
2152 /* If the user has switched buffers or windows, we need to
2153 recompute to reflect the new bindings. But we'll
2154 recompute when update_mode_lines is set too; that means
2155 that people can use force-mode-line-update to request
2156 that the menu bar be recomputed. The adverse effect on
2157 the rest of the redisplay algorithm is about the same as
2158 windows_or_buffers_changed anyway. */
2159 if (windows_or_buffers_changed
2160 || update_mode_lines
2161 || (XFASTINT (w
->last_modified
) < MODIFF
2162 && (XFASTINT (w
->last_modified
)
2163 <= XBUFFER (w
->buffer
)->save_modified
)))
2165 struct buffer
*prev
= current_buffer
;
2166 current_buffer
= XBUFFER (w
->buffer
);
2167 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items ();
2168 current_buffer
= prev
;
2171 for (tail
= FRAME_MENU_BAR_ITEMS (f
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2175 string
= XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->car
;
2177 /* Record in each item its hpos. */
2178 XFASTINT (XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->cdr
) = hpos
;
2180 if (hpos
< maxendcol
)
2181 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
2182 XSTRING (string
)->data
,
2183 hpos
, 0, hpos
, maxendcol
);
2184 /* Put a gap of 3 spaces between items. */
2185 if (hpos
< maxendcol
)
2187 int hpos1
= hpos
+ 3;
2188 hpos
= display_string (w
, vpos
, "", hpos
, 0,
2189 min (hpos1
, maxendcol
), maxendcol
);
2193 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2194 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2196 /* Fill out the line with spaces. */
2197 if (maxendcol
> hpos
)
2198 hpos
= display_string (w
, vpos
, "", hpos
, 0, maxendcol
, -1);
2200 /* Clear the rest of the lines allocated to the menu bar. */
2202 while (vpos
< FRAME_MENU_BAR_LINES (f
))
2203 get_display_line (f
, vpos
++, 0);
2206 /* Display the mode line for window w */
2209 display_mode_line (w
)
2212 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
2213 register int left
= XFASTINT (w
->left
);
2214 register int right
= XFASTINT (w
->width
) + left
;
2215 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2217 line_number_displayed
= 0;
2219 get_display_line (f
, vpos
, left
);
2220 display_mode_element (w
, vpos
, left
, 0, right
, right
,
2221 current_buffer
->mode_line_format
);
2222 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2224 /* Make the mode line inverse video if the entire line
2225 is made of mode lines.
2226 I.e. if this window is full width,
2227 or if it is the child of a full width window
2228 (which implies that that window is split side-by-side
2229 and the rest of this line is mode lines of the sibling windows). */
2230 if (XFASTINT (w
->width
) == FRAME_WIDTH (f
)
2231 || XFASTINT (XWINDOW (w
->parent
)->width
) == FRAME_WIDTH (f
))
2232 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2234 #ifdef HAVE_X_WINDOWS
2235 /* I'm trying this out because I saw Unimpress use it, but it's
2236 possible that this may mess adversely with some window managers. -jla
2238 Wouldn't it be nice to use something like mode-line-format to
2239 describe frame titles? -JimB */
2241 /* Change the title of the frame to the name of the buffer displayed
2242 in the currently selected window. Don't do this for minibuffer frames,
2243 and don't do it when there's only one non-minibuffer frame. */
2245 && ! FRAME_MINIBUF_ONLY_P (f
)
2246 && w
== XWINDOW (f
->selected_window
))
2247 x_implicitly_set_name (f
, (EQ (Fnext_frame (WINDOW_FRAME (w
), Qnil
),
2250 : XBUFFER (w
->buffer
)->name
),
2255 /* Contribute ELT to the mode line for window W.
2256 How it translates into text depends on its data type.
2258 VPOS is the position of the mode line being displayed.
2260 HPOS is the position (absolute on frame) where this element's text
2261 should start. The output is truncated automatically at the right
2264 DEPTH is the depth in recursion. It is used to prevent
2265 infinite recursion here.
2267 MINENDCOL is the hpos before which the element may not end.
2268 The element is padded at the right with spaces if nec
2269 to reach this column.
2271 MAXENDCOL is the hpos past which this element may not extend.
2272 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
2273 (This is necessary to make nested padding and truncation work.)
2275 Returns the hpos of the end of the text generated by ELT.
2276 The next element will receive that value as its HPOS arg,
2277 so as to concatenate the elements. */
2280 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
2282 register int vpos
, hpos
;
2285 register int maxendcol
;
2286 register Lisp_Object elt
;
2294 #ifdef SWITCH_ENUM_BUG
2295 switch ((int) XTYPE (elt
))
2297 switch (XTYPE (elt
))
2302 /* A string: output it and check for %-constructs within it. */
2303 register unsigned char c
;
2304 register unsigned char *this = XSTRING (elt
)->data
;
2306 while (hpos
< maxendcol
&& *this)
2308 unsigned char *last
= this;
2309 while ((c
= *this++) != '\0' && c
!= '%')
2311 if (this - 1 != last
)
2313 register int lim
= --this - last
+ hpos
;
2314 hpos
= display_string (w
, vpos
, last
, hpos
, 0, hpos
,
2315 min (lim
, maxendcol
));
2319 register int spec_width
= 0;
2321 /* We can't allow -ve args due to the "%-" construct */
2322 /* Argument specifies minwidth but not maxwidth
2323 (maxwidth can be specified by
2324 (<negative-number> . <stuff>) mode-line elements) */
2326 while ((c
= *this++) >= '0' && c
<= '9')
2328 spec_width
= spec_width
* 10 + (c
- '0');
2332 if (spec_width
> maxendcol
)
2333 spec_width
= maxendcol
;
2336 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2337 spec_width
, maxendcol
,
2338 Vglobal_mode_string
);
2340 hpos
= display_string (w
, vpos
,
2341 decode_mode_spec (w
, c
,
2343 hpos
, 0, spec_width
, maxendcol
);
2350 /* A symbol: process the value of the symbol recursively
2351 as if it appeared here directly. Avoid error if symbol void.
2352 Special case: if value of symbol is a string, output the string
2355 register Lisp_Object tem
;
2356 tem
= Fboundp (elt
);
2359 tem
= Fsymbol_value (elt
);
2360 /* If value is a string, output that string literally:
2361 don't check for % within it. */
2362 if (XTYPE (tem
) == Lisp_String
)
2363 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
2364 hpos
, 0, minendcol
, maxendcol
);
2365 /* Give up right away for nil or t. */
2366 else if (!EQ (tem
, elt
))
2367 { elt
= tem
; goto tail_recurse
; }
2374 register Lisp_Object car
, tem
;
2376 /* A cons cell: three distinct cases.
2377 If first element is a string or a cons, process all the elements
2378 and effectively concatenate them.
2379 If first element is a negative number, truncate displaying cdr to
2380 at most that many characters. If positive, pad (with spaces)
2381 to at least that many characters.
2382 If first element is a symbol, process the cadr or caddr recursively
2383 according to whether the symbol's value is non-nil or nil. */
2384 car
= XCONS (elt
)->car
;
2385 if (XTYPE (car
) == Lisp_Symbol
)
2387 tem
= Fboundp (car
);
2388 elt
= XCONS (elt
)->cdr
;
2389 if (XTYPE (elt
) != Lisp_Cons
)
2391 /* elt is now the cdr, and we know it is a cons cell.
2392 Use its car if CAR has a non-nil value. */
2395 tem
= Fsymbol_value (car
);
2397 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
2399 /* Symbol's value is nil (or symbol is unbound)
2400 Get the cddr of the original list
2401 and if possible find the caddr and use that. */
2402 elt
= XCONS (elt
)->cdr
;
2405 else if (XTYPE (elt
) != Lisp_Cons
)
2407 elt
= XCONS (elt
)->car
;
2410 else if (XTYPE (car
) == Lisp_Int
)
2412 register int lim
= XINT (car
);
2413 elt
= XCONS (elt
)->cdr
;
2415 /* Negative int means reduce maximum width.
2416 DO NOT change MINENDCOL here!
2417 (20 -10 . foo) should truncate foo to 10 col
2418 and then pad to 20. */
2419 maxendcol
= min (maxendcol
, hpos
- lim
);
2422 /* Padding specified. Don't let it be more than
2425 if (lim
> maxendcol
)
2427 /* If that's more padding than already wanted, queue it.
2428 But don't reduce padding already specified even if
2429 that is beyond the current truncation point. */
2430 if (lim
> minendcol
)
2435 else if (XTYPE (car
) == Lisp_String
|| XTYPE (car
) == Lisp_Cons
)
2437 register int limit
= 50;
2438 /* LIMIT is to protect against circular lists. */
2439 while (XTYPE (elt
) == Lisp_Cons
&& --limit
> 0
2440 && hpos
< maxendcol
)
2442 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2445 elt
= XCONS (elt
)->cdr
;
2453 return (display_string (w
, vpos
, "*invalid*", hpos
, 0,
2454 minendcol
, maxendcol
));
2458 if (minendcol
> hpos
)
2459 hpos
= display_string (w
, vpos
, "", hpos
, 0, minendcol
, -1);
2463 /* Return a string for the output of a mode line %-spec for window W,
2464 generated by character C and width MAXWIDTH. */
2466 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
2469 decode_mode_spec (w
, c
, maxwidth
)
2472 register int maxwidth
;
2474 Lisp_Object obj
= Qnil
;
2475 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2476 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
2478 if (maxwidth
> FRAME_WIDTH (f
))
2479 maxwidth
= FRAME_WIDTH (f
);
2484 obj
= current_buffer
->name
;
2486 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
2488 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
2489 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
2490 decode_mode_spec_buf
[maxwidth
] = '\0';
2491 return decode_mode_spec_buf
;
2497 obj
= current_buffer
->filename
;
2501 else if (XTYPE (obj
) == Lisp_String
&& XSTRING (obj
)->size
> maxwidth
)
2503 bcopy ("...", decode_mode_spec_buf
, 3);
2504 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
2505 decode_mode_spec_buf
+ 3, maxwidth
- 3);
2506 return decode_mode_spec_buf
;
2513 int startpos
= marker_position (w
->start
);
2514 int line
, linepos
, topline
;
2517 int height
= XFASTINT (w
->height
);
2519 /* If we decided that this buffer isn't suitable for line numbers,
2520 don't forget that too fast. */
2521 if (EQ (w
->base_line_pos
, w
->buffer
))
2524 /* If the buffer is very big, don't waste time. */
2525 if (ZV
- BEGV
> line_number_display_limit
)
2527 w
->base_line_pos
= Qnil
;
2528 w
->base_line_number
= Qnil
;
2532 if (!NILP (w
->base_line_number
)
2533 && !NILP (w
->base_line_pos
)
2534 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
2536 line
= XFASTINT (w
->base_line_number
);
2537 linepos
= XFASTINT (w
->base_line_pos
);
2545 /* Count lines from base line to window start position. */
2546 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
2548 topline
= nlines
+ line
;
2550 /* Determine a new base line, if the old one is too close
2551 or too far away, or if we did not have one.
2552 "Too close" means it's plausible a scroll-down would
2554 if (startpos
== BEGV
)
2556 XFASTINT (w
->base_line_number
) = topline
;
2557 XFASTINT (w
->base_line_pos
) = BEGV
;
2559 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
2564 int distance
= (height
* 2 + 30) * 200;
2566 if (startpos
- distance
> limit
)
2567 limit
= startpos
- distance
;
2569 nlines
= display_count_lines (startpos
, limit
,
2572 /* If we couldn't find the lines we wanted within
2574 give up on line numbers for this window. */
2575 if (position
== startpos
- distance
)
2577 w
->base_line_pos
= w
->buffer
;
2578 w
->base_line_number
= Qnil
;
2582 XFASTINT (w
->base_line_number
) = topline
- nlines
;
2583 XFASTINT (w
->base_line_pos
) = position
;
2586 /* Now count lines from the start pos to point. */
2587 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
2589 /* Record that we did display the line number. */
2590 line_number_displayed
= 1;
2592 /* Make the string to show. */
2593 sprintf (decode_mode_spec_buf
, "%d", topline
+ nlines
);
2594 return decode_mode_spec_buf
;
2599 obj
= current_buffer
->mode_name
;
2603 if (BEGV
> BEG
|| ZV
< Z
)
2608 if (!NILP (current_buffer
->read_only
))
2610 if (MODIFF
> current_buffer
->save_modified
)
2615 /* status of process */
2616 obj
= Fget_buffer_process (Fcurrent_buffer ());
2618 return "no process";
2619 obj
= Fsymbol_name (Fprocess_status (obj
));
2624 int pos
= marker_position (w
->start
);
2625 int total
= ZV
- BEGV
;
2627 if (XFASTINT (w
->window_end_pos
) <= Z
- ZV
)
2634 else if (pos
<= BEGV
)
2638 total
= ((pos
- BEGV
) * 100 + total
- 1) / total
;
2639 /* We can't normally display a 3-digit number,
2640 so get us a 2-digit number that is close. */
2643 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
2644 return decode_mode_spec_buf
;
2656 if (command_loop_level
> 5)
2658 p
= decode_mode_spec_buf
;
2659 for (i
= 0; i
< command_loop_level
; i
++)
2662 return decode_mode_spec_buf
;
2670 if (command_loop_level
> 5)
2672 p
= decode_mode_spec_buf
;
2673 for (i
= 0; i
< command_loop_level
; i
++)
2676 return decode_mode_spec_buf
;
2684 if (maxwidth
< sizeof (lots_of_dashes
))
2685 return lots_of_dashes
;
2688 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
2692 return decode_mode_spec_buf
;
2696 if (XTYPE (obj
) == Lisp_String
)
2697 return (char *) XSTRING (obj
)->data
;
2702 /* Count up to N lines starting from FROM.
2703 But don't go beyond LIMIT.
2704 Return the number of lines thus found (always positive).
2705 Store the position after what was found into *POS_PTR. */
2708 display_count_lines (from
, limit
, n
, pos_ptr
)
2721 *pos_ptr
= scan_buffer ('\n', from
, n
, &shortage
);
2727 /* When scanning backwards, scan_buffer stops *after* the last newline
2728 it finds, but does count it. Compensate for that. */
2729 return - n
- shortage
- (*pos_ptr
!= limit
);
2730 return n
- shortage
;
2733 /* Display STRING on one line of window W, starting at HPOS.
2734 Display at position VPOS. Caller should have done get_display_line.
2735 If VPOS == -1, display it as the current frame's title.
2737 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
2739 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
2740 MAXCOL is the last column ok to end at. Truncate here.
2741 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
2742 Both count from the left edge of the frame, as does HPOS.
2743 The right edge of W is an implicit maximum.
2744 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
2746 Returns ending hpos */
2749 display_string (w
, vpos
, string
, hpos
, truncate
, mincol
, maxcol
)
2751 unsigned char *string
;
2758 int hscroll
= XINT (w
->hscroll
);
2759 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
2760 register GLYPH
*start
;
2761 register GLYPH
*end
;
2762 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2763 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
2764 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2765 int window_width
= XFASTINT (w
->width
);
2767 /* Use the standard display table, not the window's display table.
2768 We don't want the mode line in rot13. */
2769 register struct Lisp_Vector
*dp
= 0;
2771 if (XTYPE (Vstandard_display_table
) == Lisp_Vector
2772 && XVECTOR (Vstandard_display_table
)->size
== DISP_TABLE_SIZE
)
2773 dp
= XVECTOR (Vstandard_display_table
);
2775 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
2778 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
2779 end
= start
+ window_width
- (truncate
!= 0);
2781 if ((window_width
+ XFASTINT (w
->left
)) != FRAME_WIDTH (f
))
2783 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2787 for (i
= 0; i
< VERTICAL_SCROLL_BAR_WIDTH
; i
++)
2794 if (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
)
2795 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
2796 if (maxcol
>= 0 && mincol
> maxcol
)
2803 if (c
>= 040 && c
< 0177
2804 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
2814 if (p1
>= start
&& p1
< end
)
2818 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
2820 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
2821 p1
= copy_rope (p1
, start
, DISP_CHAR_VECTOR (dp
, c
), 0);
2822 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
2825 *p1
= (dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
2826 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^');
2828 if (p1
>= start
&& p1
< end
)
2835 *p1
= (dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
2836 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\');
2838 if (p1
>= start
&& p1
< end
)
2839 *p1
= (c
>> 6) + '0';
2841 if (p1
>= start
&& p1
< end
)
2842 *p1
= (7 & (c
>> 3)) + '0';
2844 if (p1
>= start
&& p1
< end
)
2845 *p1
= (7 & c
) + '0';
2853 if (truncate
) *p1
++ = truncate
;
2855 else if (mincol
>= 0)
2857 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
2863 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
2865 if (len
> desired_glyphs
->used
[vpos
])
2866 desired_glyphs
->used
[vpos
] = len
;
2867 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2876 staticpro (&last_arrow_position
);
2877 staticpro (&last_arrow_string
);
2878 last_arrow_position
= Qnil
;
2879 last_arrow_string
= Qnil
;
2881 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
2882 "String (or mode line construct) included (normally) in `mode-line-format'.");
2883 Vglobal_mode_string
= Qnil
;
2885 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
2886 "Marker for where to display an arrow on top of the buffer text.\n\
2887 This must be the beginning of a line in order to work.\n\
2888 See also `overlay-arrow-string'.");
2889 Voverlay_arrow_position
= Qnil
;
2891 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
2892 "String to display as an arrow. See also `overlay-arrow-position'.");
2893 Voverlay_arrow_string
= Qnil
;
2895 DEFVAR_INT ("scroll-step", &scroll_step
,
2896 "*The number of lines to try scrolling a window by when point moves out.\n\
2897 If that fails to bring point back on frame, point is centered instead.\n\
2898 If this is zero, point is always centered after it moves off frame.");
2900 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
2902 DEFVAR_BOOL ("truncate-partial-width-windows",
2903 &truncate_partial_width_windows
,
2904 "*Non-nil means truncate lines in all windows less than full frame wide.");
2905 truncate_partial_width_windows
= 1;
2907 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
2908 "*Non-nil means use inverse video for the mode line.");
2909 mode_line_inverse_video
= 1;
2911 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
2912 "*Maximum buffer size for which line number should be displayed.");
2913 line_number_display_limit
= 1000000;
2915 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
2916 "*Non-nil means highlight region even in nonselected windows.");
2917 highlight_nonselected_windows
= 1;
2920 /* initialize the window system */
2923 Lisp_Object root_window
;
2924 #ifndef COMPILER_REGISTER_BUG
2926 #endif /* COMPILER_REGISTER_BUG */
2927 struct window
*mini_w
;
2929 this_line_bufpos
= 0;
2931 mini_w
= XWINDOW (minibuf_window
);
2932 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
2934 echo_area_glyphs
= 0;
2935 previous_echo_glyphs
= 0;
2937 if (!noninteractive
)
2939 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
2940 XFASTINT (XWINDOW (root_window
)->top
) = 0;
2941 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
2942 XFASTINT (mini_w
->top
) = FRAME_HEIGHT (f
) - 1;
2943 set_window_height (minibuf_window
, 1, 0);
2945 XFASTINT (XWINDOW (root_window
)->width
) = FRAME_WIDTH (f
);
2946 XFASTINT (mini_w
->width
) = FRAME_WIDTH (f
);