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 /* If cursor motion alone moves point off frame,
96 Try scrolling this many lines up or down if that will bring it back. */
99 /* Nonzero if try_window_id has made blank lines at window bottom
100 since the last redisplay that paused */
101 static int blank_end_of_window
;
103 /* Number of windows showing the buffer of the selected window.
104 keyboard.c refers to this. */
107 /* display_text_line sets these to the frame position (origin 0) of point,
108 whether the window is selected or not.
109 Set one to -1 first to determine whether point was found afterwards. */
111 static int cursor_vpos
;
112 static int cursor_hpos
;
116 /* Nonzero means display mode line highlighted */
117 int mode_line_inverse_video
;
119 static void echo_area_display ();
120 void mark_window_display_accurate ();
121 static void redisplay_windows ();
122 static void redisplay_window ();
123 static void try_window ();
124 static int try_window_id ();
125 static struct position
*display_text_line ();
126 static void display_mode_line ();
127 static int display_mode_element ();
128 static char *fmodetrunc ();
129 static char *decode_mode_spec ();
130 static int display_string ();
131 static void display_menu_bar ();
132 static int display_count_lines ();
134 /* Prompt to display in front of the minibuffer contents */
135 char *minibuf_prompt
;
137 /* Width in columns of current minibuffer prompt. */
138 int minibuf_prompt_width
;
140 /* Message to display instead of minibuffer contents
141 This is what the functions error and message make,
142 and command echoing uses it as well.
143 It overrides the minibuf_prompt as well as the buffer. */
144 char *echo_area_glyphs
;
146 /* true iff we should redraw the mode lines on the next redisplay */
147 int update_mode_lines
;
149 /* Smallest number of characters before the gap
150 at any time since last redisplay that finished.
151 Valid for current buffer when try_window_id can be called. */
154 /* Smallest number of characters after the gap
155 at any time since last redisplay that finished.
156 Valid for current buffer when try_window_id can be called. */
159 /* MODIFF as of last redisplay that finished;
160 if it matches MODIFF, beg_unchanged and end_unchanged
161 contain no useful information */
162 int unchanged_modified
;
164 /* Nonzero if head_clip or tail_clip of current buffer has changed
165 since last redisplay that finished */
168 /* Nonzero if window sizes or contents have changed
169 since last redisplay that finished */
170 int windows_or_buffers_changed
;
172 /* Nonzero after display_mode_line if %l was used
173 and it displayed a line number. */
174 int line_number_displayed
;
176 /* Maximum buffer size for which to display line numbers. */
177 int line_number_display_limit
;
179 /* Specify m, a string, as a message in the minibuf. If m is 0, clear out
180 any existing message, and let the minibuffer text show through. */
187 if (noninteractive_need_newline
)
189 noninteractive_need_newline
= 0;
190 if (cursor_in_echo_area
!= 0)
191 fprintf (stderr
, "%s", m
);
193 fprintf (stderr
, "%s\n", m
);
196 /* A null message buffer means that the frame hasn't really been
197 initialized yet. Error messages get reported properly by
198 cmd_error, so this must be just an informative message; toss it. */
199 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
202 Lisp_Object minibuf_frame
;
204 choose_minibuf_frame ();
205 minibuf_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
206 FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame
));
207 if (FRAME_VISIBLE_P (selected_frame
)
208 && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame
)))
209 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window
)));
213 echo_area_glyphs
= m
;
215 echo_area_glyphs
= previous_echo_glyphs
= 0;
217 do_pending_window_change ();
218 echo_area_display ();
219 update_frame (XFRAME (XWINDOW (minibuf_window
)->frame
), 1, 1);
220 do_pending_window_change ();
224 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
225 zero if being used by message. */
226 int message_buf_print
;
228 /* Dump an informative message to the minibuf. If m is 0, clear out
229 any existing message, and let the minibuffer text show through. */
232 message (m
, a1
, a2
, a3
)
239 if (noninteractive_need_newline
)
241 noninteractive_need_newline
= 0;
242 fprintf (stderr
, m
, a1
, a2
, a3
);
243 if (cursor_in_echo_area
== 0)
244 fprintf (stderr
, "\n");
248 else if (INTERACTIVE
)
250 /* The frame whose minibuffer we're going to display the message on.
251 It may be larger than the selected frame, so we need
252 to use its buffer, not the selected frame's buffer. */
253 FRAME_PTR echo_frame
;
255 choose_minibuf_frame ();
256 echo_frame
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
258 echo_frame
= selected_frame
;
261 /* A null message buffer means that the frame hasn't really been
262 initialized yet. Error messages get reported properly by
263 cmd_error, so this must be just an informative message; toss it. */
264 if (FRAME_MESSAGE_BUF (echo_frame
))
275 doprnt (FRAME_MESSAGE_BUF (echo_frame
),
276 FRAME_WIDTH (echo_frame
), m
, 0, 3, a
);
278 doprnt (FRAME_MESSAGE_BUF (echo_frame
),
279 FRAME_WIDTH (echo_frame
), m
, 0, 3, &a1
);
280 #endif /* NO_ARG_ARRAY */
283 message1 (FRAME_MESSAGE_BUF (echo_frame
));
288 /* Print should start at the beginning of the message
290 message_buf_print
= 0;
302 choose_minibuf_frame ();
305 f
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
307 if (! FRAME_VISIBLE_P (f
))
316 if (echo_area_glyphs
|| minibuf_level
== 0)
318 vpos
= XFASTINT (XWINDOW (minibuf_window
)->top
);
319 get_display_line (f
, vpos
, 0);
320 display_string (XWINDOW (minibuf_window
), vpos
,
321 echo_area_glyphs
? echo_area_glyphs
: "",
322 0, 0, 0, FRAME_WIDTH (f
));
324 /* If desired cursor location is on this line, put it at end of text */
325 if (FRAME_CURSOR_Y (f
) == vpos
)
326 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
328 /* Fill the rest of the minibuffer window with blank lines. */
332 for (i
= vpos
+ 1; i
< vpos
+ XWINDOW (minibuf_window
)->height
; i
++)
334 get_display_line (f
, i
, 0);
335 display_string (XWINDOW (minibuf_window
), vpos
,
336 "", 0, 0, 0, FRAME_WIDTH (f
));
340 else if (!EQ (minibuf_window
, selected_window
))
341 windows_or_buffers_changed
++;
343 if (EQ (minibuf_window
, selected_window
))
344 this_line_bufpos
= 0;
346 previous_echo_glyphs
= echo_area_glyphs
;
349 /* Do a frame update, taking possible shortcuts into account.
350 This is the main external entry point for redisplay.
352 If the last redisplay displayed an echo area message and that
353 message is no longer requested, we clear the echo area
354 or bring back the minibuffer if that is in use.
356 Everyone would like to have a hook here to call eval,
357 but that cannot be done safely without a lot of changes elsewhere.
358 This can be called from signal handlers; with alarms set up;
359 or with synchronous processes running.
360 See the function `echo' in keyboard.c.
361 See Fcall_process; if you called it from here, it could be
362 entered recursively. */
367 register struct window
*w
= XWINDOW (selected_window
);
371 register int tlbufpos
, tlendpos
;
373 extern int input_pending
;
378 /* Set the visible flags for all frames.
379 Do this before checking for resized or garbaged frames; they want
380 to know if their frames are visible.
381 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
383 Lisp_Object tail
, frame
;
385 FOR_EACH_FRAME (tail
, frame
)
386 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
389 /* Notice any pending interrupt request to change frame size. */
390 do_pending_window_change ();
398 /* Normally the message* functions will have already displayed and
399 updated the echo area, but the frame may have been trashed, or
400 the update may have been preempted, so display the echo area
402 if (echo_area_glyphs
|| previous_echo_glyphs
)
404 echo_area_display ();
408 if (clip_changed
|| windows_or_buffers_changed
)
411 /* Detect case that we need to write a star in the mode line. */
412 if (XFASTINT (w
->last_modified
) < MODIFF
413 && XFASTINT (w
->last_modified
) <= current_buffer
->save_modified
)
415 w
->update_mode_line
= Qt
;
416 if (buffer_shared
> 1)
420 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
422 all_windows
= update_mode_lines
|| buffer_shared
> 1;
424 /* If specs for an arrow have changed, do thorough redisplay
425 to ensure we remove any arrow that should no longer exist. */
426 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
427 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
428 all_windows
= 1, clip_changed
= 1;
430 /* If showing region, and mark has changed, must redisplay whole window. */
431 if (((!NILP (Vtransient_mark_mode
)
432 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
433 != !NILP (w
->region_showing
))
434 || !EQ (w
->region_showing
,
435 Fmarker_position (XBUFFER (w
->buffer
)->mark
)))
436 this_line_bufpos
= -1;
438 tlbufpos
= this_line_bufpos
;
439 tlendpos
= this_line_endpos
;
440 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
441 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
442 /* Make sure recorded data applies to current buffer, etc */
443 && this_line_buffer
== current_buffer
444 && current_buffer
== XBUFFER (w
->buffer
)
445 && NILP (w
->force_start
)
446 /* Point must be on the line that we have info recorded about */
448 && point
<= Z
- tlendpos
449 /* All text outside that line, including its final newline,
451 && (XFASTINT (w
->last_modified
) >= MODIFF
452 || (beg_unchanged
>= tlbufpos
- 1
454 /* If selective display, can't optimize
455 if the changes start at the beginning of the line. */
456 && ((XTYPE (current_buffer
->selective_display
) == Lisp_Int
457 && XINT (current_buffer
->selective_display
) > 0
458 ? (beg_unchanged
>= tlbufpos
461 && end_unchanged
>= tlendpos
462 && Z
- GPT
>= tlendpos
)))
464 if (tlbufpos
> BEGV
&& FETCH_CHAR (tlbufpos
- 1) != '\n'
466 || FETCH_CHAR (tlbufpos
) == '\n'))
467 /* Former continuation line has disappeared by becoming empty */
469 else if (XFASTINT (w
->last_modified
) < MODIFF
470 || MINI_WINDOW_P (w
))
473 overlay_arrow_seen
= 0;
474 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
475 pos_tab_offset (w
, tlbufpos
));
476 /* If line contains point, is not continued,
477 and ends at same distance from eob as before, we win */
478 if (cursor_vpos
>= 0 && this_line_bufpos
479 && this_line_endpos
== tlendpos
)
481 if (XFASTINT (w
->width
) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w
))))
482 preserve_other_columns (w
);
488 else if (point
== XFASTINT (w
->last_point
))
492 do_pending_window_change ();
497 /* If highlighting the region, we can't just move the cursor. */
498 else if (! (!NILP (Vtransient_mark_mode
)
499 && !NILP (current_buffer
->mark_active
))
500 && NILP (w
->region_showing
))
502 pos
= *compute_motion (tlbufpos
, 0,
503 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
504 point
, 2, - (1 << (SHORTBITS
- 1)),
505 window_internal_width (w
) - 1,
507 pos_tab_offset (w
, tlbufpos
));
510 FRAME_CURSOR_X (selected_frame
)
511 = XFASTINT (w
->left
) + max (pos
.hpos
, 0);
512 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
519 /* Text changed drastically or point moved off of line */
520 cancel_line (this_line_vpos
, selected_frame
);
523 this_line_bufpos
= 0;
524 all_windows
|= buffer_shared
> 1;
528 Lisp_Object tail
, frame
;
530 #ifdef HAVE_X_WINDOWS
531 /* Since we're doing a thorough redisplay, we might as well
532 recompute all our display faces. */
533 clear_face_vector ();
536 /* Recompute # windows showing selected buffer.
537 This will be incremented each time such a window is displayed. */
540 FOR_EACH_FRAME (tail
, frame
)
542 FRAME_PTR f
= XFRAME (frame
);
544 /* Mark all the scroll bars to be removed; we'll redeem the ones
545 we want when we redisplay their windows. */
546 if (condemn_scroll_bars_hook
)
547 (*condemn_scroll_bars_hook
) (f
);
549 if (FRAME_VISIBLE_P (f
))
550 redisplay_windows (FRAME_ROOT_WINDOW (f
));
552 /* Any scroll bars which redisplay_windows should have nuked
553 should now go away. */
554 if (judge_scroll_bars_hook
)
555 (*judge_scroll_bars_hook
) (f
);
558 else if (FRAME_VISIBLE_P (selected_frame
))
560 redisplay_window (selected_window
, 1);
561 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
562 preserve_other_columns (w
);
566 /* Prevent various kinds of signals during display update.
567 stdio is not robust about handling signals,
568 which can cause an apparent I/O error. */
580 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
584 if (XTYPE (XCONS (tail
)->car
) != Lisp_Frame
)
587 f
= XFRAME (XCONS (tail
)->car
);
588 if (FRAME_VISIBLE_P (f
))
590 pause
|= update_frame (f
, 0, 0);
592 mark_window_display_accurate (f
->root_window
, 1);
597 #endif /* MULTI_FRAME */
599 if (FRAME_VISIBLE_P (selected_frame
))
600 pause
= update_frame (selected_frame
, 0, 0);
602 /* We may have called echo_area_display at the top of this
603 function. If the echo area is on another frame, that may
604 have put text on a frame other than the selected one, so the
605 above call to update_frame would not have caught it. Catch
608 FRAME_PTR mini_frame
=
609 XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
611 if (mini_frame
!= selected_frame
)
612 pause
|= update_frame (mini_frame
, 0, 0);
616 /* If frame does not match, prevent doing single-line-update next time.
617 Also, don't forget to check every line to update the arrow. */
620 this_line_bufpos
= 0;
621 if (!NILP (last_arrow_position
))
623 last_arrow_position
= Qt
;
624 last_arrow_string
= Qt
;
626 /* If we pause after scrolling, some lines in current_frame
627 may be null, so preserve_other_columns won't be able to
628 preserve all the vertical-bar separators. So, avoid using it
630 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
631 update_mode_lines
= 1;
634 /* Now text on frame agrees with windows, so
635 put info into the windows for partial redisplay to follow */
639 register struct buffer
*b
= XBUFFER (w
->buffer
);
641 blank_end_of_window
= 0;
643 unchanged_modified
= BUF_MODIFF (b
);
644 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
645 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
647 XFASTINT (w
->last_point
) = BUF_PT (b
);
648 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (selected_frame
);
649 XFASTINT (w
->last_point_y
) = FRAME_CURSOR_Y (selected_frame
);
652 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
655 w
->update_mode_line
= Qnil
;
656 XFASTINT (w
->last_modified
) = BUF_MODIFF (b
);
657 w
->window_end_valid
= Qt
;
658 last_arrow_position
= Voverlay_arrow_position
;
659 last_arrow_string
= Voverlay_arrow_string
;
661 update_mode_lines
= 0;
662 windows_or_buffers_changed
= 0;
665 /* Start SIGIO interrupts coming again.
666 Having them off during the code above
667 makes it less likely one will discard output,
668 but not impossible, since there might be stuff
669 in the system buffer here.
670 But it is much hairier to try to do anything about that. */
676 /* Change frame size now if a change is pending. */
677 do_pending_window_change ();
680 /* Redisplay, but leave alone any recent echo area message
681 unless another message has been requested in its place.
683 This is useful in situations where you need to redisplay but no
684 user action has occurred, making it inappropriate for the message
685 area to be cleared. See tracking_off and
686 wait_reading_process_input for examples of these situations. */
688 redisplay_preserve_echo_area ()
690 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
692 echo_area_glyphs
= previous_echo_glyphs
;
694 echo_area_glyphs
= 0;
701 mark_window_display_accurate (window
, flag
)
705 register struct window
*w
;
707 for (;!NILP (window
); window
= w
->next
)
709 if (XTYPE (window
) != Lisp_Window
) abort ();
710 w
= XWINDOW (window
);
712 if (!NILP (w
->buffer
))
714 XFASTINT (w
->last_modified
)
716 : XBUFFER (w
->buffer
) == current_buffer
717 ? MODIFF
: BUF_MODIFF (XBUFFER (w
->buffer
));
719 /* Record if we are showing a region, so can make sure to
720 update it fully at next redisplay. */
721 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
722 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
723 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
727 w
->window_end_valid
= Qt
;
728 w
->update_mode_line
= Qnil
;
730 if (!NILP (w
->vchild
))
731 mark_window_display_accurate (w
->vchild
, flag
);
732 if (!NILP (w
->hchild
))
733 mark_window_display_accurate (w
->hchild
, flag
);
738 last_arrow_position
= Voverlay_arrow_position
;
739 last_arrow_string
= Voverlay_arrow_string
;
743 /* t is unequal to any useful value of Voverlay_arrow_... */
744 last_arrow_position
= Qt
;
745 last_arrow_string
= Qt
;
752 redisplay_windows (window
)
755 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
756 redisplay_window (window
, 0);
760 redisplay_window (window
, just_this_one
)
764 register struct window
*w
= XWINDOW (window
);
765 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
767 register int lpoint
= point
;
768 struct buffer
*old
= current_buffer
;
769 register int width
= window_internal_width (w
) - 1;
771 register int hscroll
= XINT (w
->hscroll
);
775 int window_needs_modeline
;
777 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
779 /* If this is a combination window, do its children; that's all. */
781 if (!NILP (w
->vchild
))
783 redisplay_windows (w
->vchild
);
786 if (!NILP (w
->hchild
))
788 redisplay_windows (w
->hchild
);
791 if (NILP (w
->buffer
))
794 height
= window_internal_height (w
);
796 if (MINI_WINDOW_P (w
))
798 if (w
== XWINDOW (minibuf_window
))
800 if (echo_area_glyphs
)
801 /* We've already displayed the echo area glyphs, if any. */
802 goto finish_scroll_bars
;
806 /* This is a minibuffer, but it's not the currently active one, so
808 int vpos
= XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
811 for (i
= 0; i
< height
; i
++)
813 get_display_line (f
, vpos
+ i
, 0);
814 display_string (w
, vpos
+ i
, "", 0, 0, 0, width
);
817 goto finish_scroll_bars
;
821 if (update_mode_lines
)
822 w
->update_mode_line
= Qt
;
824 /* Otherwise set up data on this window; select its buffer and point value */
826 current_buffer
= XBUFFER (w
->buffer
);
829 /* Count number of windows showing the selected buffer. */
832 && current_buffer
== XBUFFER (XWINDOW (selected_window
)->buffer
))
835 /* POINT refers normally to the selected window.
836 For any other window, set up appropriate value. */
838 if (!EQ (window
, selected_window
))
840 SET_PT (marker_position (w
->pointm
));
844 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
846 else if (point
> (ZV
- 1))
849 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
853 /* If window-start is screwed up, choose a new one. */
854 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
857 startp
= marker_position (w
->start
);
859 /* Handle case where place to start displaying has been specified,
860 unless the specified location is outside the accessible range. */
861 if (!NILP (w
->force_start
))
863 /* Forget any recorded base line for line number display. */
864 w
->base_line_number
= Qnil
;
865 w
->update_mode_line
= Qt
;
866 w
->force_start
= Qnil
;
867 XFASTINT (w
->last_modified
) = 0;
868 if (startp
< BEGV
) startp
= BEGV
;
869 if (startp
> ZV
) startp
= ZV
;
870 try_window (window
, startp
);
873 /* ??? What should happen here if highlighting a region? */
874 /* If point does not appear, move point so it does appear */
875 pos
= *compute_motion (startp
, 0,
876 ((EQ (window
, minibuf_window
) && startp
== 1)
877 ? minibuf_prompt_width
: 0)
879 (hscroll
? 1 - hscroll
: 0),
881 - (1 << (SHORTBITS
- 1)),
882 width
, hscroll
, pos_tab_offset (w
, startp
));
884 if (w
!= XWINDOW (FRAME_SELECTED_WINDOW (f
)))
885 Fset_marker (w
->pointm
, make_number (point
), Qnil
);
889 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
890 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
896 /* Handle case where text has not changed, only point,
897 and it has not moved off the frame */
899 /* This code is not used for minibuffer for the sake of
900 the case of redisplaying to replace an echo area message;
901 since in that case the minibuffer contents per se are usually unchanged.
902 This code is of no real use in the minibuffer since
903 the handling of this_line_bufpos, etc.,
904 in redisplay handles the same cases. */
906 if (XFASTINT (w
->last_modified
) >= MODIFF
907 && point
>= startp
&& !clip_changed
908 && (just_this_one
|| XFASTINT (w
->width
) == FRAME_WIDTH (f
))
909 /* Can't use this case if highlighting a region. */
910 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
911 && NILP (w
->region_showing
)
912 && !EQ (window
, minibuf_window
))
914 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0),
915 point
, height
+ 1, 10000, width
, hscroll
,
916 pos_tab_offset (w
, startp
));
918 if (pos
.vpos
< height
)
920 /* Ok, point is still on frame */
921 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
923 /* These variables are supposed to be origin 1 */
924 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
925 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
927 /* This doesn't do the trick, because if a window to the right of
928 this one must be redisplayed, this does nothing because there
929 is nothing in DesiredFrame yet, and then the other window is
930 redisplayed, making likes that are empty in this window's columns.
931 if (XFASTINT (w->width) != FRAME_WIDTH (f))
932 preserve_my_columns (w);
936 /* Don't bother trying redisplay with same start;
937 we already know it will lose */
939 /* If current starting point was originally the beginning of a line
940 but no longer is, find a new starting point. */
941 else if (!NILP (w
->start_at_line_beg
)
943 || FETCH_CHAR (startp
- 1) == '\n'))
947 else if (just_this_one
&& !MINI_WINDOW_P (w
)
949 && XFASTINT (w
->last_modified
)
950 && ! EQ (w
->window_end_valid
, Qnil
)
951 && do_id
&& !clip_changed
952 && !blank_end_of_window
953 && XFASTINT (w
->width
) == FRAME_WIDTH (f
)
954 /* Can't use this case if highlighting a region. */
955 && !(!NILP (Vtransient_mark_mode
)
956 && !NILP (current_buffer
->mark_active
))
957 && NILP (w
->region_showing
)
958 && EQ (last_arrow_position
, Voverlay_arrow_position
)
959 && EQ (last_arrow_string
, Voverlay_arrow_string
)
960 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
963 /* tem > 0 means success. tem == -1 means choose new start.
964 tem == -2 means try again with same start,
965 and nothing but whitespace follows the changed stuff.
966 tem == 0 means try again with same start. */
970 else if (startp
>= BEGV
&& startp
<= ZV
971 /* Avoid starting display at end of buffer! */
972 && (startp
< ZV
|| startp
== BEGV
973 || (XFASTINT (w
->last_modified
) >= MODIFF
)))
975 /* Try to redisplay starting at same place as before */
976 /* If point has not moved off frame, accept the results */
977 try_window (window
, startp
);
978 if (cursor_vpos
>= 0)
980 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
981 /* Forget any recorded base line for line number display. */
982 w
->base_line_number
= Qnil
;
986 cancel_my_columns (w
);
989 XFASTINT (w
->last_modified
) = 0;
990 w
->update_mode_line
= Qt
;
992 /* Try to scroll by specified few lines */
994 if (scroll_step
&& !clip_changed
)
998 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
999 scroll_step
, width
, hscroll
, window
);
1000 if (pos
.vpos
>= height
)
1004 pos
= *vmotion (startp
, point
< startp
? - scroll_step
: scroll_step
,
1005 width
, hscroll
, window
);
1007 if (point
>= pos
.bufpos
)
1009 try_window (window
, pos
.bufpos
);
1010 if (cursor_vpos
>= 0)
1012 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1013 /* Forget any recorded base line for line number display. */
1014 w
->base_line_number
= Qnil
;
1018 cancel_my_columns (w
);
1023 /* Finally, just choose place to start which centers point */
1026 /* Forget any previously recorded base line for line number display. */
1027 w
->base_line_number
= Qnil
;
1029 pos
= *vmotion (point
, - height
/ 2, width
, hscroll
, window
);
1030 try_window (window
, pos
.bufpos
);
1032 startp
= marker_position (w
->start
);
1033 w
->start_at_line_beg
=
1034 (startp
== BEGV
|| FETCH_CHAR (startp
- 1) == '\n') ? Qt
: Qnil
;
1037 if ((!NILP (w
->update_mode_line
)
1038 /* If window not full width, must redo its mode line
1039 if the window to its side is being redone */
1040 || (!just_this_one
&& width
< FRAME_WIDTH (f
) - 1)
1041 || INTEGERP (w
->base_line_pos
))
1042 && height
!= XFASTINT (w
->height
))
1043 display_mode_line (w
);
1044 if (! line_number_displayed
1045 && ! BUFFERP (w
->base_line_pos
))
1047 w
->base_line_pos
= Qnil
;
1048 w
->base_line_number
= Qnil
;
1051 /* When we reach a frame's selected window, redo the frame's menu bar. */
1052 if (!NILP (w
->update_mode_line
)
1053 && FRAME_MENU_BAR_LINES (f
) > 0
1054 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
1055 display_menu_bar (w
);
1058 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1060 int start
, end
, whole
;
1062 /* Calculate the start and end positions for the current window.
1063 At some point, it would be nice to choose between scrollbars
1064 which reflect the whole buffer size, with special markers
1065 indicating narrowing, and scrollbars which reflect only the
1068 Note that minibuffers sometimes aren't displaying any text. */
1069 if (! MINI_WINDOW_P (w
)
1070 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
1073 start
= startp
- BEGV
;
1074 /* I don't think this is guaranteed to be right. For the
1075 moment, we'll pretend it is. */
1076 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
1078 if (end
< start
) end
= start
;
1079 if (whole
< (end
- start
)) whole
= end
- start
;
1082 start
= end
= whole
= 0;
1084 /* Indicate what this scroll bar ought to be displaying now. */
1085 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
- 1);
1087 /* Note that we actually used the scroll bar attached to this window,
1088 so it shouldn't be deleted at the end of redisplay. */
1089 (*redeem_scroll_bar_hook
) (w
);
1093 current_buffer
= old
;
1097 /* Do full redisplay on one window, starting at position `pos'. */
1100 try_window (window
, pos
)
1104 register struct window
*w
= XWINDOW (window
);
1105 register int height
= window_internal_height (w
);
1106 register int vpos
= XFASTINT (w
->top
);
1107 register int last_text_vpos
= vpos
;
1108 int tab_offset
= pos_tab_offset (w
, pos
);
1109 FRAME_PTR f
= XFRAME (w
->frame
);
1110 int width
= window_internal_width (w
) - 1;
1111 struct position val
;
1113 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1115 overlay_arrow_seen
= 0;
1116 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1118 while (--height
>= 0)
1120 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, tab_offset
);
1121 tab_offset
+= width
;
1122 if (val
.vpos
) tab_offset
= 0;
1124 if (pos
!= val
.bufpos
)
1126 /* Next line, unless prev line ended in end of buffer with no cr */
1127 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
1131 /* If last line is continued in middle of character,
1132 include the split character in the text considered on the frame */
1133 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
1136 /* If bottom just moved off end of frame, change mode line percentage. */
1137 if (XFASTINT (w
->window_end_pos
) == 0
1139 w
->update_mode_line
= Qt
;
1141 /* Say where last char on frame will be, once redisplay is finished. */
1142 XFASTINT (w
->window_end_pos
) = Z
- pos
;
1143 XFASTINT (w
->window_end_vpos
) = last_text_vpos
- XFASTINT (w
->top
);
1144 /* But that is not valid info until redisplay finishes. */
1145 w
->window_end_valid
= Qnil
;
1148 /* Try to redisplay when buffer is modified locally,
1149 computing insert/delete line to preserve text outside
1150 the bounds of the changes.
1151 Return 1 if successful, 0 if if cannot tell what to do,
1152 or -1 to tell caller to find a new window start,
1153 or -2 to tell caller to do normal redisplay with same window start. */
1156 try_window_id (window
)
1160 register struct window
*w
= XWINDOW (window
);
1161 register int height
= window_internal_height (w
);
1162 FRAME_PTR f
= XFRAME (w
->frame
);
1163 int top
= XFASTINT (w
->top
);
1164 int start
= marker_position (w
->start
);
1165 int width
= window_internal_width (w
) - 1;
1166 int hscroll
= XINT (w
->hscroll
);
1167 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1169 register int i
, tem
;
1170 int last_text_vpos
= 0;
1173 struct position val
, bp
, ep
, xp
, pp
;
1174 int scroll_amount
= 0;
1176 int tab_offset
, epto
;
1178 if (GPT
- BEG
< beg_unchanged
)
1179 beg_unchanged
= GPT
- BEG
;
1180 if (Z
- GPT
< end_unchanged
)
1181 end_unchanged
= Z
- GPT
;
1183 if (beg_unchanged
+ 1 < start
)
1184 return 0; /* Give up if changes go above top of window */
1186 /* Find position before which nothing is changed. */
1187 bp
= *compute_motion (start
, 0, lmargin
,
1188 beg_unchanged
+ 1, height
+ 1, 0, width
, hscroll
,
1189 pos_tab_offset (w
, start
));
1190 if (bp
.vpos
>= height
)
1192 if (point
< bp
.bufpos
&& !bp
.contin
)
1194 /* All changes are below the frame, and point is on the frame.
1195 We don't need to change the frame at all.
1196 But we need to update window_end_pos to account for
1197 any change in buffer size. */
1198 bp
= *compute_motion (start
, 0, lmargin
,
1200 width
, hscroll
, pos_tab_offset (w
, start
));
1201 XFASTINT (w
->window_end_vpos
) = height
;
1202 XFASTINT (w
->window_end_pos
) = Z
- bp
.bufpos
;
1210 /* Find beginning of that frame line. Must display from there. */
1211 bp
= *vmotion (bp
.bufpos
, 0, width
, hscroll
, window
);
1218 /* If about to start displaying at the beginning of a continuation line,
1219 really start with previous frame line, in case it was not
1220 continued when last redisplayed */
1221 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
1223 /* Likewise if we have to worry about selective display. */
1224 (XTYPE (current_buffer
->selective_display
) == Lisp_Int
1225 && XINT (current_buffer
->selective_display
) > 0
1226 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
1228 bp
= *vmotion (bp
.bufpos
, -1, width
, hscroll
, window
);
1233 if (bp
.contin
&& bp
.hpos
!= lmargin
)
1235 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
1241 /* Find first visible newline after which no more is changed. */
1242 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
1243 if (XTYPE (current_buffer
->selective_display
) == Lisp_Int
1244 && XINT (current_buffer
->selective_display
) > 0)
1246 && (position_indentation (tem
)
1247 >= XINT (current_buffer
->selective_display
)))
1248 tem
= find_next_newline (tem
, 1);
1250 /* Compute the cursor position after that newline. */
1251 ep
= *compute_motion (pos
, vpos
, val
.hpos
, tem
,
1252 height
, - (1 << (SHORTBITS
- 1)),
1253 width
, hscroll
, pos_tab_offset (w
, bp
.bufpos
));
1255 /* If changes reach past the text available on the frame,
1256 just display rest of frame. */
1257 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
1260 stop_vpos
= ep
.vpos
;
1262 /* If no newline before ep, the line ep is on includes some changes
1263 that must be displayed. Make sure we don't stop before it. */
1264 /* Also, if changes reach all the way until ep.bufpos,
1265 it is possible that something was deleted after the
1266 newline before it, so the following line must be redrawn. */
1267 if (stop_vpos
== ep
.vpos
1268 && (ep
.bufpos
== BEGV
1269 || FETCH_CHAR (ep
.bufpos
- 1) != '\n'
1270 || ep
.bufpos
== Z
- end_unchanged
))
1271 stop_vpos
= ep
.vpos
+ 1;
1274 overlay_arrow_seen
= 0;
1276 /* If changes do not reach to bottom of window,
1277 figure out how much to scroll the rest of the window */
1278 if (stop_vpos
< height
)
1280 /* Now determine how far up or down the rest of the window has moved */
1281 epto
= pos_tab_offset (w
, ep
.bufpos
);
1282 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1283 Z
- XFASTINT (w
->window_end_pos
),
1284 10000, 0, width
, hscroll
, epto
);
1285 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
1287 /* Is everything on frame below the changes whitespace?
1288 If so, no scrolling is really necessary. */
1289 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
1291 tem
= FETCH_CHAR (i
);
1292 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
1298 XFASTINT (w
->window_end_vpos
) += scroll_amount
;
1300 /* Before doing any scrolling, verify that point will be on frame. */
1301 if (point
> ep
.bufpos
&& !(point
<= xp
.bufpos
&& xp
.bufpos
< height
))
1303 if (point
<= xp
.bufpos
)
1305 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1306 point
, height
, - (1 << (SHORTBITS
- 1)),
1307 width
, hscroll
, epto
);
1311 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
,
1312 point
, height
, - (1 << (SHORTBITS
- 1)),
1313 width
, hscroll
, pos_tab_offset (w
, xp
.bufpos
));
1315 if (pp
.bufpos
< point
|| pp
.vpos
== height
)
1317 cursor_vpos
= pp
.vpos
+ top
;
1318 cursor_hpos
= pp
.hpos
+ XFASTINT (w
->left
);
1321 if (stop_vpos
- scroll_amount
>= height
1322 || ep
.bufpos
== xp
.bufpos
)
1324 if (scroll_amount
< 0)
1325 stop_vpos
-= scroll_amount
;
1327 /* In this path, we have altered window_end_vpos
1328 and not left it negative.
1329 We must make sure that, in case display is preempted
1330 before the frame changes to reflect what we do here,
1331 further updates will not come to try_window_id
1332 and assume the frame and window_end_vpos match. */
1333 blank_end_of_window
= 1;
1335 else if (!scroll_amount
)
1337 else if (bp
.bufpos
== Z
- end_unchanged
)
1339 /* If reprinting everything is nearly as fast as scrolling,
1340 don't bother scrolling. Can happen if lines are short. */
1341 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
1342 top
+ height
- max (0, scroll_amount
),
1344 > xp
.bufpos
- bp
.bufpos
- 20)
1345 /* Return "try normal display with same window-start."
1346 Too bad we can't prevent further scroll-thinking. */
1348 /* If pure deletion, scroll up as many lines as possible.
1349 In common case of killing a line, this can save the
1350 following line from being overwritten by scrolling
1351 and therefore having to be redrawn. */
1352 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
1353 top
+ height
- max (0, scroll_amount
),
1355 if (!tem
) stop_vpos
= height
;
1357 else if (scroll_amount
)
1359 /* If reprinting everything is nearly as fast as scrolling,
1360 don't bother scrolling. Can happen if lines are short. */
1361 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
1362 overestimate of cost of reprinting, since xp.bufpos
1363 would end up below the bottom of the window. */
1364 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
1365 top
+ height
- max (0, scroll_amount
),
1367 > xp
.bufpos
- ep
.bufpos
- 20)
1368 /* Return "try normal display with same window-start."
1369 Too bad we can't prevent further scroll-thinking. */
1371 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
1372 top
+ height
- max (0, scroll_amount
),
1374 if (!tem
) stop_vpos
= height
;
1378 /* In any case, do not display past bottom of window */
1379 if (stop_vpos
>= height
)
1385 /* Handle case where pos is before w->start --
1386 can happen if part of line had been clipped and is not clipped now */
1387 if (vpos
== 0 && pos
< marker_position (w
->start
))
1388 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1390 /* Redisplay the lines where the text was changed */
1391 last_text_vpos
= vpos
;
1392 tab_offset
= pos_tab_offset (w
, pos
);
1393 /* If we are starting display in mid-character, correct tab_offset
1394 to account for passing the line that that character really starts in. */
1395 if (val
.hpos
< lmargin
)
1396 tab_offset
+= width
;
1397 while (vpos
< stop_vpos
)
1399 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1400 tab_offset
+= width
;
1401 if (val
.vpos
) tab_offset
= 0;
1402 if (pos
!= val
.bufpos
)
1404 /* Next line, unless prev line ended in end of buffer with no cr */
1405 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
1409 /* There are two cases:
1410 1) we have displayed down to the bottom of the window
1411 2) we have scrolled lines below stop_vpos by scroll_amount */
1415 /* If last line is continued in middle of character,
1416 include the split character in the text considered on the frame */
1417 if (val
.hpos
< lmargin
)
1419 XFASTINT (w
->window_end_vpos
) = last_text_vpos
;
1420 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1423 /* If scrolling made blank lines at window bottom,
1424 redisplay to fill those lines */
1425 if (scroll_amount
< 0)
1427 /* Don't consider these lines for general-purpose scrolling.
1428 That will save time in the scrolling computation. */
1429 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
1434 vpos
= height
+ scroll_amount
;
1435 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
1437 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
1441 blank_end_of_window
= 1;
1442 tab_offset
= pos_tab_offset (w
, pos
);
1443 /* If we are starting display in mid-character, correct tab_offset
1444 to account for passing the line that that character starts in. */
1445 if (val
.hpos
< lmargin
)
1446 tab_offset
+= width
;
1448 while (vpos
< height
)
1450 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1451 tab_offset
+= width
;
1452 if (val
.vpos
) tab_offset
= 0;
1456 /* Here is a case where display_text_line sets cursor_vpos wrong.
1457 Make it be fixed up, below. */
1459 && xp
.bufpos
== point
)
1463 /* If bottom just moved off end of frame, change mode line percentage. */
1464 if (XFASTINT (w
->window_end_pos
) == 0
1466 w
->update_mode_line
= Qt
;
1468 /* Attempt to adjust end-of-text positions to new bottom line */
1471 delta
= height
- xp
.vpos
;
1473 || (delta
> 0 && xp
.bufpos
<= ZV
)
1474 || (delta
== 0 && xp
.hpos
))
1476 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1477 delta
, width
, hscroll
, window
);
1478 XFASTINT (w
->window_end_pos
) = Z
- val
.bufpos
;
1479 XFASTINT (w
->window_end_vpos
) += val
.vpos
;
1483 w
->window_end_valid
= Qnil
;
1485 /* If point was not in a line that was displayed, find it */
1486 if (cursor_vpos
< 0)
1488 val
= *compute_motion (start
, 0, lmargin
, point
, 10000, 10000,
1489 width
, hscroll
, pos_tab_offset (w
, start
));
1490 /* Admit failure if point is off frame now */
1491 if (val
.vpos
>= height
)
1493 for (vpos
= 0; vpos
< height
; vpos
++)
1494 cancel_line (vpos
+ top
, f
);
1497 cursor_vpos
= val
.vpos
+ top
;
1498 cursor_hpos
= val
.hpos
+ XFASTINT (w
->left
);
1501 FRAME_CURSOR_X (f
) = max (0, cursor_hpos
);
1502 FRAME_CURSOR_Y (f
) = cursor_vpos
;
1506 val
= *compute_motion (start
, 0, lmargin
, ZV
,
1507 height
, - (1 << (SHORTBITS
- 1)),
1508 width
, hscroll
, pos_tab_offset (w
, start
));
1509 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
1511 if (XFASTINT (w
->window_end_pos
)
1519 /* Mark a section of BUF as modified, but only for the sake of redisplay.
1520 This is useful for recording changes to overlays.
1522 We increment the buffer's modification timestamp and set the
1523 redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
1524 as if the region of text between START and END had been modified;
1525 the redisplay code will check this against the windows' timestamps,
1526 and redraw the appropriate area of the buffer.
1528 However, if the buffer is unmodified, we bump the last-save
1529 timestamp as well, so that incrementing the timestamp doesn't fool
1530 Emacs into thinking that the buffer's text has been modified.
1532 Tweaking the timestamps shouldn't hurt the first-modification
1533 timestamps recorded in the undo records; those values aren't
1534 written until just before a real text modification is made, so they
1535 will never catch the timestamp value just before this function gets
1539 redisplay_region (buf
, start
, end
)
1549 start
= end
; end
= temp
;
1552 if (buf
!= current_buffer
)
1553 windows_or_buffers_changed
= 1;
1556 if (unchanged_modified
== MODIFF
)
1558 beg_unchanged
= start
- BEG
;
1559 end_unchanged
= Z
- end
;
1563 if (Z
- end
< end_unchanged
)
1564 end_unchanged
= Z
- end
;
1565 if (start
- BEG
< beg_unchanged
)
1566 beg_unchanged
= start
- BEG
;
1570 /* Increment the buffer's time stamp, but also increment the save
1571 and autosave timestamps, so as not to screw up that timekeeping. */
1572 if (BUF_MODIFF (buf
) == buf
->save_modified
)
1573 buf
->save_modified
++;
1574 if (BUF_MODIFF (buf
) == buf
->auto_save_modified
)
1575 buf
->auto_save_modified
++;
1577 BUF_MODIFF (buf
) ++;
1581 /* Copy glyphs from the vector FROM to the rope T.
1582 But don't actually copy the parts that would come in before S.
1583 Value is T, advanced past the copied data. */
1586 copy_rope (t
, s
, from
, face
)
1587 register GLYPH
*t
; /* Copy to here. */
1588 register GLYPH
*s
; /* Starting point. */
1589 Lisp_Object from
; /* Data to copy; known to be a vector. */
1590 int face
; /* Face to apply to glyphs which don't specify one. */
1592 register int n
= XVECTOR (from
)->size
;
1593 register Lisp_Object
*f
= XVECTOR (from
)->contents
;
1597 if (t
>= s
) *t
= MAKE_GLYPH (GLYPH_CHAR (*f
),
1607 /* Copy exactly LEN glyphs from FROM into data at T.
1608 But don't alter words before S. */
1611 copy_part_of_rope (t
, s
, from
, len
, face
)
1612 register GLYPH
*t
; /* Copy to here. */
1613 register GLYPH
*s
; /* Starting point. */
1614 Lisp_Object
*from
; /* Data to copy. */
1616 int face
; /* Face to apply to glyphs which don't specify one. */
1619 register Lisp_Object
*f
= from
;
1623 if (t
>= s
) *t
= MAKE_GLYPH (GLYPH_CHAR (*f
),
1633 /* Display one line of window w, starting at position START in W's buffer.
1634 Display starting at horizontal position HPOS, which is normally zero
1635 or negative. A negative value causes output up to hpos = 0 to be discarded.
1636 This is done for negative hscroll, or when this is a continuation line
1637 and the continuation occurred in the middle of a multi-column character.
1639 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
1641 Display on position VPOS on the frame. (origin 0).
1643 Returns a STRUCT POSITION giving character to start next line with
1644 and where to display it, including a zero or negative hpos.
1645 The vpos field is not really a vpos; it is 1 unless the line is continued */
1647 struct position val_display_text_line
;
1649 static struct position
*
1650 display_text_line (w
, start
, vpos
, hpos
, taboffset
)
1657 register int pos
= start
;
1662 register unsigned char *p
;
1664 register GLYPH
*startp
;
1665 register GLYPH
*p1prev
;
1666 FRAME_PTR f
= XFRAME (w
->frame
);
1667 int tab_width
= XINT (current_buffer
->tab_width
);
1668 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
1669 int width
= window_internal_width (w
) - 1;
1670 struct position val
;
1673 int hscroll
= XINT (w
->hscroll
);
1674 int truncate
= hscroll
1675 || (truncate_partial_width_windows
1676 && XFASTINT (w
->width
) < FRAME_WIDTH (f
))
1677 || !NILP (current_buffer
->truncate_lines
);
1679 /* 1 if we should highlight the region. */
1680 int highlight_region
1681 = !NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
);
1682 int region_beg
, region_end
;
1685 = XTYPE (current_buffer
->selective_display
) == Lisp_Int
1686 ? XINT (current_buffer
->selective_display
)
1687 : !NILP (current_buffer
->selective_display
) ? -1 : 0;
1688 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
1689 register struct Lisp_Vector
*dp
= window_display_table (w
);
1691 Lisp_Object default_invis_vector
[3];
1692 /* Nonzero means display something where there are invisible lines.
1693 The precise value is the number of glyphs to display. */
1695 = (selective
&& dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1696 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
1697 : selective
&& !NILP (current_buffer
->selective_display_ellipses
)
1699 /* This is the sequence of Lisp objects to display
1700 when there are invisible lines. */
1701 Lisp_Object
*invis_vector_contents
1702 = (dp
&& XTYPE (DISP_INVIS_VECTOR (dp
)) == Lisp_Vector
1703 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
1704 : default_invis_vector
);
1706 GLYPH truncator
= (dp
== 0 || XTYPE (DISP_TRUNC_GLYPH (dp
)) != Lisp_Int
1707 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
1708 GLYPH continuer
= (dp
== 0 || XTYPE (DISP_CONTINUE_GLYPH (dp
)) != Lisp_Int
1709 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
1711 /* The next buffer location at which the face should change, due
1712 to overlays or text property changes. */
1713 int next_face_change
;
1715 /* The face we're currently using. */
1716 int current_face
= 0;
1718 XFASTINT (default_invis_vector
[2]) = '.';
1719 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
1721 hpos
+= XFASTINT (w
->left
);
1722 get_display_line (f
, vpos
, XFASTINT (w
->left
));
1723 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
1725 /* Show where to highlight the region. */
1726 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
1727 /* Highlight only in selected window. */
1728 && w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
1730 region_beg
= marker_position (current_buffer
->mark
);
1731 if (PT
< region_beg
)
1733 region_end
= region_beg
;
1738 w
->region_showing
= Qt
;
1741 region_beg
= region_end
= -1;
1743 if (MINI_WINDOW_P (w
) && start
== 1
1744 && vpos
== XFASTINT (w
->top
))
1747 hpos
= display_string (w
, vpos
, minibuf_prompt
, hpos
,
1748 (!truncate
? continuer
: truncator
),
1750 minibuf_prompt_width
= hpos
;
1753 desired_glyphs
->bufp
[vpos
] = pos
;
1754 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
1756 startp
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
1757 endp
= startp
+ width
;
1759 /* Arrange the overlays nicely for our purposes. Usually, we call
1760 display_text_line on only one line at a time, in which case this
1761 can't really hurt too much, or we call it on lines which appear
1762 one after another in the buffer, in which case all calls to
1763 recenter_overlay_lists but the first will be pretty cheap. */
1764 recenter_overlay_lists (current_buffer
, pos
);
1766 /* Loop generating characters.
1767 Stop at end of buffer, before newline,
1768 if reach or pass continuation column,
1769 or at face change. */
1771 next_face_change
= pos
;
1777 /* Did we hit the end of the visible region of the buffer?
1782 /* Did we reach point? Record the cursor location. */
1783 if (pos
== point
&& cursor_vpos
< 0)
1786 cursor_hpos
= p1
- startp
;
1789 #ifdef HAVE_X_WINDOWS
1790 /* Did we hit a face change? Figure out what face we should
1791 use now. We also hit this the first time through the
1792 loop, to see what face we should start with. */
1793 if (pos
== next_face_change
)
1794 current_face
= compute_char_face (f
, w
, pos
,
1795 region_beg
, region_end
,
1801 if (pos
< next_face_change
&& next_face_change
< pause
)
1802 pause
= next_face_change
;
1804 /* Wouldn't you hate to read the next line to someone over
1806 if (pos
< point
&& point
< pause
)
1808 if (pos
< GPT
&& GPT
< pause
)
1811 p
= &FETCH_CHAR (pos
);
1814 if (c
>= 040 && c
< 0177
1815 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
1818 *p1
= MAKE_GLYPH (c
, current_face
);
1826 && position_indentation (pos
+ 1) >= selective
)
1829 pos
= find_next_newline (pos
+ 1, 1);
1830 if (FETCH_CHAR (pos
- 1) == '\n')
1833 if (invis
&& selective_rlen
> 0 && p1
>= startp
)
1835 p1
+= selective_rlen
;
1836 if (p1
- startp
> width
)
1838 copy_part_of_rope (p1prev
, p1prev
, invis_vector_contents
,
1839 (p1
- p1prev
), current_face
);
1842 /* Draw the face of the newline character as extending all the
1843 way to the end of the frame line. */
1846 *p1
++ = MAKE_GLYPH (' ', current_face
);
1854 if (p1
>= startp
&& p1
< endp
)
1855 *p1
= MAKE_GLYPH (' ', current_face
);
1858 while ((p1
- startp
+ taboffset
+ hscroll
- (hscroll
> 0))
1861 else if (c
== Ctl ('M') && selective
== -1)
1863 pos
= find_next_newline (pos
, 1);
1864 if (FETCH_CHAR (pos
- 1) == '\n')
1866 if (selective_rlen
> 0)
1868 p1
+= selective_rlen
;
1869 if (p1
- startp
> width
)
1871 copy_part_of_rope (p1prev
, p1prev
, invis_vector_contents
,
1872 (p1
- p1prev
), current_face
);
1875 /* Draw the face of the newline character as extending all the
1876 way to the end of the frame line. */
1879 *p1
++ = MAKE_GLYPH (' ', current_face
);
1883 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
1885 p1
= copy_rope (p1
, startp
, DISP_CHAR_VECTOR (dp
, c
), current_face
);
1887 else if (c
< 0200 && ctl_arrow
)
1890 *p1
= MAKE_GLYPH ((dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
1891 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
1894 if (p1
>= startp
&& p1
< endp
)
1895 *p1
= MAKE_GLYPH (c
^ 0100, current_face
);
1901 *p1
= MAKE_GLYPH ((dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
1902 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
1905 if (p1
>= startp
&& p1
< endp
)
1906 *p1
= MAKE_GLYPH ((c
>> 6) + '0', current_face
);
1908 if (p1
>= startp
&& p1
< endp
)
1909 *p1
= MAKE_GLYPH ((7 & (c
>> 3)) + '0', current_face
);
1911 if (p1
>= startp
&& p1
< endp
)
1912 *p1
= MAKE_GLYPH ((7 & c
) + '0', current_face
);
1919 val
.hpos
= - XINT (w
->hscroll
);
1927 /* Handle continuation in middle of a character */
1928 /* by backing up over it */
1931 /* Start the next line with that same character */
1933 /* but at a negative hpos, to skip the columns output on this line. */
1934 val
.hpos
+= p1prev
- endp
;
1935 /* Keep in this line everything up to the continuation column. */
1939 /* Finish deciding which character to start the next line on,
1940 and what hpos to start it at.
1941 Also set `lastpos' to the last position which counts as "on this line"
1942 for cursor-positioning. */
1946 if (FETCH_CHAR (pos
) == '\n')
1947 /* If stopped due to a newline, start next line after it */
1950 /* Stopped due to right margin of window */
1955 /* Truncating => start next line after next newline,
1956 and point is on this line if it is before the newline,
1957 and skip none of first char of next line */
1958 pos
= find_next_newline (pos
, 1);
1959 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1961 lastpos
= pos
- (FETCH_CHAR (pos
- 1) == '\n');
1972 /* If point is at eol or in invisible text at eol,
1973 record its frame location now. */
1975 if (start
<= point
&& point
<= lastpos
&& cursor_vpos
< 0)
1978 cursor_hpos
= p1
- startp
;
1981 if (cursor_vpos
== vpos
)
1983 if (cursor_hpos
< 0) cursor_hpos
= 0;
1984 if (cursor_hpos
> width
) cursor_hpos
= width
;
1985 cursor_hpos
+= XFASTINT (w
->left
);
1986 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
1988 FRAME_CURSOR_Y (f
) = cursor_vpos
;
1989 FRAME_CURSOR_X (f
) = cursor_hpos
;
1991 if (w
== XWINDOW (selected_window
))
1993 /* Line is not continued and did not start
1994 in middle of character */
1995 if ((hpos
- XFASTINT (w
->left
)
1996 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
1999 this_line_bufpos
= start
;
2000 this_line_buffer
= current_buffer
;
2001 this_line_vpos
= cursor_vpos
;
2002 this_line_start_hpos
= hpos
;
2003 this_line_endpos
= Z
- lastpos
;
2006 this_line_bufpos
= 0;
2011 /* If hscroll and line not empty, insert truncation-at-left marker */
2012 if (hscroll
&& lastpos
!= start
)
2014 *startp
= truncator
;
2019 if (XFASTINT (w
->width
) + XFASTINT (w
->left
) != FRAME_WIDTH (f
))
2022 if (p1
< startp
) p1
= startp
;
2023 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
2025 /* Don't draw vertical bars if we're using scroll bars. They're
2026 covered up by the scroll bars, and it's distracting to see
2027 them when the scroll bar windows are flickering around to be
2029 *p1
++ = (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
2032 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
2033 p1
- desired_glyphs
->glyphs
[vpos
]);
2034 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2036 /* If the start of this line is the overlay arrow-position,
2037 then put the arrow string into the display-line. */
2039 if (XTYPE (Voverlay_arrow_position
) == Lisp_Marker
2040 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
2041 && start
== marker_position (Voverlay_arrow_position
)
2042 && XTYPE (Voverlay_arrow_string
) == Lisp_String
2043 && ! overlay_arrow_seen
)
2045 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
2047 int len
= XSTRING (Voverlay_arrow_string
)->size
;
2051 for (i
= 0; i
< len
; i
++)
2053 if (desired_glyphs
->used
[vpos
] <
2054 (len
+ startp
- desired_glyphs
->glyphs
[vpos
]))
2055 desired_glyphs
->used
[vpos
] = len
+ startp
- desired_glyphs
->glyphs
[vpos
];
2057 overlay_arrow_seen
= 1;
2061 val_display_text_line
= val
;
2062 return &val_display_text_line
;
2065 /* Redisplay the menu bar in the frame for window W. */
2068 display_menu_bar (w
)
2071 Lisp_Object items
, tail
;
2072 register int vpos
= 0;
2073 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2074 int maxendcol
= FRAME_WIDTH (f
);
2077 if (FRAME_MENU_BAR_LINES (f
) <= 0)
2080 get_display_line (f
, vpos
, 0);
2082 /* If the user has switched buffers or windows, we need to
2083 recompute to reflect the new bindings. But we'll
2084 recompute when update_mode_lines is set too; that means
2085 that people can use force-mode-line-update to request
2086 that the menu bar be recomputed. The adverse effect on
2087 the rest of the redisplay algorithm is about the same as
2088 windows_or_buffers_changed anyway. */
2089 if (windows_or_buffers_changed
2090 || update_mode_lines
2091 || (XFASTINT (w
->last_modified
) < MODIFF
2092 && (XFASTINT (w
->last_modified
)
2093 <= XBUFFER (w
->buffer
)->save_modified
)))
2095 struct buffer
*prev
= current_buffer
;
2096 current_buffer
= XBUFFER (w
->buffer
);
2097 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items ();
2098 current_buffer
= prev
;
2101 for (tail
= FRAME_MENU_BAR_ITEMS (f
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2105 string
= XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->car
;
2107 /* Record in each item its hpos. */
2108 XFASTINT (XCONS (XCONS (XCONS (tail
)->car
)->cdr
)->cdr
) = hpos
;
2110 if (hpos
< maxendcol
)
2111 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
2112 XSTRING (string
)->data
,
2113 hpos
, 0, hpos
, maxendcol
);
2114 /* Put a gap of 3 spaces between items. */
2115 if (hpos
< maxendcol
)
2117 int hpos1
= hpos
+ 3;
2118 hpos
= display_string (w
, vpos
, "", hpos
, 0,
2119 min (hpos1
, maxendcol
), maxendcol
);
2123 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2124 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2126 /* Fill out the line with spaces. */
2127 if (maxendcol
> hpos
)
2128 hpos
= display_string (w
, vpos
, "", hpos
, 0, maxendcol
, -1);
2131 /* Display the mode line for window w */
2134 display_mode_line (w
)
2137 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
2138 register int left
= XFASTINT (w
->left
);
2139 register int right
= XFASTINT (w
->width
) + left
;
2140 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2142 line_number_displayed
= 0;
2144 get_display_line (f
, vpos
, left
);
2145 display_mode_element (w
, vpos
, left
, 0, right
, right
,
2146 current_buffer
->mode_line_format
);
2147 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2149 /* Make the mode line inverse video if the entire line
2150 is made of mode lines.
2151 I.e. if this window is full width,
2152 or if it is the child of a full width window
2153 (which implies that that window is split side-by-side
2154 and the rest of this line is mode lines of the sibling windows). */
2155 if (XFASTINT (w
->width
) == FRAME_WIDTH (f
)
2156 || XFASTINT (XWINDOW (w
->parent
)->width
) == FRAME_WIDTH (f
))
2157 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2159 #ifdef HAVE_X_WINDOWS
2160 /* I'm trying this out because I saw Unimpress use it, but it's
2161 possible that this may mess adversely with some window managers. -jla
2163 Wouldn't it be nice to use something like mode-line-format to
2164 describe frame titles? -JimB */
2166 /* Change the title of the frame to the name of the buffer displayed
2167 in the currently selected window. Don't do this for minibuffer frames,
2168 and don't do it when there's only one non-minibuffer frame. */
2170 && ! FRAME_MINIBUF_ONLY_P (f
)
2171 && w
== XWINDOW (f
->selected_window
))
2172 x_implicitly_set_name (f
, (EQ (Fnext_frame (WINDOW_FRAME (w
), Qnil
),
2175 : XBUFFER (w
->buffer
)->name
),
2180 /* Contribute ELT to the mode line for window W.
2181 How it translates into text depends on its data type.
2183 VPOS is the position of the mode line being displayed.
2185 HPOS is the position (absolute on frame) where this element's text
2186 should start. The output is truncated automatically at the right
2189 DEPTH is the depth in recursion. It is used to prevent
2190 infinite recursion here.
2192 MINENDCOL is the hpos before which the element may not end.
2193 The element is padded at the right with spaces if nec
2194 to reach this column.
2196 MAXENDCOL is the hpos past which this element may not extend.
2197 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
2198 (This is necessary to make nested padding and truncation work.)
2200 Returns the hpos of the end of the text generated by ELT.
2201 The next element will receive that value as its HPOS arg,
2202 so as to concatenate the elements. */
2205 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
2207 register int vpos
, hpos
;
2210 register int maxendcol
;
2211 register Lisp_Object elt
;
2219 #ifdef SWITCH_ENUM_BUG
2220 switch ((int) XTYPE (elt
))
2222 switch (XTYPE (elt
))
2227 /* A string: output it and check for %-constructs within it. */
2228 register unsigned char c
;
2229 register unsigned char *this = XSTRING (elt
)->data
;
2231 while (hpos
< maxendcol
&& *this)
2233 unsigned char *last
= this;
2234 while ((c
= *this++) != '\0' && c
!= '%')
2236 if (this - 1 != last
)
2238 register int lim
= --this - last
+ hpos
;
2239 hpos
= display_string (w
, vpos
, last
, hpos
, 0, hpos
,
2240 min (lim
, maxendcol
));
2244 register int spec_width
= 0;
2246 /* We can't allow -ve args due to the "%-" construct */
2247 /* Argument specifies minwidth but not maxwidth
2248 (maxwidth can be specified by
2249 (<negative-number> . <stuff>) mode-line elements) */
2251 while ((c
= *this++) >= '0' && c
<= '9')
2253 spec_width
= spec_width
* 10 + (c
- '0');
2257 if (spec_width
> maxendcol
)
2258 spec_width
= maxendcol
;
2261 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2262 spec_width
, maxendcol
,
2263 Vglobal_mode_string
);
2265 hpos
= display_string (w
, vpos
,
2266 decode_mode_spec (w
, c
,
2268 hpos
, 0, spec_width
, maxendcol
);
2275 /* A symbol: process the value of the symbol recursively
2276 as if it appeared here directly. Avoid error if symbol void.
2277 Special case: if value of symbol is a string, output the string
2280 register Lisp_Object tem
;
2281 tem
= Fboundp (elt
);
2284 tem
= Fsymbol_value (elt
);
2285 /* If value is a string, output that string literally:
2286 don't check for % within it. */
2287 if (XTYPE (tem
) == Lisp_String
)
2288 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
2289 hpos
, 0, minendcol
, maxendcol
);
2290 /* Give up right away for nil or t. */
2291 else if (!EQ (tem
, elt
))
2292 { elt
= tem
; goto tail_recurse
; }
2299 register Lisp_Object car
, tem
;
2301 /* A cons cell: three distinct cases.
2302 If first element is a string or a cons, process all the elements
2303 and effectively concatenate them.
2304 If first element is a negative number, truncate displaying cdr to
2305 at most that many characters. If positive, pad (with spaces)
2306 to at least that many characters.
2307 If first element is a symbol, process the cadr or caddr recursively
2308 according to whether the symbol's value is non-nil or nil. */
2309 car
= XCONS (elt
)->car
;
2310 if (XTYPE (car
) == Lisp_Symbol
)
2312 tem
= Fboundp (car
);
2313 elt
= XCONS (elt
)->cdr
;
2314 if (XTYPE (elt
) != Lisp_Cons
)
2316 /* elt is now the cdr, and we know it is a cons cell.
2317 Use its car if CAR has a non-nil value. */
2320 tem
= Fsymbol_value (car
);
2322 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
2324 /* Symbol's value is nil (or symbol is unbound)
2325 Get the cddr of the original list
2326 and if possible find the caddr and use that. */
2327 elt
= XCONS (elt
)->cdr
;
2330 else if (XTYPE (elt
) != Lisp_Cons
)
2332 elt
= XCONS (elt
)->car
;
2335 else if (XTYPE (car
) == Lisp_Int
)
2337 register int lim
= XINT (car
);
2338 elt
= XCONS (elt
)->cdr
;
2340 /* Negative int means reduce maximum width.
2341 DO NOT change MINENDCOL here!
2342 (20 -10 . foo) should truncate foo to 10 col
2343 and then pad to 20. */
2344 maxendcol
= min (maxendcol
, hpos
- lim
);
2347 /* Padding specified. Don't let it be more than
2350 if (lim
> maxendcol
)
2352 /* If that's more padding than already wanted, queue it.
2353 But don't reduce padding already specified even if
2354 that is beyond the current truncation point. */
2355 if (lim
> minendcol
)
2360 else if (XTYPE (car
) == Lisp_String
|| XTYPE (car
) == Lisp_Cons
)
2362 register int limit
= 50;
2363 /* LIMIT is to protect against circular lists. */
2364 while (XTYPE (elt
) == Lisp_Cons
&& --limit
> 0
2365 && hpos
< maxendcol
)
2367 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2370 elt
= XCONS (elt
)->cdr
;
2378 return (display_string (w
, vpos
, "*invalid*", hpos
, 0,
2379 minendcol
, maxendcol
));
2383 if (minendcol
> hpos
)
2384 hpos
= display_string (w
, vpos
, "", hpos
, 0, minendcol
, -1);
2388 /* Return a string for the output of a mode line %-spec for window W,
2389 generated by character C and width MAXWIDTH. */
2391 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
2394 decode_mode_spec (w
, c
, maxwidth
)
2397 register int maxwidth
;
2399 Lisp_Object obj
= Qnil
;
2400 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2401 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
2403 if (maxwidth
> FRAME_WIDTH (f
))
2404 maxwidth
= FRAME_WIDTH (f
);
2409 obj
= current_buffer
->name
;
2411 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
2413 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
2414 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
2415 decode_mode_spec_buf
[maxwidth
] = '\0';
2416 return decode_mode_spec_buf
;
2422 obj
= current_buffer
->filename
;
2426 else if (XTYPE (obj
) == Lisp_String
&& XSTRING (obj
)->size
> maxwidth
)
2428 bcopy ("...", decode_mode_spec_buf
, 3);
2429 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
2430 decode_mode_spec_buf
+ 3, maxwidth
- 3);
2431 return decode_mode_spec_buf
;
2438 int startpos
= marker_position (w
->start
);
2439 int line
, linepos
, topline
;
2442 int height
= XFASTINT (w
->height
);
2444 /* If we decided that this buffer isn't suitable for line numbers,
2445 don't forget that too fast. */
2446 if (EQ (w
->base_line_pos
, w
->buffer
))
2449 /* If the buffer is very big, don't waste time. */
2450 if (ZV
- BEGV
> line_number_display_limit
)
2452 w
->base_line_pos
= Qnil
;
2453 w
->base_line_number
= Qnil
;
2457 if (!NILP (w
->base_line_number
)
2458 && !NILP (w
->base_line_pos
)
2459 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
2461 line
= XFASTINT (w
->base_line_number
);
2462 linepos
= XFASTINT (w
->base_line_pos
);
2470 /* Count lines from base line to window start position. */
2471 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
2473 topline
= nlines
+ line
;
2475 /* Determine a new base line, if the old one is too close
2476 or too far away, or if we did not have one.
2477 "Too close" means it's plausible a scroll-down would
2479 if (startpos
== BEGV
)
2481 XFASTINT (w
->base_line_number
) = topline
;
2482 XFASTINT (w
->base_line_pos
) = BEGV
;
2484 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
2489 int distance
= (height
* 2 + 30) * 200;
2491 if (startpos
- distance
> limit
)
2492 limit
= startpos
- distance
;
2494 nlines
= display_count_lines (startpos
, limit
,
2497 /* If we couldn't find the lines we wanted within
2499 give up on line numbers for this window. */
2500 if (position
== startpos
- distance
)
2502 w
->base_line_pos
= w
->buffer
;
2503 w
->base_line_number
= Qnil
;
2507 XFASTINT (w
->base_line_number
) = topline
- nlines
;
2508 XFASTINT (w
->base_line_pos
) = position
;
2511 /* Now count lines from the start pos to point. */
2512 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
2514 /* Record that we did display the line number. */
2515 line_number_displayed
= 1;
2517 /* Make the string to show. */
2518 sprintf (decode_mode_spec_buf
, "%d", topline
+ nlines
);
2519 return decode_mode_spec_buf
;
2524 obj
= current_buffer
->mode_name
;
2528 if (BEGV
> BEG
|| ZV
< Z
)
2533 if (!NILP (current_buffer
->read_only
))
2535 if (MODIFF
> current_buffer
->save_modified
)
2540 /* status of process */
2541 obj
= Fget_buffer_process (Fcurrent_buffer ());
2543 return "no process";
2544 obj
= Fsymbol_name (Fprocess_status (obj
));
2549 int pos
= marker_position (w
->start
);
2550 int total
= ZV
- BEGV
;
2552 if (XFASTINT (w
->window_end_pos
) <= Z
- ZV
)
2559 else if (pos
<= BEGV
)
2563 total
= ((pos
- BEGV
) * 100 + total
- 1) / total
;
2564 /* We can't normally display a 3-digit number,
2565 so get us a 2-digit number that is close. */
2568 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
2569 return decode_mode_spec_buf
;
2581 if (command_loop_level
> 5)
2583 p
= decode_mode_spec_buf
;
2584 for (i
= 0; i
< command_loop_level
; i
++)
2587 return decode_mode_spec_buf
;
2595 if (command_loop_level
> 5)
2597 p
= decode_mode_spec_buf
;
2598 for (i
= 0; i
< command_loop_level
; i
++)
2601 return decode_mode_spec_buf
;
2609 if (maxwidth
< sizeof (lots_of_dashes
))
2610 return lots_of_dashes
;
2613 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
2617 return decode_mode_spec_buf
;
2621 if (XTYPE (obj
) == Lisp_String
)
2622 return (char *) XSTRING (obj
)->data
;
2627 /* Count up to N lines starting from FROM.
2628 But don't go beyond LIMIT.
2629 Return the number of lines thus found (always positive).
2630 Store the position after what was found into *POS_PTR. */
2633 display_count_lines (from
, limit
, n
, pos_ptr
)
2646 *pos_ptr
= scan_buffer ('\n', from
, n
, &shortage
);
2652 /* When scanning backwards, scan_buffer stops *after* the last newline
2653 it finds, but does count it. Compensate for that. */
2654 return - n
- shortage
- (*pos_ptr
!= limit
);
2655 return n
- shortage
;
2658 /* Display STRING on one line of window W, starting at HPOS.
2659 Display at position VPOS. Caller should have done get_display_line.
2660 If VPOS == -1, display it as the current frame's title.
2662 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
2664 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
2665 MAXCOL is the last column ok to end at. Truncate here.
2666 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
2667 Both count from the left edge of the frame, as does HPOS.
2668 The right edge of W is an implicit maximum.
2669 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
2671 Returns ending hpos */
2674 display_string (w
, vpos
, string
, hpos
, truncate
, mincol
, maxcol
)
2676 unsigned char *string
;
2683 int hscroll
= XINT (w
->hscroll
);
2684 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
2685 register GLYPH
*start
;
2686 register GLYPH
*end
;
2687 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2688 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
2689 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2690 int window_width
= XFASTINT (w
->width
);
2692 /* Use the standard display table, not the window's display table.
2693 We don't want the mode line in rot13. */
2694 register struct Lisp_Vector
*dp
= 0;
2696 if (XTYPE (Vstandard_display_table
) == Lisp_Vector
2697 && XVECTOR (Vstandard_display_table
)->size
== DISP_TABLE_SIZE
)
2698 dp
= XVECTOR (Vstandard_display_table
);
2700 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
2703 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
2704 end
= start
+ window_width
- (truncate
!= 0);
2706 if ((window_width
+ XFASTINT (w
->left
)) != FRAME_WIDTH (f
))
2708 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
2712 for (i
= 0; i
< VERTICAL_SCROLL_BAR_WIDTH
; i
++)
2719 if (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
)
2720 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
2721 if (maxcol
>= 0 && mincol
> maxcol
)
2728 if (c
>= 040 && c
< 0177
2729 && (dp
== 0 || XTYPE (DISP_CHAR_VECTOR (dp
, c
)) != Lisp_Vector
))
2739 if (p1
>= start
&& p1
< end
)
2743 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
2745 else if (dp
!= 0 && XTYPE (DISP_CHAR_VECTOR (dp
, c
)) == Lisp_Vector
)
2746 p1
= copy_rope (p1
, start
, DISP_CHAR_VECTOR (dp
, c
), 0);
2747 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
2750 *p1
= (dp
&& XTYPE (DISP_CTRL_GLYPH (dp
)) == Lisp_Int
2751 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^');
2753 if (p1
>= start
&& p1
< end
)
2760 *p1
= (dp
&& XTYPE (DISP_ESCAPE_GLYPH (dp
)) == Lisp_Int
2761 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\');
2763 if (p1
>= start
&& p1
< end
)
2764 *p1
= (c
>> 6) + '0';
2766 if (p1
>= start
&& p1
< end
)
2767 *p1
= (7 & (c
>> 3)) + '0';
2769 if (p1
>= start
&& p1
< end
)
2770 *p1
= (7 & c
) + '0';
2778 if (truncate
) *p1
++ = truncate
;
2780 else if (mincol
>= 0)
2782 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
2788 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
2790 if (len
> desired_glyphs
->used
[vpos
])
2791 desired_glyphs
->used
[vpos
] = len
;
2792 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2801 staticpro (&last_arrow_position
);
2802 staticpro (&last_arrow_string
);
2803 last_arrow_position
= Qnil
;
2804 last_arrow_string
= Qnil
;
2806 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
2807 "String (or mode line construct) included (normally) in `mode-line-format'.");
2808 Vglobal_mode_string
= Qnil
;
2810 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
2811 "Marker for where to display an arrow on top of the buffer text.\n\
2812 This must be the beginning of a line in order to work.\n\
2813 See also `overlay-arrow-string'.");
2814 Voverlay_arrow_position
= Qnil
;
2816 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
2817 "String to display as an arrow. See also `overlay-arrow-position'.");
2818 Voverlay_arrow_string
= Qnil
;
2820 DEFVAR_INT ("scroll-step", &scroll_step
,
2821 "*The number of lines to try scrolling a window by when point moves out.\n\
2822 If that fails to bring point back on frame, point is centered instead.\n\
2823 If this is zero, point is always centered after it moves off frame.");
2825 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
2827 DEFVAR_BOOL ("truncate-partial-width-windows",
2828 &truncate_partial_width_windows
,
2829 "*Non-nil means truncate lines in all windows less than full frame wide.");
2830 truncate_partial_width_windows
= 1;
2832 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
2833 "*Non-nil means use inverse video for the mode line.");
2834 mode_line_inverse_video
= 1;
2836 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
2837 "*Maximum buffer size for which line number should be displayed.");
2838 line_number_display_limit
= 1000000;
2841 /* initialize the window system */
2844 Lisp_Object root_window
;
2845 #ifndef COMPILER_REGISTER_BUG
2847 #endif /* COMPILER_REGISTER_BUG */
2848 struct window
*mini_w
;
2850 this_line_bufpos
= 0;
2852 mini_w
= XWINDOW (minibuf_window
);
2853 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
2855 echo_area_glyphs
= 0;
2856 previous_echo_glyphs
= 0;
2858 if (!noninteractive
)
2860 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
2861 XFASTINT (XWINDOW (root_window
)->top
) = 0;
2862 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
2863 XFASTINT (mini_w
->top
) = FRAME_HEIGHT (f
) - 1;
2864 set_window_height (minibuf_window
, 1, 0);
2866 XFASTINT (XWINDOW (root_window
)->width
) = FRAME_WIDTH (f
);
2867 XFASTINT (mini_w
->width
) = FRAME_WIDTH (f
);