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"
37 extern int interrupt_input
;
38 extern int command_loop_level
;
40 /* Nonzero means print newline before next minibuffer message. */
42 int noninteractive_need_newline
;
44 #define min(a, b) ((a) < (b) ? (a) : (b))
45 #define max(a, b) ((a) > (b) ? (a) : (b))
47 /* The buffer position of the first character appearing
48 entirely or partially on the current frame line.
49 Or zero, which disables the optimization for the current frame line. */
50 static int this_line_bufpos
;
52 /* Number of characters past the end of this line,
53 including the terminating newline */
54 static int this_line_endpos
;
56 /* The vertical position of this frame line. */
57 static int this_line_vpos
;
59 /* Hpos value for start of display on this frame line.
60 Usually zero, but negative if first character really began
62 static int this_line_start_hpos
;
64 /* Buffer that this_line variables are describing. */
65 static struct buffer
*this_line_buffer
;
67 /* Set by try_window_id to the vpos of first of any lines
68 scrolled on to the bottom of the frame. These lines should
69 not be included in any general scroll computation. */
70 static int scroll_bottom_vpos
;
72 /* Value of echo_area_glyphs when it was last acted on.
73 If this is nonzero, there is a message on the frame
74 in the minibuffer and it should be erased as soon
75 as it is no longer requested to appear. */
76 char *previous_echo_glyphs
;
78 /* Nonzero means truncate lines in all windows less wide than the frame */
79 int truncate_partial_width_windows
;
81 Lisp_Object Vglobal_mode_string
;
83 /* Marker for where to display an arrow on top of the buffer text. */
84 Lisp_Object Voverlay_arrow_position
;
86 /* String to display for the arrow. */
87 Lisp_Object Voverlay_arrow_string
;
89 /* Values of those variables at last redisplay. */
90 static Lisp_Object last_arrow_position
, last_arrow_string
;
92 /* Nonzero if overlay arrow has been displayed once in this window. */
93 static int overlay_arrow_seen
;
95 /* Nonzero means highlight the region even in nonselected windows. */
96 static int highlight_nonselected_windows
;
98 /* If cursor motion alone moves point off frame,
99 Try scrolling this many lines up or down if that will bring it back. */
102 /* Nonzero if try_window_id has made blank lines at window bottom
103 since the last redisplay that paused */
104 static int blank_end_of_window
;
106 /* Number of windows showing the buffer of the selected window.
107 keyboard.c refers to this. */
110 /* display_text_line sets these to the frame position (origin 0) of point,
111 whether the window is selected or not.
112 Set one to -1 first to determine whether point was found afterwards. */
114 static int cursor_vpos
;
115 static int cursor_hpos
;
119 /* Nonzero means display mode line highlighted */
120 int mode_line_inverse_video
;
122 static void echo_area_display ();
123 void mark_window_display_accurate ();
124 static void redisplay_windows ();
125 static void redisplay_window ();
126 static void try_window ();
127 static int try_window_id ();
128 static struct position
*display_text_line ();
129 static void display_mode_line ();
130 static int display_mode_element ();
131 static char *fmodetrunc ();
132 static char *decode_mode_spec ();
133 static int display_string ();
134 static void display_menu_bar ();
135 static int display_count_lines ();
137 /* Prompt to display in front of the minibuffer contents */
138 char *minibuf_prompt
;
140 /* Width in columns of current minibuffer prompt. */
141 int minibuf_prompt_width
;
143 /* Message to display instead of minibuffer contents
144 This is what the functions error and message make,
145 and command echoing uses it as well.
146 It overrides the minibuf_prompt as well as the buffer. */
147 char *echo_area_glyphs
;
149 /* true iff we should redraw the mode lines on the next redisplay */
150 int update_mode_lines
;
152 /* Smallest number of characters before the gap
153 at any time since last redisplay that finished.
154 Valid for current buffer when try_window_id can be called. */
157 /* Smallest number of characters after the gap
158 at any time since last redisplay that finished.
159 Valid for current buffer when try_window_id can be called. */
162 /* MODIFF as of last redisplay that finished;
163 if it matches MODIFF, beg_unchanged and end_unchanged
164 contain no useful information */
165 int unchanged_modified
;
167 /* Nonzero if head_clip or tail_clip of current buffer has changed
168 since last redisplay that finished */
171 /* Nonzero if window sizes or contents have changed
172 since last redisplay that finished */
173 int windows_or_buffers_changed
;
175 /* Nonzero after display_mode_line if %l was used
176 and it displayed a line number. */
177 int line_number_displayed
;
179 /* Maximum buffer size for which to display line numbers. */
180 int line_number_display_limit
;
182 /* Specify m, a string, as a message in the minibuf. If m is 0, clear out
183 any existing message, and let the minibuffer text show through. */
190 if (noninteractive_need_newline
)
192 noninteractive_need_newline
= 0;
193 if (cursor_in_echo_area
!= 0)
194 fprintf (stderr
, "%s", m
);
196 fprintf (stderr
, "%s\n", m
);
199 /* A null message buffer means that the frame hasn't really been
200 initialized yet. Error messages get reported properly by
201 cmd_error, so this must be just an informative message; toss it. */
202 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
205 Lisp_Object minibuf_frame
;
207 choose_minibuf_frame ();
208 minibuf_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
209 FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame
));
210 if (FRAME_VISIBLE_P (selected_frame
)
211 && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame
)))
212 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window
)));
216 echo_area_glyphs
= m
;
218 echo_area_glyphs
= previous_echo_glyphs
= 0;
220 do_pending_window_change ();
221 echo_area_display ();
222 update_frame (XFRAME (XWINDOW (minibuf_window
)->frame
), 1, 1);
223 do_pending_window_change ();
227 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
228 zero if being used by message. */
229 int message_buf_print
;
231 /* Dump an informative message to the minibuf. If m is 0, clear out
232 any existing message, and let the minibuffer text show through. */
235 message (m
, a1
, a2
, a3
)
242 if (noninteractive_need_newline
)
244 noninteractive_need_newline
= 0;
245 fprintf (stderr
, m
, a1
, a2
, a3
);
246 if (cursor_in_echo_area
== 0)
247 fprintf (stderr
, "\n");
251 else if (INTERACTIVE
)
253 /* The frame whose minibuffer we're going to display the message on.
254 It may be larger than the selected frame, so we need
255 to use its buffer, not the selected frame's buffer. */
256 FRAME_PTR echo_frame
;
258 choose_minibuf_frame ();
259 echo_frame
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
261 echo_frame
= selected_frame
;
264 /* A null message buffer means that the frame hasn't really been
265 initialized yet. Error messages get reported properly by
266 cmd_error, so this must be just an informative message; toss it. */
267 if (FRAME_MESSAGE_BUF (echo_frame
))
278 doprnt (FRAME_MESSAGE_BUF (echo_frame
),
279 FRAME_WIDTH (echo_frame
), m
, 0, 3, a
);
281 doprnt (FRAME_MESSAGE_BUF (echo_frame
),
282 FRAME_WIDTH (echo_frame
), m
, 0, 3, &a1
);
283 #endif /* NO_ARG_ARRAY */
286 message1 (FRAME_MESSAGE_BUF (echo_frame
));
291 /* Print should start at the beginning of the message
293 message_buf_print
= 0;
305 choose_minibuf_frame ();
308 f
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
310 if (! FRAME_VISIBLE_P (f
))
315 redraw_garbaged_frames ();
319 if (echo_area_glyphs
|| minibuf_level
== 0)
321 vpos
= XFASTINT (XWINDOW (minibuf_window
)->top
);
322 get_display_line (f
, vpos
, 0);
323 display_string (XWINDOW (minibuf_window
), vpos
,
324 echo_area_glyphs
? echo_area_glyphs
: "",
325 0, 0, 0, FRAME_WIDTH (f
));
327 /* If desired cursor location is on this line, put it at end of text */
328 if (FRAME_CURSOR_Y (f
) == vpos
)
329 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
331 /* Fill the rest of the minibuffer window with blank lines. */
336 i
< vpos
+ XFASTINT (XWINDOW (minibuf_window
)->height
); i
++)
338 get_display_line (f
, i
, 0);
339 display_string (XWINDOW (minibuf_window
), vpos
,
340 "", 0, 0, 0, FRAME_WIDTH (f
));
344 else if (!EQ (minibuf_window
, selected_window
))
345 windows_or_buffers_changed
++;
347 if (EQ (minibuf_window
, selected_window
))
348 this_line_bufpos
= 0;
350 previous_echo_glyphs
= echo_area_glyphs
;
353 /* Do a frame update, taking possible shortcuts into account.
354 This is the main external entry point for redisplay.
356 If the last redisplay displayed an echo area message and that
357 message is no longer requested, we clear the echo area
358 or bring back the minibuffer if that is in use.
360 Everyone would like to have a hook here to call eval,
361 but that cannot be done safely without a lot of changes elsewhere.
362 This can be called from signal handlers; with alarms set up;
363 or with synchronous processes running.
364 See the function `echo' in keyboard.c.
365 See Fcall_process; if you called it from here, it could be
366 entered recursively. */
371 register struct window
*w
= XWINDOW (selected_window
);
375 register int tlbufpos
, tlendpos
;
377 extern int input_pending
;
382 /* Set the visible flags for all frames.
383 Do this before checking for resized or garbaged frames; they want
384 to know if their frames are visible.
385 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
387 Lisp_Object tail
, frame
;
389 FOR_EACH_FRAME (tail
, frame
)
390 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
393 /* Notice any pending interrupt request to change frame size. */
394 do_pending_window_change ();
398 redraw_garbaged_frames ();
402 /* Normally the message* functions will have already displayed and
403 updated the echo area, but the frame may have been trashed, or
404 the update may have been preempted, so display the echo area
406 if (echo_area_glyphs
|| previous_echo_glyphs
)
408 echo_area_display ();
412 if (clip_changed
|| windows_or_buffers_changed
)
415 /* Detect case that we need to write a star in the mode line. */
416 if (XFASTINT (w
->last_modified
) < MODIFF
417 && XFASTINT (w
->last_modified
) <= current_buffer
->save_modified
)
419 w
->update_mode_line
= Qt
;
420 if (buffer_shared
> 1)
424 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
426 all_windows
= update_mode_lines
|| buffer_shared
> 1;
428 /* If specs for an arrow have changed, do thorough redisplay
429 to ensure we remove any arrow that should no longer exist. */
430 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
431 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
432 all_windows
= 1, clip_changed
= 1;
434 /* If showing region, and mark has changed, must redisplay whole window. */
435 if (((!NILP (Vtransient_mark_mode
)
436 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
437 != !NILP (w
->region_showing
))
438 || !EQ (w
->region_showing
,
439 Fmarker_position (XBUFFER (w
->buffer
)->mark
)))
440 this_line_bufpos
= -1;
442 tlbufpos
= this_line_bufpos
;
443 tlendpos
= this_line_endpos
;
444 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
445 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
446 /* Make sure recorded data applies to current buffer, etc */
447 && this_line_buffer
== current_buffer
448 && current_buffer
== XBUFFER (w
->buffer
)
449 && NILP (w
->force_start
)
450 /* Point must be on the line that we have info recorded about */
452 && point
<= Z
- tlendpos
453 /* All text outside that line, including its final newline,
455 && (XFASTINT (w
->last_modified
) >= MODIFF
456 || (beg_unchanged
>= tlbufpos
- 1
458 /* If selective display, can't optimize
459 if the changes start at the beginning of the line. */
460 && ((XTYPE (current_buffer
->selective_display
) == Lisp_Int
461 && XINT (current_buffer
->selective_display
) > 0
462 ? (beg_unchanged
>= tlbufpos
465 && end_unchanged
>= tlendpos
466 && Z
- GPT
>= tlendpos
)))
468 if (tlbufpos
> BEGV
&& FETCH_CHAR (tlbufpos
- 1) != '\n'
470 || FETCH_CHAR (tlbufpos
) == '\n'))
471 /* Former continuation line has disappeared by becoming empty */
473 else if (XFASTINT (w
->last_modified
) < MODIFF
474 || MINI_WINDOW_P (w
))
477 overlay_arrow_seen
= 0;
478 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
479 pos_tab_offset (w
, tlbufpos
));
480 /* If line contains point, is not continued,
481 and ends at same distance from eob as before, we win */
482 if (cursor_vpos
>= 0 && this_line_bufpos
483 && this_line_endpos
== tlendpos
)
485 if (XFASTINT (w
->width
) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w
))))
486 preserve_other_columns (w
);
492 else if (point
== XFASTINT (w
->last_point
))
496 do_pending_window_change ();
501 /* If highlighting the region, we can't just move the cursor. */
502 else if (! (!NILP (Vtransient_mark_mode
)
503 && !NILP (current_buffer
->mark_active
))
504 && NILP (w
->region_showing
))
506 pos
= *compute_motion (tlbufpos
, 0,
507 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
508 point
, 2, - (1 << (SHORTBITS
- 1)),
509 window_internal_width (w
) - 1,
511 pos_tab_offset (w
, tlbufpos
));
514 FRAME_CURSOR_X (selected_frame
)
515 = XFASTINT (w
->left
) + max (pos
.hpos
, 0);
516 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
523 /* Text changed drastically or point moved off of line */
524 cancel_line (this_line_vpos
, selected_frame
);
527 this_line_bufpos
= 0;
528 all_windows
|= buffer_shared
> 1;
532 Lisp_Object tail
, frame
;
534 #ifdef HAVE_X_WINDOWS
535 /* Since we're doing a thorough redisplay, we might as well
536 recompute all our display faces. */
537 clear_face_vector ();
540 /* Recompute # windows showing selected buffer.
541 This will be incremented each time such a window is displayed. */
544 FOR_EACH_FRAME (tail
, frame
)
546 FRAME_PTR f
= XFRAME (frame
);
548 /* Mark all the scroll bars to be removed; we'll redeem the ones
549 we want when we redisplay their windows. */
550 if (condemn_scroll_bars_hook
)
551 (*condemn_scroll_bars_hook
) (f
);
553 if (FRAME_VISIBLE_P (f
))
554 redisplay_windows (FRAME_ROOT_WINDOW (f
));
556 /* Any scroll bars which redisplay_windows should have nuked
557 should now go away. */
558 if (judge_scroll_bars_hook
)
559 (*judge_scroll_bars_hook
) (f
);
562 else if (FRAME_VISIBLE_P (selected_frame
))
564 redisplay_window (selected_window
, 1);
565 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
566 preserve_other_columns (w
);
570 /* Prevent various kinds of signals during display update.
571 stdio is not robust about handling signals,
572 which can cause an apparent I/O error. */
584 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
588 if (XTYPE (XCONS (tail
)->car
) != Lisp_Frame
)
591 f
= XFRAME (XCONS (tail
)->car
);
592 if (FRAME_VISIBLE_P (f
))
594 pause
|= update_frame (f
, 0, 0);
596 mark_window_display_accurate (f
->root_window
, 1);
601 #endif /* MULTI_FRAME */
603 if (FRAME_VISIBLE_P (selected_frame
))
604 pause
= update_frame (selected_frame
, 0, 0);
606 /* We may have called echo_area_display at the top of this
607 function. If the echo area is on another frame, that may
608 have put text on a frame other than the selected one, so the
609 above call to update_frame would not have caught it. Catch
612 FRAME_PTR mini_frame
=
613 XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
615 if (mini_frame
!= selected_frame
)
616 pause
|= update_frame (mini_frame
, 0, 0);
620 /* If frame does not match, prevent doing single-line-update next time.
621 Also, don't forget to check every line to update the arrow. */
624 this_line_bufpos
= 0;
625 if (!NILP (last_arrow_position
))
627 last_arrow_position
= Qt
;
628 last_arrow_string
= Qt
;
630 /* If we pause after scrolling, some lines in current_frame
631 may be null, so preserve_other_columns won't be able to
632 preserve all the vertical-bar separators. So, avoid using it
634 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
635 update_mode_lines
= 1;
638 /* Now text on frame agrees with windows, so
639 put info into the windows for partial redisplay to follow */
643 register struct buffer
*b
= XBUFFER (w
->buffer
);
645 blank_end_of_window
= 0;
647 unchanged_modified
= BUF_MODIFF (b
);
648 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
649 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
651 XFASTINT (w
->last_point
) = BUF_PT (b
);
652 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (selected_frame
);
653 XFASTINT (w
->last_point_y
) = FRAME_CURSOR_Y (selected_frame
);
656 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
659 w
->update_mode_line
= Qnil
;
660 XFASTINT (w
->last_modified
) = BUF_MODIFF (b
);
661 w
->window_end_valid
= Qt
;
662 last_arrow_position
= Voverlay_arrow_position
;
663 last_arrow_string
= Voverlay_arrow_string
;
665 update_mode_lines
= 0;
666 windows_or_buffers_changed
= 0;
669 /* Start SIGIO interrupts coming again.
670 Having them off during the code above
671 makes it less likely one will discard output,
672 but not impossible, since there might be stuff
673 in the system buffer here.
674 But it is much hairier to try to do anything about that. */
680 /* Change frame size now if a change is pending. */
681 do_pending_window_change ();
684 /* Redisplay, but leave alone any recent echo area message
685 unless another message has been requested in its place.
687 This is useful in situations where you need to redisplay but no
688 user action has occurred, making it inappropriate for the message
689 area to be cleared. See tracking_off and
690 wait_reading_process_input for examples of these situations. */
692 redisplay_preserve_echo_area ()
694 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
696 echo_area_glyphs
= previous_echo_glyphs
;
698 echo_area_glyphs
= 0;
705 mark_window_display_accurate (window
, flag
)
709 register struct window
*w
;
711 for (;!NILP (window
); window
= w
->next
)
713 if (XTYPE (window
) != Lisp_Window
) abort ();
714 w
= XWINDOW (window
);
716 if (!NILP (w
->buffer
))
718 XFASTINT (w
->last_modified
)
720 : XBUFFER (w
->buffer
) == current_buffer
721 ? MODIFF
: BUF_MODIFF (XBUFFER (w
->buffer
));
723 /* Record if we are showing a region, so can make sure to
724 update it fully at next redisplay. */
725 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
726 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
727 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
731 w
->window_end_valid
= Qt
;
732 w
->update_mode_line
= Qnil
;
734 if (!NILP (w
->vchild
))
735 mark_window_display_accurate (w
->vchild
, flag
);
736 if (!NILP (w
->hchild
))
737 mark_window_display_accurate (w
->hchild
, flag
);
742 last_arrow_position
= Voverlay_arrow_position
;
743 last_arrow_string
= Voverlay_arrow_string
;
747 /* t is unequal to any useful value of Voverlay_arrow_... */
748 last_arrow_position
= Qt
;
749 last_arrow_string
= Qt
;
756 redisplay_windows (window
)
759 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
760 redisplay_window (window
, 0);
764 redisplay_window (window
, just_this_one
)
768 register struct window
*w
= XWINDOW (window
);
769 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
771 register int lpoint
= point
;
772 struct buffer
*old
= current_buffer
;
773 register int width
= window_internal_width (w
) - 1;
775 register int hscroll
= XINT (w
->hscroll
);
779 int window_needs_modeline
;
781 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
783 /* If this is a combination window, do its children; that's all. */
785 if (!NILP (w
->vchild
))
787 redisplay_windows (w
->vchild
);
790 if (!NILP (w
->hchild
))
792 redisplay_windows (w
->hchild
);
795 if (NILP (w
->buffer
))
798 height
= window_internal_height (w
);
800 if (MINI_WINDOW_P (w
))
802 if (w
== XWINDOW (minibuf_window
))
804 if (echo_area_glyphs
)
805 /* We've already displayed the echo area glyphs, if any. */
806 goto finish_scroll_bars
;
810 /* This is a minibuffer, but it's not the currently active one, so
812 int vpos
= XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
815 for (i
= 0; i
< height
; i
++)
817 get_display_line (f
, vpos
+ i
, 0);
818 display_string (w
, vpos
+ i
, "", 0, 0, 0, width
);
821 goto finish_scroll_bars
;
825 if (update_mode_lines
)
826 w
->update_mode_line
= Qt
;
828 /* Otherwise set up data on this window; select its buffer and point value */
830 current_buffer
= XBUFFER (w
->buffer
);
833 /* Count number of windows showing the selected buffer. */
836 && current_buffer
== XBUFFER (XWINDOW (selected_window
)->buffer
))
839 /* POINT refers normally to the selected window.
840 For any other window, set up appropriate value. */
842 if (!EQ (window
, selected_window
))
844 SET_PT (marker_position (w
->pointm
));
848 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
850 else if (point
> (ZV
- 1))
853 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
857 /* If window-start is screwed up, choose a new one. */
858 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
861 startp
= marker_position (w
->start
);
863 /* Handle case where place to start displaying has been specified,
864 unless the specified location is outside the accessible range. */
865 if (!NILP (w
->force_start
))
867 /* Forget any recorded base line for line number display. */
868 w
->base_line_number
= Qnil
;
869 w
->update_mode_line
= Qt
;
870 w
->force_start
= Qnil
;
871 XFASTINT (w
->last_modified
) = 0;
872 if (startp
< BEGV
) startp
= BEGV
;
873 if (startp
> ZV
) startp
= ZV
;
874 try_window (window
, startp
);
877 /* ??? What should happen here if highlighting a region? */
878 /* If point does not appear, move point so it does appear */
879 pos
= *compute_motion (startp
, 0,
880 ((EQ (window
, minibuf_window
) && startp
== 1)
881 ? minibuf_prompt_width
: 0)
883 (hscroll
? 1 - hscroll
: 0),
885 - (1 << (SHORTBITS
- 1)),
886 width
, hscroll
, pos_tab_offset (w
, startp
));
888 if (w
!= XWINDOW (FRAME_SELECTED_WINDOW (f
)))
889 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
893 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
894 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
900 /* Handle case where text has not changed, only point,
901 and it has not moved off the frame */
903 /* This code is not used for minibuffer for the sake of
904 the case of redisplaying to replace an echo area message;
905 since in that case the minibuffer contents per se are usually unchanged.
906 This code is of no real use in the minibuffer since
907 the handling of this_line_bufpos, etc.,
908 in redisplay handles the same cases. */
910 if (XFASTINT (w
->last_modified
) >= MODIFF
911 && point
>= startp
&& !clip_changed
912 && (just_this_one
|| XFASTINT (w
->width
) == FRAME_WIDTH (f
))
913 /* Can't use this case if highlighting a region. */
914 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
915 && NILP (w
->region_showing
)
916 && !EQ (window
, minibuf_window
))
918 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0),
919 point
, height
+ 1, 10000, width
, hscroll
,
920 pos_tab_offset (w
, startp
));
922 if (pos
.vpos
< height
)
924 /* Ok, point is still on frame */
925 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
927 /* These variables are supposed to be origin 1 */
928 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
929 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
931 /* This doesn't do the trick, because if a window to the right of
932 this one must be redisplayed, this does nothing because there
933 is nothing in DesiredFrame yet, and then the other window is
934 redisplayed, making likes that are empty in this window's columns.
935 if (XFASTINT (w->width) != FRAME_WIDTH (f))
936 preserve_my_columns (w);
940 /* Don't bother trying redisplay with same start;
941 we already know it will lose */
943 /* If current starting point was originally the beginning of a line
944 but no longer is, find a new starting point. */
945 else if (!NILP (w
->start_at_line_beg
)
947 || FETCH_CHAR (startp
- 1) == '\n'))
951 else if (just_this_one
&& !MINI_WINDOW_P (w
)
953 && XFASTINT (w
->last_modified
)
954 /* or else vmotion on first line won't work. */
955 && ! NILP (w
->start_at_line_beg
)
956 && ! EQ (w
->window_end_valid
, Qnil
)
957 && do_id
&& !clip_changed
958 && !blank_end_of_window
959 && XFASTINT (w
->width
) == FRAME_WIDTH (f
)
960 /* Can't use this case if highlighting a region. */
961 && !(!NILP (Vtransient_mark_mode
)
962 && !NILP (current_buffer
->mark_active
))
963 && NILP (w
->region_showing
)
964 && EQ (last_arrow_position
, Voverlay_arrow_position
)
965 && EQ (last_arrow_string
, Voverlay_arrow_string
)
966 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
969 /* tem > 0 means success. tem == -1 means choose new start.
970 tem == -2 means try again with same start,
971 and nothing but whitespace follows the changed stuff.
972 tem == 0 means try again with same start. */
976 else if (startp
>= BEGV
&& startp
<= ZV
977 /* Avoid starting display at end of buffer! */
978 && (startp
< ZV
|| startp
== BEGV
979 || (XFASTINT (w
->last_modified
) >= MODIFF
)))
981 /* Try to redisplay starting at same place as before */
982 /* If point has not moved off frame, accept the results */
983 try_window (window
, startp
);
984 if (cursor_vpos
>= 0)
986 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
987 /* Forget any recorded base line for line number display. */
988 w
->base_line_number
= Qnil
;
992 cancel_my_columns (w
);
995 XFASTINT (w
->last_modified
) = 0;
996 w
->update_mode_line
= Qt
;
998 /* Try to scroll by specified few lines */
1000 if (scroll_step
&& !clip_changed
)
1004 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1005 scroll_step
, width
, hscroll
, window
);
1006 if (pos
.vpos
>= height
)
1010 pos
= *vmotion (startp
, point
< startp
? - scroll_step
: scroll_step
,
1011 width
, hscroll
, window
);
1013 if (point
>= pos
.bufpos
)
1015 try_window (window
, pos
.bufpos
);
1016 if (cursor_vpos
>= 0)
1018 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1019 /* Forget any recorded base line for line number display. */
1020 w
->base_line_number
= Qnil
;
1024 cancel_my_columns (w
);
1029 /* Finally, just choose place to start which centers point */
1032 /* Forget any previously recorded base line for line number display. */
1033 w
->base_line_number
= Qnil
;
1035 pos
= *vmotion (point
, - height
/ 2, width
, hscroll
, window
);
1036 try_window (window
, pos
.bufpos
);
1038 startp
= marker_position (w
->start
);
1039 w
->start_at_line_beg
=
1040 (startp
== BEGV
|| FETCH_CHAR (startp
- 1) == '\n') ? Qt
: Qnil
;
1043 if ((!NILP (w
->update_mode_line
)
1044 /* If window not full width, must redo its mode line
1045 if the window to its side is being redone */
1046 || (!just_this_one
&& width
< FRAME_WIDTH (f
) - 1)
1047 || INTEGERP (w
->base_line_pos
))
1048 && height
!= XFASTINT (w
->height
))
1049 display_mode_line (w
);
1050 if (! line_number_displayed
1051 && ! BUFFERP (w
->base_line_pos
))
1053 w
->base_line_pos
= Qnil
;
1054 w
->base_line_number
= Qnil
;
1057 /* When we reach a frame's selected window, redo the frame's menu bar. */
1058 if (!NILP (w
->update_mode_line
)
1059 && FRAME_MENU_BAR_LINES (f
) > 0
1060 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
1061 display_menu_bar (w
);
1064 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1066 int start
, end
, whole
;
1068 /* Calculate the start and end positions for the current window.
1069 At some point, it would be nice to choose between scrollbars
1070 which reflect the whole buffer size, with special markers
1071 indicating narrowing, and scrollbars which reflect only the
1074 Note that minibuffers sometimes aren't displaying any text. */
1075 if (! MINI_WINDOW_P (w
)
1076 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
1079 start
= startp
- BEGV
;
1080 /* I don't think this is guaranteed to be right. For the
1081 moment, we'll pretend it is. */
1082 end
= (Z
- XINT (w
->window_end_pos
));
1084 if (end
< start
) end
= start
;
1085 if (whole
< (end
- start
)) whole
= end
- start
;
1088 start
= end
= whole
= 0;
1090 /* Indicate what this scroll bar ought to be displaying now. */
1091 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
1093 /* Note that we actually used the scroll bar attached to this window,
1094 so it shouldn't be deleted at the end of redisplay. */
1095 (*redeem_scroll_bar_hook
) (w
);
1099 current_buffer
= old
;
1103 /* Do full redisplay on one window, starting at position `pos'. */
1106 try_window (window
, pos
)
1110 register struct window
*w
= XWINDOW (window
);
1111 register int height
= window_internal_height (w
);
1112 register int vpos
= XFASTINT (w
->top
);
1113 register int last_text_vpos
= vpos
;
1114 int tab_offset
= pos_tab_offset (w
, pos
);
1115 FRAME_PTR f
= XFRAME (w
->frame
);
1116 int width
= window_internal_width (w
) - 1;
1117 struct position val
;
1119 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1121 overlay_arrow_seen
= 0;
1122 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1124 while (--height
>= 0)
1126 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, tab_offset
);
1127 tab_offset
+= width
;
1128 if (val
.vpos
) tab_offset
= 0;
1130 if (pos
!= val
.bufpos
)
1132 /* Next line, unless prev line ended in end of buffer with no cr */
1133 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
1137 /* If last line is continued in middle of character,
1138 include the split character in the text considered on the frame */
1139 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
1142 /* If bottom just moved off end of frame, change mode line percentage. */
1143 if (XFASTINT (w
->window_end_pos
) == 0
1145 w
->update_mode_line
= Qt
;
1147 /* Say where last char on frame will be, once redisplay is finished. */
1148 XFASTINT (w
->window_end_pos
) = Z
- pos
;
1149 XFASTINT (w
->window_end_vpos
) = last_text_vpos
- XFASTINT (w
->top
);
1150 /* But that is not valid info until redisplay finishes. */
1151 w
->window_end_valid
= Qnil
;
1154 /* Try to redisplay when buffer is modified locally,
1155 computing insert/delete line to preserve text outside
1156 the bounds of the changes.
1157 Return 1 if successful, 0 if if cannot tell what to do,
1158 or -1 to tell caller to find a new window start,
1159 or -2 to tell caller to do normal redisplay with same window start. */
1162 try_window_id (window
)
1166 register struct window
*w
= XWINDOW (window
);
1167 register int height
= window_internal_height (w
);
1168 FRAME_PTR f
= XFRAME (w
->frame
);
1169 int top
= XFASTINT (w
->top
);
1170 int start
= marker_position (w
->start
);
1171 int width
= window_internal_width (w
) - 1;
1172 int hscroll
= XINT (w
->hscroll
);
1173 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1175 register int i
, tem
;
1176 int last_text_vpos
= 0;
1179 struct position val
, bp
, ep
, xp
, pp
;
1180 int scroll_amount
= 0;
1182 int tab_offset
, epto
;
1184 if (GPT
- BEG
< beg_unchanged
)
1185 beg_unchanged
= GPT
- BEG
;
1186 if (Z
- GPT
< end_unchanged
)
1187 end_unchanged
= Z
- GPT
;
1189 if (beg_unchanged
+ 1 < start
)
1190 return 0; /* Give up if changes go above top of window */
1192 /* Find position before which nothing is changed. */
1193 bp
= *compute_motion (start
, 0, lmargin
,
1194 beg_unchanged
+ 1, height
+ 1, 0, width
, hscroll
,
1195 pos_tab_offset (w
, start
));
1196 if (bp
.vpos
>= height
)
1198 if (point
< bp
.bufpos
&& !bp
.contin
)
1200 /* All changes are below the frame, and point is on the frame.
1201 We don't need to change the frame at all.
1202 But we need to update window_end_pos to account for
1203 any change in buffer size. */
1204 bp
= *compute_motion (start
, 0, lmargin
,
1206 width
, hscroll
, pos_tab_offset (w
, start
));
1207 XFASTINT (w
->window_end_vpos
) = height
;
1208 XFASTINT (w
->window_end_pos
) = Z
- bp
.bufpos
;
1216 /* Find beginning of that frame line. Must display from there. */
1217 bp
= *vmotion (bp
.bufpos
, 0, width
, hscroll
, window
);
1224 /* If about to start displaying at the beginning of a continuation line,
1225 really start with previous frame line, in case it was not
1226 continued when last redisplayed */
1227 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
1229 /* Likewise if we have to worry about selective display. */
1230 (XTYPE (current_buffer
->selective_display
) == Lisp_Int
1231 && XINT (current_buffer
->selective_display
) > 0
1232 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
1234 bp
= *vmotion (bp
.bufpos
, -1, width
, hscroll
, window
);
1239 if (bp
.contin
&& bp
.hpos
!= lmargin
)
1241 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
1247 /* Find first visible newline after which no more is changed. */
1248 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
1249 if (XTYPE (current_buffer
->selective_display
) == Lisp_Int
1250 && XINT (current_buffer
->selective_display
) > 0)
1252 && (position_indentation (tem
)
1253 >= XINT (current_buffer
->selective_display
)))
1254 tem
= find_next_newline (tem
, 1);
1256 /* Compute the cursor position after that newline. */
1257 ep
= *compute_motion (pos
, vpos
, val
.hpos
, tem
,
1258 height
, - (1 << (SHORTBITS
- 1)),
1259 width
, hscroll
, pos_tab_offset (w
, bp
.bufpos
));
1261 /* If changes reach past the text available on the frame,
1262 just display rest of frame. */
1263 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
1266 stop_vpos
= ep
.vpos
;
1268 /* If no newline before ep, the line ep is on includes some changes
1269 that must be displayed. Make sure we don't stop before it. */
1270 /* Also, if changes reach all the way until ep.bufpos,
1271 it is possible that something was deleted after the
1272 newline before it, so the following line must be redrawn. */
1273 if (stop_vpos
== ep
.vpos
1274 && (ep
.bufpos
== BEGV
1275 || FETCH_CHAR (ep
.bufpos
- 1) != '\n'
1276 || ep
.bufpos
== Z
- end_unchanged
))
1277 stop_vpos
= ep
.vpos
+ 1;
1280 overlay_arrow_seen
= 0;
1282 /* If changes do not reach to bottom of window,
1283 figure out how much to scroll the rest of the window */
1284 if (stop_vpos
< height
)
1286 /* Now determine how far up or down the rest of the window has moved */
1287 epto
= pos_tab_offset (w
, ep
.bufpos
);
1288 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1289 Z
- XFASTINT (w
->window_end_pos
),
1290 10000, 0, width
, hscroll
, epto
);
1291 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
1293 /* Is everything on frame below the changes whitespace?
1294 If so, no scrolling is really necessary. */
1295 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
1297 tem
= FETCH_CHAR (i
);
1298 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
1304 XFASTINT (w
->window_end_vpos
) += scroll_amount
;
1306 /* Before doing any scrolling, verify that point will be on frame. */
1307 if (point
> ep
.bufpos
&& !(point
<= xp
.bufpos
&& xp
.bufpos
< height
))
1309 if (point
<= xp
.bufpos
)
1311 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1312 point
, height
, - (1 << (SHORTBITS
- 1)),
1313 width
, hscroll
, epto
);
1317 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
,
1318 point
, height
, - (1 << (SHORTBITS
- 1)),
1319 width
, hscroll
, pos_tab_offset (w
, xp
.bufpos
));
1321 if (pp
.bufpos
< point
|| pp
.vpos
== height
)
1323 cursor_vpos
= pp
.vpos
+ top
;
1324 cursor_hpos
= pp
.hpos
+ XFASTINT (w
->left
);
1327 if (stop_vpos
- scroll_amount
>= height
1328 || ep
.bufpos
== xp
.bufpos
)
1330 if (scroll_amount
< 0)
1331 stop_vpos
-= scroll_amount
;
1333 /* In this path, we have altered window_end_vpos
1334 and not left it negative.
1335 We must make sure that, in case display is preempted
1336 before the frame changes to reflect what we do here,
1337 further updates will not come to try_window_id
1338 and assume the frame and window_end_vpos match. */
1339 blank_end_of_window
= 1;
1341 else if (!scroll_amount
)
1343 else if (bp
.bufpos
== Z
- end_unchanged
)
1345 /* If reprinting everything is nearly as fast as scrolling,
1346 don't bother scrolling. Can happen if lines are short. */
1347 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
1348 top
+ height
- max (0, scroll_amount
),
1350 > xp
.bufpos
- bp
.bufpos
- 20)
1351 /* Return "try normal display with same window-start."
1352 Too bad we can't prevent further scroll-thinking. */
1354 /* If pure deletion, scroll up as many lines as possible.
1355 In common case of killing a line, this can save the
1356 following line from being overwritten by scrolling
1357 and therefore having to be redrawn. */
1358 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
1359 top
+ height
- max (0, scroll_amount
),
1361 if (!tem
) stop_vpos
= height
;
1363 else if (scroll_amount
)
1365 /* If reprinting everything is nearly as fast as scrolling,
1366 don't bother scrolling. Can happen if lines are short. */
1367 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
1368 overestimate of cost of reprinting, since xp.bufpos
1369 would end up below the bottom of the window. */
1370 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
1371 top
+ height
- max (0, scroll_amount
),
1373 > xp
.bufpos
- ep
.bufpos
- 20)
1374 /* Return "try normal display with same window-start."
1375 Too bad we can't prevent further scroll-thinking. */
1377 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
1378 top
+ height
- max (0, scroll_amount
),
1380 if (!tem
) stop_vpos
= height
;
1384 /* In any case, do not display past bottom of window */
1385 if (stop_vpos
>= height
)
1391 /* Handle case where pos is before w->start --
1392 can happen if part of line had been clipped and is not clipped now */
1393 if (vpos
== 0 && pos
< marker_position (w
->start
))
1394 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1396 /* Redisplay the lines where the text was changed */
1397 last_text_vpos
= vpos
;
1398 tab_offset
= pos_tab_offset (w
, pos
);
1399 /* If we are starting display in mid-character, correct tab_offset
1400 to account for passing the line that that character really starts in. */
1401 if (val
.hpos
< lmargin
)
1402 tab_offset
+= width
;
1403 while (vpos
< stop_vpos
)
1405 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1406 tab_offset
+= width
;
1407 if (val
.vpos
) tab_offset
= 0;
1408 if (pos
!= val
.bufpos
)
1410 /* Next line, unless prev line ended in end of buffer with no cr */
1411 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
1415 /* There are two cases:
1416 1) we have displayed down to the bottom of the window
1417 2) we have scrolled lines below stop_vpos by scroll_amount */
1421 /* If last line is continued in middle of character,
1422 include the split character in the text considered on the frame */
1423 if (val
.hpos
< lmargin
)
1425 XFASTINT (w
->window_end_vpos
) = last_text_vpos
;
1426 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1429 /* If scrolling made blank lines at window bottom,
1430 redisplay to fill those lines */
1431 if (scroll_amount
< 0)
1433 /* Don't consider these lines for general-purpose scrolling.
1434 That will save time in the scrolling computation. */
1435 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
1440 vpos
= height
+ scroll_amount
;
1441 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
1443 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
1447 blank_end_of_window
= 1;
1448 tab_offset
= pos_tab_offset (w
, pos
);
1449 /* If we are starting display in mid-character, correct tab_offset
1450 to account for passing the line that that character starts in. */
1451 if (val
.hpos
< lmargin
)
1452 tab_offset
+= width
;
1454 while (vpos
< height
)
1456 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1457 tab_offset
+= width
;
1458 if (val
.vpos
) tab_offset
= 0;
1462 /* Here is a case where display_text_line sets cursor_vpos wrong.
1463 Make it be fixed up, below. */
1465 && xp
.bufpos
== point
)
1469 /* If bottom just moved off end of frame, change mode line percentage. */
1470 if (XFASTINT (w
->window_end_pos
) == 0
1472 w
->update_mode_line
= Qt
;
1474 /* Attempt to adjust end-of-text positions to new bottom line */
1477 delta
= height
- xp
.vpos
;
1479 || (delta
> 0 && xp
.bufpos
<= ZV
)
1480 || (delta
== 0 && xp
.hpos
))
1482 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1483 delta
, width
, hscroll
, window
);
1484 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1485 XFASTINT (w
->window_end_vpos
) += val
.vpos
;
1489 w
->window_end_valid
= Qnil
;
1491 /* If point was not in a line that was displayed, find it */
1492 if (cursor_vpos
< 0)
1494 val
= *compute_motion (start
, 0, lmargin
, point
, 10000, 10000,
1495 width
, hscroll
, pos_tab_offset (w
, start
));
1496 /* Admit failure if point is off frame now */
1497 if (val
.vpos
>= height
)
1499 for (vpos
= 0; vpos
< height
; vpos
++)
1500 cancel_line (vpos
+ top
, f
);
1503 cursor_vpos
= val
.vpos
+ top
;
1504 cursor_hpos
= val
.hpos
+ XFASTINT (w
->left
);
1507 FRAME_CURSOR_X (f
) = max (0, cursor_hpos
);
1508 FRAME_CURSOR_Y (f
) = cursor_vpos
;
1512 val
= *compute_motion (start
, 0, lmargin
, ZV
,
1513 height
, - (1 << (SHORTBITS
- 1)),
1514 width
, hscroll
, pos_tab_offset (w
, start
));
1515 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
1517 if (XFASTINT (w
->window_end_pos
)
1525 /* Mark a section of BUF as modified, but only for the sake of redisplay.
1526 This is useful for recording changes to overlays.
1528 We increment the buffer's modification timestamp and set the
1529 redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
1530 as if the region of text between START and END had been modified;
1531 the redisplay code will check this against the windows' timestamps,
1532 and redraw the appropriate area of the buffer.
1534 However, if the buffer is unmodified, we bump the last-save
1535 timestamp as well, so that incrementing the timestamp doesn't fool
1536 Emacs into thinking that the buffer's text has been modified.
1538 Tweaking the timestamps shouldn't hurt the first-modification
1539 timestamps recorded in the undo records; those values aren't
1540 written until just before a real text modification is made, so they
1541 will never catch the timestamp value just before this function gets
1545 redisplay_region (buf
, start
, end
)
1555 start
= end
; end
= temp
;
1558 if (buf
!= current_buffer
)
1559 windows_or_buffers_changed
= 1;
1562 if (unchanged_modified
== MODIFF
)
1564 beg_unchanged
= start
- BEG
;
1565 end_unchanged
= Z
- end
;
1569 if (Z
- end
< end_unchanged
)
1570 end_unchanged
= Z
- end
;
1571 if (start
- BEG
< beg_unchanged
)
1572 beg_unchanged
= start
- BEG
;
1576 /* Increment the buffer's time stamp, but also increment the save
1577 and autosave timestamps, so as not to screw up that timekeeping. */
1578 if (BUF_MODIFF (buf
) == buf
->save_modified
)
1579 buf
->save_modified
++;
1580 if (BUF_MODIFF (buf
) == buf
->auto_save_modified
)
1581 buf
->auto_save_modified
++;
1583 BUF_MODIFF (buf
) ++;
1587 /* Copy glyphs from the vector FROM to the rope T.
1588 But don't actually copy the parts that would come in before S.
1589 Value is T, advanced past the copied data. */
1592 copy_rope (t
, s
, from
, face
)
1593 register GLYPH
*t
; /* Copy to here. */
1594 register GLYPH
*s
; /* Starting point. */
1595 Lisp_Object from
; /* Data to copy; known to be a vector. */
1596 int face
; /* Face to apply to glyphs which don't specify one. */
1598 register int n
= XVECTOR (from
)->size
;
1599 register Lisp_Object
*f
= XVECTOR (from
)->contents
;
1603 int glyph
= XFASTINT (*f
);
1605 if (t
>= s
) *t
= MAKE_GLYPH (GLYPH_CHAR (glyph
),
1607 ? GLYPH_FACE (glyph
)
1615 /* Copy exactly LEN glyphs from FROM into data at T.
1616 But don't alter words before S. */
1619 copy_part_of_rope (t
, s
, from
, len
, face
)
1620 register GLYPH
*t
; /* Copy to here. */
1621 register GLYPH
*s
; /* Starting point. */
1622 Lisp_Object
*from
; /* Data to copy. */
1624 int face
; /* Face to apply to glyphs which don't specify one. */
1627 register Lisp_Object
*f
= from
;
1631 int glyph
= XFASTINT (*f
);
1633 if (t
>= s
) *t
= MAKE_GLYPH (GLYPH_CHAR (glyph
),
1635 ? GLYPH_FACE (glyph
)
1643 /* Display one line of window w, starting at position START in W's buffer.
1644 Display starting at horizontal position HPOS, which is normally zero
1645 or negative. A negative value causes output up to hpos = 0 to be discarded.
1646 This is done for negative hscroll, or when this is a continuation line
1647 and the continuation occurred in the middle of a multi-column character.
1649 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
1651 Display on position VPOS on the frame. (origin 0).
1653 Returns a STRUCT POSITION giving character to start next line with
1654 and where to display it, including a zero or negative hpos.
1655 The vpos field is not really a vpos; it is 1 unless the line is continued */
1657 struct position val_display_text_line
;
1659 static struct position
*
1660 display_text_line (w
, start
, vpos
, hpos
, taboffset
)
1667 register int pos
= start
;
1672 register unsigned char *p
;
1674 register GLYPH
*startp
;
1675 register GLYPH
*p1prev
= 0;
1676 FRAME_PTR f
= XFRAME (w
->frame
);
1677 int tab_width
= XINT (current_buffer
->tab_width
);
1678 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1679 int width
= window_internal_width (w
) - 1;
1680 struct position val
;
1683 int hscroll
= XINT (w
->hscroll
);
1684 int truncate
= hscroll
1685 || (truncate_partial_width_windows
1686 && XFASTINT (w
->width
) < FRAME_WIDTH (f
))
1687 || !NILP (current_buffer
->truncate_lines
);
1689 /* 1 if we should highlight the region. */
1690 int highlight_region
1691 = !NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
);
1692 int region_beg
, region_end
;
1695 = XTYPE (current_buffer
->selective_display
) == Lisp_Int
1696 ? XINT (current_buffer
->selective_display
)
1697 : !NILP (current_buffer
->selective_display
) ? -1 : 0;
1698 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
1699 register struct Lisp_Vector
*dp
= window_display_table (w
);
1701 Lisp_Object default_invis_vector
[3];
1702 /* Nonzero means display something where there are invisible lines.
1703 The precise value is the number of glyphs to display. */
1705 = (selective
&& dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1706 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
1707 : selective
&& !NILP (current_buffer
->selective_display_ellipses
)
1709 /* This is the sequence of Lisp objects to display
1710 when there are invisible lines. */
1711 Lisp_Object
*invis_vector_contents
1712 = (dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1713 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
1714 : default_invis_vector
);
1716 GLYPH truncator
= (dp
== 0 || XTYPE (DISP_TRUNC_GLYPH (dp
)) != Lisp_Int
1717 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
1718 GLYPH continuer
= (dp
== 0 || XTYPE (DISP_CONTINUE_GLYPH (dp
)) != Lisp_Int
1719 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
1721 /* The next buffer location at which the face should change, due
1722 to overlays or text property changes. */
1723 int next_face_change
;
1725 /* The face we're currently using. */
1726 int current_face
= 0;
1728 XFASTINT (default_invis_vector
[2]) = '.';
1729 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
1731 hpos
+= XFASTINT (w
->left
);
1732 get_display_line (f
, vpos
, XFASTINT (w
->left
));
1733 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
1735 /* Show where to highlight the region. */
1736 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
1737 /* Maybe highlight only in selected window. */
1738 && (highlight_nonselected_windows
1739 || w
== XWINDOW (selected_window
)))
1741 region_beg
= marker_position (current_buffer
->mark
);
1742 if (PT
< region_beg
)
1744 region_end
= region_beg
;
1749 w
->region_showing
= Qt
;
1752 region_beg
= region_end
= -1;
1754 if (MINI_WINDOW_P (w
) && start
== 1
1755 && vpos
== XFASTINT (w
->top
))
1758 hpos
= display_string (w
, vpos
, minibuf_prompt
, hpos
,
1759 (!truncate
? continuer
: truncator
),
1761 minibuf_prompt_width
= hpos
;
1764 desired_glyphs
->bufp
[vpos
] = pos
;
1765 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
1767 startp
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
1768 endp
= startp
+ width
;
1770 /* Arrange the overlays nicely for our purposes. Usually, we call
1771 display_text_line on only one line at a time, in which case this
1772 can't really hurt too much, or we call it on lines which appear
1773 one after another in the buffer, in which case all calls to
1774 recenter_overlay_lists but the first will be pretty cheap. */
1775 recenter_overlay_lists (current_buffer
, pos
);
1777 /* Loop generating characters.
1778 Stop at end of buffer, before newline,
1779 if reach or pass continuation column,
1780 or at face change. */
1782 next_face_change
= pos
;
1788 /* Did we hit the end of the visible region of the buffer?
1793 /* Did we reach point? Record the cursor location. */
1794 if (pos
== point
&& cursor_vpos
< 0)
1797 cursor_hpos
= p1
- startp
;
1800 #ifdef HAVE_X_WINDOWS
1801 /* Did we hit a face change? Figure out what face we should
1802 use now. We also hit this the first time through the
1803 loop, to see what face we should start with. */
1804 if (pos
== next_face_change
&& FRAME_X_P (f
))
1805 current_face
= compute_char_face (f
, w
, pos
,
1806 region_beg
, region_end
,
1812 if (pos
< next_face_change
&& next_face_change
< pause
)
1813 pause
= next_face_change
;
1815 /* Wouldn't you hate to read the next line to someone over
1817 if (pos
< point
&& point
< pause
)
1819 if (pos
< GPT
&& GPT
< pause
)
1822 p
= &FETCH_CHAR (pos
);
1825 if (c
>= 040 && c
< 0177
1826 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
1829 *p1
= MAKE_GLYPH (c
, current_face
);
1837 && position_indentation (pos
+ 1) >= selective
)
1840 pos
= find_next_newline (pos
+ 1, 1);
1841 if (FETCH_CHAR (pos
- 1) == '\n')
1844 if (invis
&& selective_rlen
> 0 && p1
>= startp
)
1846 p1
+= selective_rlen
;
1847 if (p1
- startp
> width
)
1849 copy_part_of_rope (p1prev
, p1prev
, invis_vector_contents
,
1850 (p1
- p1prev
), current_face
);
1853 /* Draw the face of the newline character as extending all the
1854 way to the end of the frame line. */
1857 *p1
++ = MAKE_GLYPH (' ', current_face
);
1865 if (p1
>= startp
&& p1
< endp
)
1866 *p1
= MAKE_GLYPH (' ', current_face
);
1869 while ((p1
- startp
+ taboffset
+ hscroll
- (hscroll
> 0))
1872 else if (c
== Ctl ('M') && selective
== -1)
1874 pos
= find_next_newline (pos
, 1);
1875 if (FETCH_CHAR (pos
- 1) == '\n')
1877 if (selective_rlen
> 0)
1879 p1
+= selective_rlen
;
1880 if (p1
- startp
> width
)
1882 copy_part_of_rope (p1prev
, p1prev
, invis_vector_contents
,
1883 (p1
- p1prev
), current_face
);
1886 /* Draw the face of the newline character as extending all the
1887 way to the end of the frame line. */
1890 *p1
++ = MAKE_GLYPH (' ', current_face
);
1894 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
1896 p1
= copy_rope (p1
, startp
, DISP_CHAR_VECTOR (dp
, c
), current_face
);
1898 else if (c
< 0200 && ctl_arrow
)
1901 *p1
= MAKE_GLYPH ((dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
1902 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
1905 if (p1
>= startp
&& p1
< endp
)
1906 *p1
= MAKE_GLYPH (c
^ 0100, current_face
);
1912 *p1
= MAKE_GLYPH ((dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
1913 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
1916 if (p1
>= startp
&& p1
< endp
)
1917 *p1
= MAKE_GLYPH ((c
>> 6) + '0', current_face
);
1919 if (p1
>= startp
&& p1
< endp
)
1920 *p1
= MAKE_GLYPH ((7 & (c
>> 3)) + '0', current_face
);
1922 if (p1
>= startp
&& p1
< endp
)
1923 *p1
= MAKE_GLYPH ((7 & c
) + '0', current_face
);
1930 val
.hpos
= - XINT (w
->hscroll
);
1938 /* Handle continuation in middle of a character */
1939 /* by backing up over it */
1942 /* Don't back up if we never actually displayed any text.
1943 This occurs when the minibuffer prompt takes up the whole line. */
1946 /* Start the next line with that same character */
1948 /* but at negative hpos, to skip the columns output on this line. */
1949 val
.hpos
+= p1prev
- endp
;
1952 /* Keep in this line everything up to the continuation column. */
1956 /* Finish deciding which character to start the next line on,
1957 and what hpos to start it at.
1958 Also set `lastpos' to the last position which counts as "on this line"
1959 for cursor-positioning. */
1963 if (FETCH_CHAR (pos
) == '\n')
1964 /* If stopped due to a newline, start next line after it */
1967 /* Stopped due to right margin of window */
1972 /* Truncating => start next line after next newline,
1973 and point is on this line if it is before the newline,
1974 and skip none of first char of next line */
1975 pos
= find_next_newline (pos
, 1);
1976 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1978 lastpos
= pos
- (FETCH_CHAR (pos
- 1) == '\n');
1989 /* If point is at eol or in invisible text at eol,
1990 record its frame location now. */
1992 if (start
<= point
&& point
<= lastpos
&& cursor_vpos
< 0)
1995 cursor_hpos
= p1
- startp
;
1998 if (cursor_vpos
== vpos
)
2000 if (cursor_hpos
< 0) cursor_hpos
= 0;
2001 if (cursor_hpos
> width
) cursor_hpos
= width
;
2002 cursor_hpos
+= XFASTINT (w
->left
);
2003 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
2005 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2006 FRAME_CURSOR_X (f
) = cursor_hpos
;
2008 if (w
== XWINDOW (selected_window
))
2010 /* Line is not continued and did not start
2011 in middle of character */
2012 if ((hpos
- XFASTINT (w
->left
)
2013 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2016 this_line_bufpos
= start
;
2017 this_line_buffer
= current_buffer
;
2018 this_line_vpos
= cursor_vpos
;
2019 this_line_start_hpos
= hpos
;
2020 this_line_endpos
= Z
- lastpos
;
2023 this_line_bufpos
= 0;
2028 /* If hscroll and line not empty, insert truncation-at-left marker */
2029 if (hscroll
&& lastpos
!= start
)
2031 *startp
= truncator
;
2036 if (XFASTINT (w
->width
) + XFASTINT (w
->left
) != FRAME_WIDTH (f
))
2039 if (p1
< startp
) p1
= startp
;
2040 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
2042 /* Don't draw vertical bars if we're using scroll bars. They're
2043 covered up by the scroll bars, and it's distracting to see
2044 them when the scroll bar windows are flickering around to be
2046 *p1
++ = (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
2049 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
2050 p1
- desired_glyphs
->glyphs
[vpos
]);
2051 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2053 /* If the start of this line is the overlay arrow-position,
2054 then put the arrow string into the display-line. */
2056 if (XTYPE (Voverlay_arrow_position
) == Lisp_Marker
2057 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
2058 && start
== marker_position (Voverlay_arrow_position
)
2059 && XTYPE (Voverlay_arrow_string
) == Lisp_String
2060 && ! overlay_arrow_seen
)
2062 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
2064 int len
= XSTRING (Voverlay_arrow_string
)->size
;
2069 for (i
= 0; i
< len
; i
++)
2072 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
2073 arrow_end
= (startp
- desired_glyphs
->glyphs
[vpos
]) + len
;
2074 if (desired_glyphs
->used
[vpos
] < arrow_end
)
2075 desired_glyphs
->used
[vpos
] = arrow_end
;
2077 overlay_arrow_seen
= 1;
2081 val_display_text_line
= val
;
2082 return &val_display_text_line
;
2085 /* Redisplay the menu bar in the frame for window W. */
2088 display_menu_bar (w
)
2091 Lisp_Object items
, tail
;
2092 register int vpos
= 0;
2093 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2094 int maxendcol
= FRAME_WIDTH (f
);
2097 if (FRAME_MENU_BAR_LINES (f
) <= 0)
2100 get_display_line (f
, vpos
, 0);
2102 /* If the user has switched buffers or windows, we need to
2103 recompute to reflect the new bindings. But we'll
2104 recompute when update_mode_lines is set too; that means
2105 that people can use force-mode-line-update to request
2106 that the menu bar be recomputed. The adverse effect on
2107 the rest of the redisplay algorithm is about the same as
2108 windows_or_buffers_changed anyway. */
2109 if (windows_or_buffers_changed
2110 || update_mode_lines
2111 || (XFASTINT (w
->last_modified
) < MODIFF
2112 && (XFASTINT (w
->last_modified
)
2113 <= XBUFFER (w
->buffer
)->save_modified
)))
2115 struct buffer
*prev
= current_buffer
;
2116 current_buffer
= XBUFFER (w
->buffer
);
2117 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items ();
2118 current_buffer
= prev
;
2121 for (tail
= FRAME_MENU_BAR_ITEMS (f
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2125 string
= XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->car
;
2127 /* Record in each item its hpos. */
2128 XFASTINT (XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->cdr
) = hpos
;
2130 if (hpos
< maxendcol
)
2131 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
2132 XSTRING (string
)->data
,
2133 hpos
, 0, hpos
, maxendcol
);
2134 /* Put a gap of 3 spaces between items. */
2135 if (hpos
< maxendcol
)
2137 int hpos1
= hpos
+ 3;
2138 hpos
= display_string (w
, vpos
, "", hpos
, 0,
2139 min (hpos1
, maxendcol
), maxendcol
);
2143 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2144 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2146 /* Fill out the line with spaces. */
2147 if (maxendcol
> hpos
)
2148 hpos
= display_string (w
, vpos
, "", hpos
, 0, maxendcol
, -1);
2151 /* Display the mode line for window w */
2154 display_mode_line (w
)
2157 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
2158 register int left
= XFASTINT (w
->left
);
2159 register int right
= XFASTINT (w
->width
) + left
;
2160 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2162 line_number_displayed
= 0;
2164 get_display_line (f
, vpos
, left
);
2165 display_mode_element (w
, vpos
, left
, 0, right
, right
,
2166 current_buffer
->mode_line_format
);
2167 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2169 /* Make the mode line inverse video if the entire line
2170 is made of mode lines.
2171 I.e. if this window is full width,
2172 or if it is the child of a full width window
2173 (which implies that that window is split side-by-side
2174 and the rest of this line is mode lines of the sibling windows). */
2175 if (XFASTINT (w
->width
) == FRAME_WIDTH (f
)
2176 || XFASTINT (XWINDOW (w
->parent
)->width
) == FRAME_WIDTH (f
))
2177 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2179 #ifdef HAVE_X_WINDOWS
2180 /* I'm trying this out because I saw Unimpress use it, but it's
2181 possible that this may mess adversely with some window managers. -jla
2183 Wouldn't it be nice to use something like mode-line-format to
2184 describe frame titles? -JimB */
2186 /* Change the title of the frame to the name of the buffer displayed
2187 in the currently selected window. Don't do this for minibuffer frames,
2188 and don't do it when there's only one non-minibuffer frame. */
2190 && ! FRAME_MINIBUF_ONLY_P (f
)
2191 && w
== XWINDOW (f
->selected_window
))
2192 x_implicitly_set_name (f
, (EQ (Fnext_frame (WINDOW_FRAME (w
), Qnil
),
2195 : XBUFFER (w
->buffer
)->name
),
2200 /* Contribute ELT to the mode line for window W.
2201 How it translates into text depends on its data type.
2203 VPOS is the position of the mode line being displayed.
2205 HPOS is the position (absolute on frame) where this element's text
2206 should start. The output is truncated automatically at the right
2209 DEPTH is the depth in recursion. It is used to prevent
2210 infinite recursion here.
2212 MINENDCOL is the hpos before which the element may not end.
2213 The element is padded at the right with spaces if nec
2214 to reach this column.
2216 MAXENDCOL is the hpos past which this element may not extend.
2217 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
2218 (This is necessary to make nested padding and truncation work.)
2220 Returns the hpos of the end of the text generated by ELT.
2221 The next element will receive that value as its HPOS arg,
2222 so as to concatenate the elements. */
2225 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
2227 register int vpos
, hpos
;
2230 register int maxendcol
;
2231 register Lisp_Object elt
;
2239 #ifdef SWITCH_ENUM_BUG
2240 switch ((int) XTYPE (elt
))
2242 switch (XTYPE (elt
))
2247 /* A string: output it and check for %-constructs within it. */
2248 register unsigned char c
;
2249 register unsigned char *this = XSTRING (elt
)->data
;
2251 while (hpos
< maxendcol
&& *this)
2253 unsigned char *last
= this;
2254 while ((c
= *this++) != '\0' && c
!= '%')
2256 if (this - 1 != last
)
2258 register int lim
= --this - last
+ hpos
;
2259 hpos
= display_string (w
, vpos
, last
, hpos
, 0, hpos
,
2260 min (lim
, maxendcol
));
2264 register int spec_width
= 0;
2266 /* We can't allow -ve args due to the "%-" construct */
2267 /* Argument specifies minwidth but not maxwidth
2268 (maxwidth can be specified by
2269 (<negative-number> . <stuff>) mode-line elements) */
2271 while ((c
= *this++) >= '0' && c
<= '9')
2273 spec_width
= spec_width
* 10 + (c
- '0');
2277 if (spec_width
> maxendcol
)
2278 spec_width
= maxendcol
;
2281 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2282 spec_width
, maxendcol
,
2283 Vglobal_mode_string
);
2285 hpos
= display_string (w
, vpos
,
2286 decode_mode_spec (w
, c
,
2288 hpos
, 0, spec_width
, maxendcol
);
2295 /* A symbol: process the value of the symbol recursively
2296 as if it appeared here directly. Avoid error if symbol void.
2297 Special case: if value of symbol is a string, output the string
2300 register Lisp_Object tem
;
2301 tem
= Fboundp (elt
);
2304 tem
= Fsymbol_value (elt
);
2305 /* If value is a string, output that string literally:
2306 don't check for % within it. */
2307 if (XTYPE (tem
) == Lisp_String
)
2308 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
2309 hpos
, 0, minendcol
, maxendcol
);
2310 /* Give up right away for nil or t. */
2311 else if (!EQ (tem
, elt
))
2312 { elt
= tem
; goto tail_recurse
; }
2319 register Lisp_Object car
, tem
;
2321 /* A cons cell: three distinct cases.
2322 If first element is a string or a cons, process all the elements
2323 and effectively concatenate them.
2324 If first element is a negative number, truncate displaying cdr to
2325 at most that many characters. If positive, pad (with spaces)
2326 to at least that many characters.
2327 If first element is a symbol, process the cadr or caddr recursively
2328 according to whether the symbol's value is non-nil or nil. */
2329 car
= XCONS (elt
)->car
;
2330 if (XTYPE (car
) == Lisp_Symbol
)
2332 tem
= Fboundp (car
);
2333 elt
= XCONS (elt
)->cdr
;
2334 if (XTYPE (elt
) != Lisp_Cons
)
2336 /* elt is now the cdr, and we know it is a cons cell.
2337 Use its car if CAR has a non-nil value. */
2340 tem
= Fsymbol_value (car
);
2342 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
2344 /* Symbol's value is nil (or symbol is unbound)
2345 Get the cddr of the original list
2346 and if possible find the caddr and use that. */
2347 elt
= XCONS (elt
)->cdr
;
2350 else if (XTYPE (elt
) != Lisp_Cons
)
2352 elt
= XCONS (elt
)->car
;
2355 else if (XTYPE (car
) == Lisp_Int
)
2357 register int lim
= XINT (car
);
2358 elt
= XCONS (elt
)->cdr
;
2360 /* Negative int means reduce maximum width.
2361 DO NOT change MINENDCOL here!
2362 (20 -10 . foo) should truncate foo to 10 col
2363 and then pad to 20. */
2364 maxendcol
= min (maxendcol
, hpos
- lim
);
2367 /* Padding specified. Don't let it be more than
2370 if (lim
> maxendcol
)
2372 /* If that's more padding than already wanted, queue it.
2373 But don't reduce padding already specified even if
2374 that is beyond the current truncation point. */
2375 if (lim
> minendcol
)
2380 else if (XTYPE (car
) == Lisp_String
|| XTYPE (car
) == Lisp_Cons
)
2382 register int limit
= 50;
2383 /* LIMIT is to protect against circular lists. */
2384 while (XTYPE (elt
) == Lisp_Cons
&& --limit
> 0
2385 && hpos
< maxendcol
)
2387 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2390 elt
= XCONS (elt
)->cdr
;
2398 return (display_string (w
, vpos
, "*invalid*", hpos
, 0,
2399 minendcol
, maxendcol
));
2403 if (minendcol
> hpos
)
2404 hpos
= display_string (w
, vpos
, "", hpos
, 0, minendcol
, -1);
2408 /* Return a string for the output of a mode line %-spec for window W,
2409 generated by character C and width MAXWIDTH. */
2411 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
2414 decode_mode_spec (w
, c
, maxwidth
)
2417 register int maxwidth
;
2419 Lisp_Object obj
= Qnil
;
2420 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2421 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
2423 if (maxwidth
> FRAME_WIDTH (f
))
2424 maxwidth
= FRAME_WIDTH (f
);
2429 obj
= current_buffer
->name
;
2431 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
2433 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
2434 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
2435 decode_mode_spec_buf
[maxwidth
] = '\0';
2436 return decode_mode_spec_buf
;
2442 obj
= current_buffer
->filename
;
2446 else if (XTYPE (obj
) == Lisp_String
&& XSTRING (obj
)->size
> maxwidth
)
2448 bcopy ("...", decode_mode_spec_buf
, 3);
2449 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
2450 decode_mode_spec_buf
+ 3, maxwidth
- 3);
2451 return decode_mode_spec_buf
;
2458 int startpos
= marker_position (w
->start
);
2459 int line
, linepos
, topline
;
2462 int height
= XFASTINT (w
->height
);
2464 /* If we decided that this buffer isn't suitable for line numbers,
2465 don't forget that too fast. */
2466 if (EQ (w
->base_line_pos
, w
->buffer
))
2469 /* If the buffer is very big, don't waste time. */
2470 if (ZV
- BEGV
> line_number_display_limit
)
2472 w
->base_line_pos
= Qnil
;
2473 w
->base_line_number
= Qnil
;
2477 if (!NILP (w
->base_line_number
)
2478 && !NILP (w
->base_line_pos
)
2479 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
2481 line
= XFASTINT (w
->base_line_number
);
2482 linepos
= XFASTINT (w
->base_line_pos
);
2490 /* Count lines from base line to window start position. */
2491 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
2493 topline
= nlines
+ line
;
2495 /* Determine a new base line, if the old one is too close
2496 or too far away, or if we did not have one.
2497 "Too close" means it's plausible a scroll-down would
2499 if (startpos
== BEGV
)
2501 XFASTINT (w
->base_line_number
) = topline
;
2502 XFASTINT (w
->base_line_pos
) = BEGV
;
2504 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
2509 int distance
= (height
* 2 + 30) * 200;
2511 if (startpos
- distance
> limit
)
2512 limit
= startpos
- distance
;
2514 nlines
= display_count_lines (startpos
, limit
,
2517 /* If we couldn't find the lines we wanted within
2519 give up on line numbers for this window. */
2520 if (position
== startpos
- distance
)
2522 w
->base_line_pos
= w
->buffer
;
2523 w
->base_line_number
= Qnil
;
2527 XFASTINT (w
->base_line_number
) = topline
- nlines
;
2528 XFASTINT (w
->base_line_pos
) = position
;
2531 /* Now count lines from the start pos to point. */
2532 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
2534 /* Record that we did display the line number. */
2535 line_number_displayed
= 1;
2537 /* Make the string to show. */
2538 sprintf (decode_mode_spec_buf
, "%d", topline
+ nlines
);
2539 return decode_mode_spec_buf
;
2544 obj
= current_buffer
->mode_name
;
2548 if (BEGV
> BEG
|| ZV
< Z
)
2553 if (!NILP (current_buffer
->read_only
))
2555 if (MODIFF
> current_buffer
->save_modified
)
2560 /* status of process */
2561 obj
= Fget_buffer_process (Fcurrent_buffer ());
2563 return "no process";
2564 obj
= Fsymbol_name (Fprocess_status (obj
));
2569 int pos
= marker_position (w
->start
);
2570 int total
= ZV
- BEGV
;
2572 if (XFASTINT (w
->window_end_pos
) <= Z
- ZV
)
2579 else if (pos
<= BEGV
)
2583 total
= ((pos
- BEGV
) * 100 + total
- 1) / total
;
2584 /* We can't normally display a 3-digit number,
2585 so get us a 2-digit number that is close. */
2588 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
2589 return decode_mode_spec_buf
;
2601 if (command_loop_level
> 5)
2603 p
= decode_mode_spec_buf
;
2604 for (i
= 0; i
< command_loop_level
; i
++)
2607 return decode_mode_spec_buf
;
2615 if (command_loop_level
> 5)
2617 p
= decode_mode_spec_buf
;
2618 for (i
= 0; i
< command_loop_level
; i
++)
2621 return decode_mode_spec_buf
;
2629 if (maxwidth
< sizeof (lots_of_dashes
))
2630 return lots_of_dashes
;
2633 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
2637 return decode_mode_spec_buf
;
2641 if (XTYPE (obj
) == Lisp_String
)
2642 return (char *) XSTRING (obj
)->data
;
2647 /* Count up to N lines starting from FROM.
2648 But don't go beyond LIMIT.
2649 Return the number of lines thus found (always positive).
2650 Store the position after what was found into *POS_PTR. */
2653 display_count_lines (from
, limit
, n
, pos_ptr
)
2666 *pos_ptr
= scan_buffer ('\n', from
, n
, &shortage
);
2672 /* When scanning backwards, scan_buffer stops *after* the last newline
2673 it finds, but does count it. Compensate for that. */
2674 return - n
- shortage
- (*pos_ptr
!= limit
);
2675 return n
- shortage
;
2678 /* Display STRING on one line of window W, starting at HPOS.
2679 Display at position VPOS. Caller should have done get_display_line.
2680 If VPOS == -1, display it as the current frame's title.
2682 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
2684 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
2685 MAXCOL is the last column ok to end at. Truncate here.
2686 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
2687 Both count from the left edge of the frame, as does HPOS.
2688 The right edge of W is an implicit maximum.
2689 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
2691 Returns ending hpos */
2694 display_string (w
, vpos
, string
, hpos
, truncate
, mincol
, maxcol
)
2696 unsigned char *string
;
2703 int hscroll
= XINT (w
->hscroll
);
2704 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
2705 register GLYPH
*start
;
2706 register GLYPH
*end
;
2707 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2708 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
2709 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2710 int window_width
= XFASTINT (w
->width
);
2712 /* Use the standard display table, not the window's display table.
2713 We don't want the mode line in rot13. */
2714 register struct Lisp_Vector
*dp
= 0;
2716 if (XTYPE (Vstandard_display_table
) == Lisp_Vector
2717 && XVECTOR (Vstandard_display_table
)->size
== DISP_TABLE_SIZE
)
2718 dp
= XVECTOR (Vstandard_display_table
);
2720 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
2723 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
2724 end
= start
+ window_width
- (truncate
!= 0);
2726 if ((window_width
+ XFASTINT (w
->left
)) != FRAME_WIDTH (f
))
2728 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2732 for (i
= 0; i
< VERTICAL_SCROLL_BAR_WIDTH
; i
++)
2739 if (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
)
2740 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
2741 if (maxcol
>= 0 && mincol
> maxcol
)
2748 if (c
>= 040 && c
< 0177
2749 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
2759 if (p1
>= start
&& p1
< end
)
2763 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
2765 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
2766 p1
= copy_rope (p1
, start
, DISP_CHAR_VECTOR (dp
, c
), 0);
2767 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
2770 *p1
= (dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
2771 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^');
2773 if (p1
>= start
&& p1
< end
)
2780 *p1
= (dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
2781 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\');
2783 if (p1
>= start
&& p1
< end
)
2784 *p1
= (c
>> 6) + '0';
2786 if (p1
>= start
&& p1
< end
)
2787 *p1
= (7 & (c
>> 3)) + '0';
2789 if (p1
>= start
&& p1
< end
)
2790 *p1
= (7 & c
) + '0';
2798 if (truncate
) *p1
++ = truncate
;
2800 else if (mincol
>= 0)
2802 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
2808 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
2810 if (len
> desired_glyphs
->used
[vpos
])
2811 desired_glyphs
->used
[vpos
] = len
;
2812 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2821 staticpro (&last_arrow_position
);
2822 staticpro (&last_arrow_string
);
2823 last_arrow_position
= Qnil
;
2824 last_arrow_string
= Qnil
;
2826 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
2827 "String (or mode line construct) included (normally) in `mode-line-format'.");
2828 Vglobal_mode_string
= Qnil
;
2830 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
2831 "Marker for where to display an arrow on top of the buffer text.\n\
2832 This must be the beginning of a line in order to work.\n\
2833 See also `overlay-arrow-string'.");
2834 Voverlay_arrow_position
= Qnil
;
2836 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
2837 "String to display as an arrow. See also `overlay-arrow-position'.");
2838 Voverlay_arrow_string
= Qnil
;
2840 DEFVAR_INT ("scroll-step", &scroll_step
,
2841 "*The number of lines to try scrolling a window by when point moves out.\n\
2842 If that fails to bring point back on frame, point is centered instead.\n\
2843 If this is zero, point is always centered after it moves off frame.");
2845 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
2847 DEFVAR_BOOL ("truncate-partial-width-windows",
2848 &truncate_partial_width_windows
,
2849 "*Non-nil means truncate lines in all windows less than full frame wide.");
2850 truncate_partial_width_windows
= 1;
2852 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
2853 "*Non-nil means use inverse video for the mode line.");
2854 mode_line_inverse_video
= 1;
2856 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
2857 "*Maximum buffer size for which line number should be displayed.");
2858 line_number_display_limit
= 1000000;
2860 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
2861 "*Non-nil means highlight region even in nonselected windows.");
2862 highlight_nonselected_windows
= 1;
2865 /* initialize the window system */
2868 Lisp_Object root_window
;
2869 #ifndef COMPILER_REGISTER_BUG
2871 #endif /* COMPILER_REGISTER_BUG */
2872 struct window
*mini_w
;
2874 this_line_bufpos
= 0;
2876 mini_w
= XWINDOW (minibuf_window
);
2877 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
2879 echo_area_glyphs
= 0;
2880 previous_echo_glyphs
= 0;
2882 if (!noninteractive
)
2884 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
2885 XFASTINT (XWINDOW (root_window
)->top
) = 0;
2886 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
2887 XFASTINT (mini_w
->top
) = FRAME_HEIGHT (f
) - 1;
2888 set_window_height (minibuf_window
, 1, 0);
2890 XFASTINT (XWINDOW (root_window
)->width
) = FRAME_WIDTH (f
);
2891 XFASTINT (mini_w
->width
) = FRAME_WIDTH (f
);