1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 86, 87, 88, 93, 94 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /*#include <ctype.h>*/
29 #include "dispextern.h"
35 #include "termhooks.h"
36 #include "intervals.h"
39 extern void set_frame_menubar ();
42 extern int interrupt_input
;
43 extern int command_loop_level
;
45 extern Lisp_Object Qface
;
47 /* Nonzero means print newline before next minibuffer message. */
49 int noninteractive_need_newline
;
51 #define min(a, b) ((a) < (b) ? (a) : (b))
52 #define max(a, b) ((a) > (b) ? (a) : (b))
54 /* The buffer position of the first character appearing
55 entirely or partially on the current frame line.
56 Or zero, which disables the optimization for the current frame line. */
57 static int this_line_bufpos
;
59 /* Number of characters past the end of this line,
60 including the terminating newline */
61 static int this_line_endpos
;
63 /* The vertical position of this frame line. */
64 static int this_line_vpos
;
66 /* Hpos value for start of display on this frame line.
67 Usually zero, but negative if first character really began
69 static int this_line_start_hpos
;
71 /* Buffer that this_line variables are describing. */
72 static struct buffer
*this_line_buffer
;
74 /* Set by try_window_id to the vpos of first of any lines
75 scrolled on to the bottom of the frame. These lines should
76 not be included in any general scroll computation. */
77 static int scroll_bottom_vpos
;
79 /* Value of echo_area_glyphs when it was last acted on.
80 If this is nonzero, there is a message on the frame
81 in the minibuffer and it should be erased as soon
82 as it is no longer requested to appear. */
83 char *previous_echo_glyphs
;
85 /* Nonzero means truncate lines in all windows less wide than the frame */
86 int truncate_partial_width_windows
;
88 /* Nonzero means we have more than one non-minibuffer-only frame.
89 Not guaranteed to be accurate except while parsing frame-title-format. */
92 Lisp_Object Vglobal_mode_string
;
94 /* Marker for where to display an arrow on top of the buffer text. */
95 Lisp_Object Voverlay_arrow_position
;
97 /* String to display for the arrow. */
98 Lisp_Object Voverlay_arrow_string
;
100 /* Like mode-line-format, but for the titlebar on a visible frame. */
101 Lisp_Object Vframe_title_format
;
103 /* Like mode-line-format, but for the titlebar on an iconified frame. */
104 Lisp_Object Vicon_title_format
;
106 /* Values of those variables at last redisplay. */
107 static Lisp_Object last_arrow_position
, last_arrow_string
;
109 Lisp_Object Qmenu_bar_update_hook
;
111 /* Nonzero if overlay arrow has been displayed once in this window. */
112 static int overlay_arrow_seen
;
114 /* Nonzero means highlight the region even in nonselected windows. */
115 static int highlight_nonselected_windows
;
117 /* If cursor motion alone moves point off frame,
118 Try scrolling this many lines up or down if that will bring it back. */
121 /* Nonzero if try_window_id has made blank lines at window bottom
122 since the last redisplay that paused */
123 static int blank_end_of_window
;
125 /* Number of windows showing the buffer of the selected window.
126 keyboard.c refers to this. */
129 /* display_text_line sets these to the frame position (origin 0) of point,
130 whether the window is selected or not.
131 Set one to -1 first to determine whether point was found afterwards. */
133 static int cursor_vpos
;
134 static int cursor_hpos
;
138 /* Nonzero means display mode line highlighted */
139 int mode_line_inverse_video
;
141 static void echo_area_display ();
142 void mark_window_display_accurate ();
143 static void redisplay_windows ();
144 static void redisplay_window ();
145 static void update_menu_bars ();
146 static void update_menu_bar ();
147 static void try_window ();
148 static int try_window_id ();
149 static struct position
*display_text_line ();
150 static void display_mode_line ();
151 static int display_mode_element ();
152 static char *fmodetrunc ();
153 static char *decode_mode_spec ();
154 static int display_string ();
155 static void display_menu_bar ();
156 static int display_count_lines ();
158 /* Prompt to display in front of the minibuffer contents */
159 Lisp_Object minibuf_prompt
;
161 /* Width in columns of current minibuffer prompt. */
162 int minibuf_prompt_width
;
164 /* Message to display instead of minibuffer contents
165 This is what the functions error and message make,
166 and command echoing uses it as well.
167 It overrides the minibuf_prompt as well as the buffer. */
168 char *echo_area_glyphs
;
170 /* This is the length of the message in echo_area_glyphs. */
171 int echo_area_glyphs_length
;
173 /* true iff we should redraw the mode lines on the next redisplay */
174 int update_mode_lines
;
176 /* Smallest number of characters before the gap
177 at any time since last redisplay that finished.
178 Valid for current buffer when try_window_id can be called. */
181 /* Smallest number of characters after the gap
182 at any time since last redisplay that finished.
183 Valid for current buffer when try_window_id can be called. */
186 /* MODIFF as of last redisplay that finished;
187 if it matches MODIFF, beg_unchanged and end_unchanged
188 contain no useful information */
189 int unchanged_modified
;
191 /* Nonzero if head_clip or tail_clip of current buffer has changed
192 since last redisplay that finished */
195 /* Nonzero if window sizes or contents have changed
196 since last redisplay that finished */
197 int windows_or_buffers_changed
;
199 /* Nonzero after display_mode_line if %l was used
200 and it displayed a line number. */
201 int line_number_displayed
;
203 /* Nonzero if display_mode_line needs to handle %c. */
204 int column_number_displayed
;
206 /* Maximum buffer size for which to display line numbers. */
207 int line_number_display_limit
;
209 /* Display an echo area message M with a specified length of LEN chars.
210 The string may include null characters. If m is 0, clear out any
211 existing message, and let the minibuffer text show through.
212 Do not pass text that is stored in a Lisp string. */
221 if (noninteractive_need_newline
)
223 noninteractive_need_newline
= 0;
224 fwrite (m
, len
, 1, stderr
);
225 if (cursor_in_echo_area
== 0)
226 fprintf (stderr
, "\n");
229 /* A null message buffer means that the frame hasn't really been
230 initialized yet. Error messages get reported properly by
231 cmd_error, so this must be just an informative message; toss it. */
232 else if (INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
235 Lisp_Object minibuf_frame
;
237 choose_minibuf_frame ();
238 minibuf_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
239 FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame
));
240 if (FRAME_VISIBLE_P (selected_frame
)
241 && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame
)))
242 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window
)));
247 echo_area_glyphs
= m
;
248 echo_area_glyphs_length
= len
;
251 echo_area_glyphs
= previous_echo_glyphs
= 0;
253 do_pending_window_change ();
254 echo_area_display ();
255 update_frame (XFRAME (XWINDOW (minibuf_window
)->frame
), 1, 1);
256 do_pending_window_change ();
257 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
258 (*frame_up_to_date_hook
) (XFRAME (XWINDOW (minibuf_window
)->frame
));
266 message2 (m
, (m
? strlen (m
) : 0));
269 /* Truncate what will be displayed in the echo area
270 the next time we display it--but don't redisplay it now. */
273 truncate_echo_area (len
)
276 /* A null message buffer means that the frame hasn't really been
277 initialized yet. Error messages get reported properly by
278 cmd_error, so this must be just an informative message; toss it. */
279 if (!noninteractive
&& INTERACTIVE
&& FRAME_MESSAGE_BUF (selected_frame
))
280 echo_area_glyphs_length
= len
;
283 /* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
284 zero if being used by message. */
285 int message_buf_print
;
287 /* Dump an informative message to the minibuf. If m is 0, clear out
288 any existing message, and let the minibuffer text show through. */
291 message (m
, a1
, a2
, a3
)
293 EMACS_INT a1
, a2
, a3
;
299 if (noninteractive_need_newline
)
301 noninteractive_need_newline
= 0;
302 fprintf (stderr
, m
, a1
, a2
, a3
);
303 if (cursor_in_echo_area
== 0)
304 fprintf (stderr
, "\n");
308 else if (INTERACTIVE
)
310 /* The frame whose minibuffer we're going to display the message on.
311 It may be larger than the selected frame, so we need
312 to use its buffer, not the selected frame's buffer. */
313 FRAME_PTR echo_frame
;
315 choose_minibuf_frame ();
316 echo_frame
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
318 echo_frame
= selected_frame
;
321 /* A null message buffer means that the frame hasn't really been
322 initialized yet. Error messages get reported properly by
323 cmd_error, so this must be just an informative message; toss it. */
324 if (FRAME_MESSAGE_BUF (echo_frame
))
335 len
= doprnt (FRAME_MESSAGE_BUF (echo_frame
),
336 FRAME_WIDTH (echo_frame
), m
, 0, 3, a
);
338 len
= doprnt (FRAME_MESSAGE_BUF (echo_frame
),
339 FRAME_WIDTH (echo_frame
), m
, 0, 3, &a1
);
340 #endif /* NO_ARG_ARRAY */
342 message2 (FRAME_MESSAGE_BUF (echo_frame
), len
);
347 /* Print should start at the beginning of the message
349 message_buf_print
= 0;
357 message2 (echo_area_glyphs
, echo_area_glyphs_length
);
367 choose_minibuf_frame ();
370 f
= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
372 if (! FRAME_VISIBLE_P (f
))
377 redraw_garbaged_frames ();
381 if (echo_area_glyphs
|| minibuf_level
== 0)
383 vpos
= XFASTINT (XWINDOW (minibuf_window
)->top
);
384 get_display_line (f
, vpos
, 0);
385 display_string (XWINDOW (minibuf_window
), vpos
,
386 echo_area_glyphs
? echo_area_glyphs
: "",
387 echo_area_glyphs
? echo_area_glyphs_length
: -1,
388 0, 0, 0, 0, FRAME_WIDTH (f
));
390 /* If desired cursor location is on this line, put it at end of text */
391 if (FRAME_CURSOR_Y (f
) == vpos
)
392 FRAME_CURSOR_X (f
) = FRAME_DESIRED_GLYPHS (f
)->used
[vpos
];
394 /* Fill the rest of the minibuffer window with blank lines. */
399 i
< vpos
+ XFASTINT (XWINDOW (minibuf_window
)->height
); i
++)
401 get_display_line (f
, i
, 0);
402 display_string (XWINDOW (minibuf_window
), vpos
,
403 "", 0, 0, 0, 0, 0, FRAME_WIDTH (f
));
407 else if (!EQ (minibuf_window
, selected_window
))
408 windows_or_buffers_changed
++;
410 if (EQ (minibuf_window
, selected_window
))
411 this_line_bufpos
= 0;
413 previous_echo_glyphs
= echo_area_glyphs
;
416 #ifdef HAVE_X_WINDOWS
417 static char frame_title_buf
[512];
418 static char *frame_title_ptr
;
421 store_frame_title (str
, mincol
, maxcol
)
426 if (maxcol
< 0 || maxcol
>= sizeof(frame_title_buf
))
427 maxcol
= sizeof (frame_title_buf
);
428 limit
= &frame_title_buf
[maxcol
];
429 while (*str
!= '\0' && frame_title_ptr
< limit
)
430 *frame_title_ptr
++ = *str
++;
431 while (frame_title_ptr
< &frame_title_buf
[mincol
])
432 *frame_title_ptr
++ = ' ';
433 return frame_title_ptr
- frame_title_buf
;
437 x_consider_frame_title (frame
)
443 FRAME_PTR f
= XFRAME (frame
);
445 if (!FRAME_X_P (f
) || FRAME_MINIBUF_ONLY_P (f
) || f
->explicit_name
)
447 multiple_frames
= !EQ (Fnext_frame (frame
, Qnil
), frame
);
448 obuf
= current_buffer
;
449 Fset_buffer (XWINDOW (f
->selected_window
)->buffer
);
450 fmt
= (FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
);
451 frame_title_ptr
= frame_title_buf
;
452 len
= display_mode_element (XWINDOW (f
->selected_window
), 0, 0, 0,
453 0, sizeof (frame_title_buf
), fmt
);
455 set_buffer_internal (obuf
);
456 /* Set the name only if it's changed. This avoids consing
457 in the common case where it hasn't. (If it turns out that we've
458 already wasted too much time by walking through the list with
459 display_mode_element, then we might need to optimize at a higher
461 if (! STRINGP (f
->name
) || XSTRING (f
->name
)->size
!= len
462 || bcmp (frame_title_buf
, XSTRING (f
->name
)->data
, len
) != 0)
463 x_implicitly_set_name (f
, make_string (frame_title_buf
, len
), Qnil
);
466 #define frame_title_ptr ((char *)0)
467 #define store_frame_title(str, mincol, maxcol) 0
470 /* Prepare for redisplay by updating menu-bar item lists when appropriate.
471 This can't be done in `redisplay' itself because it can call eval. */
476 register struct window
*w
= XWINDOW (selected_window
);
482 /* Set the visible flags for all frames.
483 Do this before checking for resized or garbaged frames; they want
484 to know if their frames are visible.
485 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
487 Lisp_Object tail
, frame
;
489 FOR_EACH_FRAME (tail
, frame
)
490 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
493 /* Notice any pending interrupt request to change frame size. */
494 do_pending_window_change ();
498 redraw_garbaged_frames ();
502 all_windows
= (update_mode_lines
|| buffer_shared
> 1
503 || clip_changed
|| windows_or_buffers_changed
);
505 #ifdef HAVE_X_WINDOWS
506 if (windows_or_buffers_changed
)
508 Lisp_Object tail
, frame
;
510 FOR_EACH_FRAME (tail
, frame
)
511 if (FRAME_VISIBLE_P (XFRAME (frame
))
512 || FRAME_ICONIFIED_P (XFRAME (frame
)))
513 x_consider_frame_title (frame
);
517 /* Update the menu bar item lists, if appropriate.
518 This has to be done before any actual redisplay
519 or generation of display lines. */
522 Lisp_Object tail
, frame
;
524 FOR_EACH_FRAME (tail
, frame
)
525 update_menu_bar (XFRAME (frame
));
528 update_menu_bar (selected_frame
);
531 /* Do a frame update, taking possible shortcuts into account.
532 This is the main external entry point for redisplay.
534 If the last redisplay displayed an echo area message and that
535 message is no longer requested, we clear the echo area
536 or bring back the minibuffer if that is in use.
538 Do not call eval from within this function.
539 Calls to eval after the call to echo_area_display would confuse
540 the display_line mechanism and would cause a crash.
541 Calls to eval before that point will work most of the time,
542 but can still lose, because this function
543 can be called from signal handlers; with alarms set up;
544 or with synchronous processes running.
546 See Fcall_process; if you called it from here, it could be
547 entered recursively. */
549 static int do_verify_charstarts
;
551 /* Counter is used to clear the face cache
552 no more than once ever 1000 redisplays. */
553 static int clear_face_cache_count
;
558 register struct window
*w
= XWINDOW (selected_window
);
562 register int tlbufpos
, tlendpos
;
564 extern int input_pending
;
569 /* Set the visible flags for all frames.
570 Do this before checking for resized or garbaged frames; they want
571 to know if their frames are visible.
572 See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
574 Lisp_Object tail
, frame
;
576 FOR_EACH_FRAME (tail
, frame
)
577 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
580 /* Notice any pending interrupt request to change frame size. */
581 do_pending_window_change ();
585 redraw_garbaged_frames ();
589 if (clip_changed
|| windows_or_buffers_changed
|| column_number_displayed
)
592 /* Detect case that we need to write a star in the mode line. */
593 if (XFASTINT (w
->last_modified
) < MODIFF
594 && XFASTINT (w
->last_modified
) <= current_buffer
->save_modified
)
596 w
->update_mode_line
= Qt
;
597 if (buffer_shared
> 1)
601 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
603 all_windows
= update_mode_lines
|| buffer_shared
> 1;
605 /* If specs for an arrow have changed, do thorough redisplay
606 to ensure we remove any arrow that should no longer exist. */
607 if (! EQ (Voverlay_arrow_position
, last_arrow_position
)
608 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
609 all_windows
= 1, clip_changed
= 1;
611 /* Normally the message* functions will have already displayed and
612 updated the echo area, but the frame may have been trashed, or
613 the update may have been preempted, so display the echo area
615 if (echo_area_glyphs
|| previous_echo_glyphs
)
617 echo_area_display ();
621 /* If showing region, and mark has changed, must redisplay whole window. */
622 if (((!NILP (Vtransient_mark_mode
)
623 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
624 != !NILP (w
->region_showing
))
625 || (!NILP (w
->region_showing
)
626 && !EQ (w
->region_showing
,
627 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
628 this_line_bufpos
= -1;
630 tlbufpos
= this_line_bufpos
;
631 tlendpos
= this_line_endpos
;
632 if (!all_windows
&& tlbufpos
> 0 && NILP (w
->update_mode_line
)
633 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
634 /* Make sure recorded data applies to current buffer, etc */
635 && this_line_buffer
== current_buffer
636 && current_buffer
== XBUFFER (w
->buffer
)
637 && NILP (w
->force_start
)
638 /* Point must be on the line that we have info recorded about */
640 && PT
<= Z
- tlendpos
641 /* All text outside that line, including its final newline,
643 && (XFASTINT (w
->last_modified
) >= MODIFF
644 || (beg_unchanged
>= tlbufpos
- 1
646 /* If selective display, can't optimize
647 if the changes start at the beginning of the line. */
648 && ((INTEGERP (current_buffer
->selective_display
)
649 && XINT (current_buffer
->selective_display
) > 0
650 ? (beg_unchanged
>= tlbufpos
653 && end_unchanged
>= tlendpos
654 && Z
- GPT
>= tlendpos
)))
656 if (tlbufpos
> BEGV
&& FETCH_CHAR (tlbufpos
- 1) != '\n'
658 || FETCH_CHAR (tlbufpos
) == '\n'))
659 /* Former continuation line has disappeared by becoming empty */
661 else if (XFASTINT (w
->last_modified
) < MODIFF
662 || MINI_WINDOW_P (w
))
665 overlay_arrow_seen
= 0;
666 display_text_line (w
, tlbufpos
, this_line_vpos
, this_line_start_hpos
,
667 pos_tab_offset (w
, tlbufpos
));
668 /* If line contains point, is not continued,
669 and ends at same distance from eob as before, we win */
670 if (cursor_vpos
>= 0 && this_line_bufpos
671 && this_line_endpos
== tlendpos
)
673 /* If this is not the window's last line,
674 we must adjust the charstarts of the lines below. */
675 if (this_line_vpos
+ 1
676 < XFASTINT (w
->top
) + window_internal_height (w
))
678 int left
= XFASTINT (w
->left
);
679 int *charstart_next_line
680 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[this_line_vpos
+ 1];
684 if (Z
- tlendpos
== ZV
)
685 /* This line ends at end of (accessible part of) buffer.
686 There is no newline to count. */
687 adjust
= Z
- tlendpos
- charstart_next_line
[left
];
689 /* This line ends in a newline.
690 Must take account of the newline and the rest of the
691 text that follows. */
692 adjust
= Z
- tlendpos
+ 1 - charstart_next_line
[left
];
694 adjust_window_charstarts (w
, this_line_vpos
, adjust
);
697 if (XFASTINT (w
->width
) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w
))))
698 preserve_other_columns (w
);
704 else if (PT
== XFASTINT (w
->last_point
))
708 do_pending_window_change ();
713 /* If highlighting the region, we can't just move the cursor. */
714 else if (! (!NILP (Vtransient_mark_mode
)
715 && !NILP (current_buffer
->mark_active
))
716 && NILP (w
->region_showing
))
718 pos
= *compute_motion (tlbufpos
, 0,
719 XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0,
720 PT
, 2, - (1 << (SHORTBITS
- 1)),
721 window_internal_width (w
) - 1,
723 pos_tab_offset (w
, tlbufpos
), w
);
726 FRAME_CURSOR_X (selected_frame
)
727 = XFASTINT (w
->left
) + max (pos
.hpos
, 0);
728 FRAME_CURSOR_Y (selected_frame
) = this_line_vpos
;
735 /* Text changed drastically or point moved off of line */
736 cancel_line (this_line_vpos
, selected_frame
);
739 this_line_bufpos
= 0;
740 all_windows
|= buffer_shared
> 1;
742 clear_face_cache_count
++;
746 Lisp_Object tail
, frame
;
749 /* Clear the face cache, only when we do a full redisplay
750 and not too often either. */
751 if (clear_face_cache_count
> 1000)
754 clear_face_cache_count
= 0;
758 /* Recompute # windows showing selected buffer.
759 This will be incremented each time such a window is displayed. */
762 FOR_EACH_FRAME (tail
, frame
)
764 FRAME_PTR f
= XFRAME (frame
);
766 /* Mark all the scroll bars to be removed; we'll redeem the ones
767 we want when we redisplay their windows. */
768 if (condemn_scroll_bars_hook
)
769 (*condemn_scroll_bars_hook
) (f
);
771 if (FRAME_VISIBLE_P (f
))
772 redisplay_windows (FRAME_ROOT_WINDOW (f
));
774 /* Any scroll bars which redisplay_windows should have nuked
775 should now go away. */
776 if (judge_scroll_bars_hook
)
777 (*judge_scroll_bars_hook
) (f
);
780 else if (FRAME_VISIBLE_P (selected_frame
))
782 redisplay_window (selected_window
, 1);
783 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
784 preserve_other_columns (w
);
788 /* Prevent various kinds of signals during display update.
789 stdio is not robust about handling signals,
790 which can cause an apparent I/O error. */
802 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
806 if (!FRAMEP (XCONS (tail
)->car
))
809 f
= XFRAME (XCONS (tail
)->car
);
810 if (FRAME_VISIBLE_P (f
))
812 pause
|= update_frame (f
, 0, 0);
815 mark_window_display_accurate (f
->root_window
, 1);
816 if (frame_up_to_date_hook
!= 0)
817 (*frame_up_to_date_hook
) (f
);
823 #endif /* MULTI_FRAME */
825 if (FRAME_VISIBLE_P (selected_frame
))
826 pause
= update_frame (selected_frame
, 0, 0);
828 /* We may have called echo_area_display at the top of this
829 function. If the echo area is on another frame, that may
830 have put text on a frame other than the selected one, so the
831 above call to update_frame would not have caught it. Catch
835 = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
837 if (mini_frame
!= selected_frame
)
838 pause
|= update_frame (mini_frame
, 0, 0);
842 /* If frame does not match, prevent doing single-line-update next time.
843 Also, don't forget to check every line to update the arrow. */
846 this_line_bufpos
= 0;
847 if (!NILP (last_arrow_position
))
849 last_arrow_position
= Qt
;
850 last_arrow_string
= Qt
;
852 /* If we pause after scrolling, some lines in current_frame
853 may be null, so preserve_other_columns won't be able to
854 preserve all the vertical-bar separators. So, avoid using it
856 if (XFASTINT (w
->width
) != FRAME_WIDTH (selected_frame
))
857 update_mode_lines
= 1;
860 /* Now text on frame agrees with windows, so
861 put info into the windows for partial redisplay to follow */
865 register struct buffer
*b
= XBUFFER (w
->buffer
);
867 blank_end_of_window
= 0;
869 unchanged_modified
= BUF_MODIFF (b
);
870 beg_unchanged
= BUF_GPT (b
) - BUF_BEG (b
);
871 end_unchanged
= BUF_Z (b
) - BUF_GPT (b
);
873 XSETFASTINT (w
->last_point
, BUF_PT (b
));
874 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (selected_frame
));
875 XSETFASTINT (w
->last_point_y
, FRAME_CURSOR_Y (selected_frame
));
878 mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame
), 1);
881 w
->update_mode_line
= Qnil
;
882 XSETFASTINT (w
->last_modified
, BUF_MODIFF (b
));
883 w
->window_end_valid
= w
->buffer
;
884 last_arrow_position
= Voverlay_arrow_position
;
885 last_arrow_string
= Voverlay_arrow_string
;
886 if (do_verify_charstarts
)
887 verify_charstarts (w
);
888 if (frame_up_to_date_hook
!= 0)
889 (*frame_up_to_date_hook
) (selected_frame
);
891 update_mode_lines
= 0;
892 windows_or_buffers_changed
= 0;
895 /* Start SIGIO interrupts coming again.
896 Having them off during the code above
897 makes it less likely one will discard output,
898 but not impossible, since there might be stuff
899 in the system buffer here.
900 But it is much hairier to try to do anything about that. */
906 /* Change frame size now if a change is pending. */
907 do_pending_window_change ();
909 /* If we just did a pending size change, redisplay again
911 if (windows_or_buffers_changed
&& !pause
)
915 /* Redisplay, but leave alone any recent echo area message
916 unless another message has been requested in its place.
918 This is useful in situations where you need to redisplay but no
919 user action has occurred, making it inappropriate for the message
920 area to be cleared. See tracking_off and
921 wait_reading_process_input for examples of these situations. */
923 redisplay_preserve_echo_area ()
925 if (echo_area_glyphs
== 0 && previous_echo_glyphs
!= 0)
927 echo_area_glyphs
= previous_echo_glyphs
;
929 echo_area_glyphs
= 0;
936 mark_window_display_accurate (window
, flag
)
940 register struct window
*w
;
942 for (;!NILP (window
); window
= w
->next
)
944 if (!WINDOWP (window
)) abort ();
945 w
= XWINDOW (window
);
947 if (!NILP (w
->buffer
))
949 XSETFASTINT (w
->last_modified
,
950 !flag
? 0 : BUF_MODIFF (XBUFFER (w
->buffer
)));
952 /* Record if we are showing a region, so can make sure to
953 update it fully at next redisplay. */
954 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
955 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
956 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
960 w
->window_end_valid
= w
->buffer
;
961 w
->update_mode_line
= Qnil
;
963 if (!NILP (w
->vchild
))
964 mark_window_display_accurate (w
->vchild
, flag
);
965 if (!NILP (w
->hchild
))
966 mark_window_display_accurate (w
->hchild
, flag
);
971 last_arrow_position
= Voverlay_arrow_position
;
972 last_arrow_string
= Voverlay_arrow_string
;
976 /* t is unequal to any useful value of Voverlay_arrow_... */
977 last_arrow_position
= Qt
;
978 last_arrow_string
= Qt
;
982 /* Update the menu bar item list for frame F.
983 This has to be done before we start to fill in any display lines,
984 because it can call eval. */
990 struct buffer
*old
= current_buffer
;
992 register struct window
*w
;
993 window
= FRAME_SELECTED_WINDOW (f
);
994 w
= XWINDOW (window
);
996 if (update_mode_lines
)
997 w
->update_mode_line
= Qt
;
1000 #ifdef USE_X_TOOLKIT
1001 FRAME_EXTERNAL_MENU_BAR (f
)
1003 FRAME_MENU_BAR_LINES (f
) > 0
1007 /* If the user has switched buffers or windows, we need to
1008 recompute to reflect the new bindings. But we'll
1009 recompute when update_mode_lines is set too; that means
1010 that people can use force-mode-line-update to request
1011 that the menu bar be recomputed. The adverse effect on
1012 the rest of the redisplay algorithm is about the same as
1013 windows_or_buffers_changed anyway. */
1014 if (windows_or_buffers_changed
1015 || !NILP (w
->update_mode_line
)
1016 || (XFASTINT (w
->last_modified
) < MODIFF
1017 && (XFASTINT (w
->last_modified
)
1018 <= XBUFFER (w
->buffer
)->save_modified
)))
1020 struct buffer
*prev
= current_buffer
;
1021 call1 (Vrun_hooks
, Qmenu_bar_update_hook
);
1022 current_buffer
= XBUFFER (w
->buffer
);
1023 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1024 current_buffer
= prev
;
1025 #ifdef USE_X_TOOLKIT
1026 set_frame_menubar (f
, 0);
1027 #endif /* USE_X_TOOLKIT */
1034 /* Redisplay WINDOW and its subwindows and siblings. */
1037 redisplay_windows (window
)
1040 for (; !NILP (window
); window
= XWINDOW (window
)->next
)
1041 redisplay_window (window
, 0);
1044 /* Redisplay window WINDOW and its subwindows. */
1047 redisplay_window (window
, just_this_one
)
1051 register struct window
*w
= XWINDOW (window
);
1052 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1054 register int lpoint
= PT
;
1055 struct buffer
*old
= current_buffer
;
1056 register int width
= window_internal_width (w
) - 1;
1057 register int startp
;
1058 register int hscroll
= XINT (w
->hscroll
);
1059 struct position pos
;
1062 int window_needs_modeline
;
1064 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1066 /* If this is a combination window, do its children; that's all. */
1068 if (!NILP (w
->vchild
))
1070 redisplay_windows (w
->vchild
);
1073 if (!NILP (w
->hchild
))
1075 redisplay_windows (w
->hchild
);
1078 if (NILP (w
->buffer
))
1081 height
= window_internal_height (w
);
1083 if (MINI_WINDOW_P (w
))
1085 if (w
== XWINDOW (minibuf_window
))
1087 if (echo_area_glyphs
)
1088 /* We've already displayed the echo area glyphs, if any. */
1089 goto finish_scroll_bars
;
1093 /* This is a minibuffer, but it's not the currently active one, so
1095 int vpos
= XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1098 for (i
= 0; i
< height
; i
++)
1100 get_display_line (f
, vpos
+ i
, 0);
1101 display_string (w
, vpos
+ i
, "", 0, 0, 0, 1, 0, width
);
1104 goto finish_scroll_bars
;
1108 if (update_mode_lines
)
1109 w
->update_mode_line
= Qt
;
1111 /* Otherwise set up data on this window; select its buffer and point value */
1113 current_buffer
= XBUFFER (w
->buffer
);
1116 /* Count number of windows showing the selected buffer. */
1119 && current_buffer
== XBUFFER (XWINDOW (selected_window
)->buffer
))
1122 /* POINT refers normally to the selected window.
1123 For any other window, set up appropriate value. */
1125 if (!EQ (window
, selected_window
))
1127 int new_pt
= marker_position (w
->pointm
);
1131 Fset_marker (w
->pointm
, make_number (new_pt
), Qnil
);
1133 else if (new_pt
> (ZV
- 1))
1136 Fset_marker (w
->pointm
, make_number (new_pt
), Qnil
);
1138 /* We don't use SET_PT so that the point-motion hooks don't run. */
1139 BUF_PT (current_buffer
) = new_pt
;
1142 /* If any of the character widths specified in the display table
1143 have changed, invalidate the width run cache. It's true that this
1144 may be a bit late to catch such changes, but the rest of
1145 redisplay goes (non-fatally) haywire when the display table is
1146 changed, so why should we worry about doing any better? */
1147 if (current_buffer
->width_run_cache
)
1149 struct Lisp_Vector
*disptab
= buffer_display_table ();
1151 if (! disptab_matches_widthtab (disptab
,
1152 XVECTOR (current_buffer
->width_table
)))
1154 invalidate_region_cache (current_buffer
,
1155 current_buffer
->width_run_cache
,
1157 recompute_width_table (current_buffer
, disptab
);
1161 /* If window-start is screwed up, choose a new one. */
1162 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
1165 startp
= marker_position (w
->start
);
1167 /* Handle case where place to start displaying has been specified,
1168 unless the specified location is outside the accessible range. */
1169 if (!NILP (w
->force_start
))
1171 /* Forget any recorded base line for line number display. */
1172 w
->base_line_number
= Qnil
;
1173 w
->update_mode_line
= Qt
;
1174 w
->force_start
= Qnil
;
1175 XSETFASTINT (w
->last_modified
, 0);
1176 if (startp
< BEGV
) startp
= BEGV
;
1177 if (startp
> ZV
) startp
= ZV
;
1178 try_window (window
, startp
);
1179 if (cursor_vpos
< 0)
1181 /* If point does not appear, move point so it does appear */
1182 pos
= *compute_motion (startp
, 0,
1183 ((EQ (window
, minibuf_window
) && startp
== 1)
1184 ? minibuf_prompt_width
: 0)
1186 (hscroll
? 1 - hscroll
: 0),
1188 - (1 << (SHORTBITS
- 1)),
1189 width
, hscroll
, pos_tab_offset (w
, startp
), w
);
1190 BUF_PT (current_buffer
) = pos
.bufpos
;
1191 if (w
!= XWINDOW (selected_window
))
1192 Fset_marker (w
->pointm
, make_number (PT
), Qnil
);
1195 if (current_buffer
== old
)
1197 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
1198 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1200 /* If we are highlighting the region,
1201 then we just changed the region, so redisplay to show it. */
1202 if (!NILP (Vtransient_mark_mode
)
1203 && !NILP (current_buffer
->mark_active
))
1205 cancel_my_columns (XWINDOW (window
));
1206 try_window (window
, startp
);
1212 /* Handle case where text has not changed, only point,
1213 and it has not moved off the frame */
1215 /* This code is not used for minibuffer for the sake of
1216 the case of redisplaying to replace an echo area message;
1217 since in that case the minibuffer contents per se are usually unchanged.
1218 This code is of no real use in the minibuffer since
1219 the handling of this_line_bufpos, etc.,
1220 in redisplay handles the same cases. */
1222 if (XFASTINT (w
->last_modified
) >= MODIFF
1223 && PT
>= startp
&& !clip_changed
1224 && (just_this_one
|| XFASTINT (w
->width
) == FRAME_WIDTH (f
))
1225 /* Can't use this case if highlighting a region. */
1226 && !(!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1227 && NILP (w
->region_showing
)
1228 /* If end pos is out of date, scroll bar and percentage will be wrong */
1229 && INTEGERP (w
->window_end_vpos
)
1230 && XFASTINT (w
->window_end_vpos
) < XFASTINT (w
->height
)
1231 && !EQ (window
, minibuf_window
))
1233 pos
= *compute_motion (startp
, 0, (hscroll
? 1 - hscroll
: 0),
1234 PT
, height
+ 1, 10000, width
, hscroll
,
1235 pos_tab_offset (w
, startp
), w
);
1237 if (pos
.vpos
< height
)
1239 /* Ok, point is still on frame */
1240 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
1242 /* These variables are supposed to be origin 1 */
1243 FRAME_CURSOR_X (f
) = max (0, pos
.hpos
) + XFASTINT (w
->left
);
1244 FRAME_CURSOR_Y (f
) = pos
.vpos
+ XFASTINT (w
->top
);
1246 /* This doesn't do the trick, because if a window to the right of
1247 this one must be redisplayed, this does nothing because there
1248 is nothing in DesiredFrame yet, and then the other window is
1249 redisplayed, making likes that are empty in this window's columns.
1250 if (XFASTINT (w->width) != FRAME_WIDTH (f))
1251 preserve_my_columns (w);
1255 /* Don't bother trying redisplay with same start;
1256 we already know it will lose */
1258 /* If current starting point was originally the beginning of a line
1259 but no longer is, find a new starting point. */
1260 else if (!NILP (w
->start_at_line_beg
)
1262 || FETCH_CHAR (startp
- 1) == '\n'))
1266 else if (just_this_one
&& !MINI_WINDOW_P (w
)
1268 && XFASTINT (w
->last_modified
)
1269 /* or else vmotion on first line won't work. */
1270 && ! NILP (w
->start_at_line_beg
)
1271 && ! EQ (w
->window_end_valid
, Qnil
)
1272 && do_id
&& !clip_changed
1273 && !blank_end_of_window
1274 && XFASTINT (w
->width
) == FRAME_WIDTH (f
)
1275 /* Can't use this case if highlighting a region. */
1276 && !(!NILP (Vtransient_mark_mode
)
1277 && !NILP (current_buffer
->mark_active
))
1278 && NILP (w
->region_showing
)
1279 && EQ (last_arrow_position
, Voverlay_arrow_position
)
1280 && EQ (last_arrow_string
, Voverlay_arrow_string
)
1281 && (tem
= try_window_id (FRAME_SELECTED_WINDOW (f
)))
1284 /* tem > 0 means success. tem == -1 means choose new start.
1285 tem == -2 means try again with same start,
1286 and nothing but whitespace follows the changed stuff.
1287 tem == 0 means try again with same start. */
1291 else if (startp
>= BEGV
&& startp
<= ZV
1292 /* Avoid starting display at end of buffer! */
1293 && (startp
< ZV
|| startp
== BEGV
1294 || (XFASTINT (w
->last_modified
) >= MODIFF
)))
1296 /* Try to redisplay starting at same place as before */
1297 /* If point has not moved off frame, accept the results */
1298 try_window (window
, startp
);
1299 if (cursor_vpos
>= 0)
1301 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1302 /* Forget any recorded base line for line number display. */
1303 w
->base_line_number
= Qnil
;
1307 cancel_my_columns (w
);
1310 XSETFASTINT (w
->last_modified
, 0);
1311 w
->update_mode_line
= Qt
;
1313 /* Try to scroll by specified few lines */
1315 if (scroll_step
&& !clip_changed
)
1319 pos
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1320 scroll_step
, width
, hscroll
, window
);
1321 if (pos
.vpos
>= height
)
1325 pos
= *vmotion (startp
, PT
< startp
? - scroll_step
: scroll_step
,
1326 width
, hscroll
, window
);
1328 if (PT
>= pos
.bufpos
)
1330 try_window (window
, pos
.bufpos
);
1331 if (cursor_vpos
>= 0)
1333 if (!just_this_one
|| clip_changed
|| beg_unchanged
< startp
)
1334 /* Forget any recorded base line for line number display. */
1335 w
->base_line_number
= Qnil
;
1339 cancel_my_columns (w
);
1344 /* Finally, just choose place to start which centers point */
1347 /* Forget any previously recorded base line for line number display. */
1348 w
->base_line_number
= Qnil
;
1350 pos
= *vmotion (PT
, - (height
/ 2), width
, hscroll
, window
);
1351 try_window (window
, pos
.bufpos
);
1353 startp
= marker_position (w
->start
);
1354 w
->start_at_line_beg
1355 = (startp
== BEGV
|| FETCH_CHAR (startp
- 1) == '\n') ? Qt
: Qnil
;
1358 if ((!NILP (w
->update_mode_line
)
1359 /* If window not full width, must redo its mode line
1360 if the window to its side is being redone */
1361 || (!just_this_one
&& width
< FRAME_WIDTH (f
) - 1)
1362 || INTEGERP (w
->base_line_pos
) || column_number_displayed
)
1363 && height
!= XFASTINT (w
->height
))
1364 display_mode_line (w
);
1365 if (! line_number_displayed
1366 && ! BUFFERP (w
->base_line_pos
))
1368 w
->base_line_pos
= Qnil
;
1369 w
->base_line_number
= Qnil
;
1372 /* When we reach a frame's selected window, redo the frame's menu bar. */
1373 if (!NILP (w
->update_mode_line
)
1374 #ifdef USE_X_TOOLKIT
1375 && FRAME_EXTERNAL_MENU_BAR (f
)
1377 && FRAME_MENU_BAR_LINES (f
) > 0
1379 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
1380 display_menu_bar (w
);
1383 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1385 int start
, end
, whole
;
1387 /* Calculate the start and end positions for the current window.
1388 At some point, it would be nice to choose between scrollbars
1389 which reflect the whole buffer size, with special markers
1390 indicating narrowing, and scrollbars which reflect only the
1393 Note that minibuffers sometimes aren't displaying any text. */
1394 if (! MINI_WINDOW_P (w
)
1395 || (w
== XWINDOW (minibuf_window
) && ! echo_area_glyphs
))
1398 start
= startp
- BEGV
;
1399 /* I don't think this is guaranteed to be right. For the
1400 moment, we'll pretend it is. */
1401 end
= (Z
- XINT (w
->window_end_pos
)) - BEGV
;
1403 if (end
< start
) end
= start
;
1404 if (whole
< (end
- start
)) whole
= end
- start
;
1407 start
= end
= whole
= 0;
1409 /* Indicate what this scroll bar ought to be displaying now. */
1410 (*set_vertical_scroll_bar_hook
) (w
, end
- start
, whole
, start
);
1412 /* Note that we actually used the scroll bar attached to this window,
1413 so it shouldn't be deleted at the end of redisplay. */
1414 (*redeem_scroll_bar_hook
) (w
);
1417 BUF_PT (current_buffer
) = opoint
;
1418 current_buffer
= old
;
1419 BUF_PT (current_buffer
) = lpoint
;
1422 /* Do full redisplay on one window, starting at position `pos'. */
1425 try_window (window
, pos
)
1429 register struct window
*w
= XWINDOW (window
);
1430 register int height
= window_internal_height (w
);
1431 register int vpos
= XFASTINT (w
->top
);
1432 register int last_text_vpos
= vpos
;
1433 int tab_offset
= pos_tab_offset (w
, pos
);
1434 FRAME_PTR f
= XFRAME (w
->frame
);
1435 int width
= window_internal_width (w
) - 1;
1436 struct position val
;
1438 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1440 overlay_arrow_seen
= 0;
1441 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
1443 while (--height
>= 0)
1445 val
= *display_text_line (w
, pos
, vpos
, val
.hpos
, tab_offset
);
1446 tab_offset
+= width
;
1447 if (val
.vpos
) tab_offset
= 0;
1449 if (pos
!= val
.bufpos
)
1451 /* Next line, unless prev line ended in end of buffer with no cr */
1452 = vpos
- (val
.vpos
&& (FETCH_CHAR (val
.bufpos
- 1) != '\n'
1453 #ifdef USE_TEXT_PROPERTIES
1454 || ! NILP (Fget_char_property (val
.bufpos
-1,
1462 /* If last line is continued in middle of character,
1463 include the split character in the text considered on the frame */
1464 if (val
.hpos
< (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
1467 /* If bottom just moved off end of frame, change mode line percentage. */
1468 if (XFASTINT (w
->window_end_pos
) == 0
1470 w
->update_mode_line
= Qt
;
1472 /* Say where last char on frame will be, once redisplay is finished. */
1473 XSETFASTINT (w
->window_end_pos
, Z
- pos
);
1474 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
- XFASTINT (w
->top
));
1475 /* But that is not valid info until redisplay finishes. */
1476 w
->window_end_valid
= Qnil
;
1479 /* Try to redisplay when buffer is modified locally,
1480 computing insert/delete line to preserve text outside
1481 the bounds of the changes.
1482 Return 1 if successful, 0 if if cannot tell what to do,
1483 or -1 to tell caller to find a new window start,
1484 or -2 to tell caller to do normal redisplay with same window start. */
1487 try_window_id (window
)
1491 register struct window
*w
= XWINDOW (window
);
1492 register int height
= window_internal_height (w
);
1493 FRAME_PTR f
= XFRAME (w
->frame
);
1494 int top
= XFASTINT (w
->top
);
1495 int start
= marker_position (w
->start
);
1496 int width
= window_internal_width (w
) - 1;
1497 int hscroll
= XINT (w
->hscroll
);
1498 int lmargin
= hscroll
> 0 ? 1 - hscroll
: 0;
1500 register int i
, tem
;
1501 int last_text_vpos
= 0;
1503 int selective
= (INTEGERP (current_buffer
->selective_display
)
1504 ? XINT (current_buffer
->selective_display
)
1505 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
1507 struct position val
, bp
, ep
, xp
, pp
;
1508 int scroll_amount
= 0;
1510 int tab_offset
, epto
;
1512 if (GPT
- BEG
< beg_unchanged
)
1513 beg_unchanged
= GPT
- BEG
;
1514 if (Z
- GPT
< end_unchanged
)
1515 end_unchanged
= Z
- GPT
;
1517 if (beg_unchanged
+ BEG
< start
)
1518 return 0; /* Give up if changes go above top of window */
1520 /* Find position before which nothing is changed. */
1521 bp
= *compute_motion (start
, 0, lmargin
,
1522 min (ZV
, beg_unchanged
+ BEG
), height
+ 1, 0,
1523 width
, hscroll
, pos_tab_offset (w
, start
), w
);
1524 if (bp
.vpos
>= height
)
1526 if (PT
< bp
.bufpos
&& !bp
.contin
)
1528 /* All changes are below the frame, and point is on the frame.
1529 We don't need to change the frame at all.
1530 But we need to update window_end_pos to account for
1531 any change in buffer size. */
1532 bp
= *compute_motion (start
, 0, lmargin
,
1534 width
, hscroll
, pos_tab_offset (w
, start
), w
);
1535 XSETFASTINT (w
->window_end_vpos
, height
);
1536 XSETFASTINT (w
->window_end_pos
, Z
- bp
.bufpos
);
1544 /* Find beginning of that frame line. Must display from there. */
1545 bp
= *vmotion (bp
.bufpos
, 0, width
, hscroll
, window
);
1552 /* If about to start displaying at the beginning of a continuation line,
1553 really start with previous frame line, in case it was not
1554 continued when last redisplayed */
1555 if ((bp
.contin
&& bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0)
1557 /* Likewise if we have to worry about selective display. */
1558 (selective
> 0 && bp
.bufpos
- 1 == beg_unchanged
&& vpos
> 0))
1560 bp
= *vmotion (bp
.bufpos
, -1, width
, hscroll
, window
);
1565 if (bp
.contin
&& bp
.hpos
!= lmargin
)
1567 val
.hpos
= bp
.prevhpos
- width
+ lmargin
;
1573 /* Find first visible newline after which no more is changed. */
1574 tem
= find_next_newline (Z
- max (end_unchanged
, Z
- ZV
), 1);
1576 while (tem
< ZV
- 1 && (indented_beyond_p (tem
, selective
)))
1577 tem
= find_next_newline (tem
, 1);
1579 /* Compute the cursor position after that newline. */
1580 ep
= *compute_motion (pos
, vpos
, val
.hpos
, tem
,
1581 height
, - (1 << (SHORTBITS
- 1)),
1582 width
, hscroll
, pos_tab_offset (w
, bp
.bufpos
), w
);
1584 /* If changes reach past the text available on the frame,
1585 just display rest of frame. */
1586 if (ep
.bufpos
> Z
- XFASTINT (w
->window_end_pos
))
1589 stop_vpos
= ep
.vpos
;
1591 /* If no newline before ep, the line ep is on includes some changes
1592 that must be displayed. Make sure we don't stop before it. */
1593 /* Also, if changes reach all the way until ep.bufpos,
1594 it is possible that something was deleted after the
1595 newline before it, so the following line must be redrawn. */
1596 if (stop_vpos
== ep
.vpos
1597 && (ep
.bufpos
== BEGV
1598 || FETCH_CHAR (ep
.bufpos
- 1) != '\n'
1599 || ep
.bufpos
== Z
- end_unchanged
))
1600 stop_vpos
= ep
.vpos
+ 1;
1603 overlay_arrow_seen
= 0;
1605 /* If changes do not reach to bottom of window,
1606 figure out how much to scroll the rest of the window */
1607 if (stop_vpos
< height
)
1609 /* Now determine how far up or down the rest of the window has moved */
1610 epto
= pos_tab_offset (w
, ep
.bufpos
);
1611 xp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1612 Z
- XFASTINT (w
->window_end_pos
),
1613 10000, 0, width
, hscroll
, epto
, w
);
1614 scroll_amount
= xp
.vpos
- XFASTINT (w
->window_end_vpos
);
1616 /* Is everything on frame below the changes whitespace?
1617 If so, no scrolling is really necessary. */
1618 for (i
= ep
.bufpos
; i
< xp
.bufpos
; i
++)
1620 tem
= FETCH_CHAR (i
);
1621 if (tem
!= ' ' && tem
!= '\n' && tem
!= '\t')
1627 XSETFASTINT (w
->window_end_vpos
,
1628 XFASTINT (w
->window_end_vpos
) + scroll_amount
);
1630 /* Before doing any scrolling, verify that point will be on frame. */
1631 if (PT
> ep
.bufpos
&& !(PT
<= xp
.bufpos
&& xp
.bufpos
< height
))
1633 if (PT
<= xp
.bufpos
)
1635 pp
= *compute_motion (ep
.bufpos
, ep
.vpos
, ep
.hpos
,
1636 PT
, height
, - (1 << (SHORTBITS
- 1)),
1637 width
, hscroll
, epto
, w
);
1641 pp
= *compute_motion (xp
.bufpos
, xp
.vpos
, xp
.hpos
,
1642 PT
, height
, - (1 << (SHORTBITS
- 1)),
1644 pos_tab_offset (w
, xp
.bufpos
), w
);
1646 if (pp
.bufpos
< PT
|| pp
.vpos
== height
)
1648 cursor_vpos
= pp
.vpos
+ top
;
1649 cursor_hpos
= pp
.hpos
+ XFASTINT (w
->left
);
1652 if (stop_vpos
- scroll_amount
>= height
1653 || ep
.bufpos
== xp
.bufpos
)
1655 if (scroll_amount
< 0)
1656 stop_vpos
-= scroll_amount
;
1658 /* In this path, we have altered window_end_vpos
1659 and not left it negative.
1660 We must make sure that, in case display is preempted
1661 before the frame changes to reflect what we do here,
1662 further updates will not come to try_window_id
1663 and assume the frame and window_end_vpos match. */
1664 blank_end_of_window
= 1;
1666 else if (!scroll_amount
)
1668 /* Even if we don't need to scroll, we must adjust the
1669 charstarts of subsequent lines (that we won't redisplay)
1670 according to the amount of text inserted or deleted. */
1671 int oldpos
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
1672 int adjust
= ep
.bufpos
- oldpos
;
1673 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1, adjust
);
1675 else if (bp
.bufpos
== Z
- end_unchanged
)
1677 /* If reprinting everything is nearly as fast as scrolling,
1678 don't bother scrolling. Can happen if lines are short. */
1679 if (scroll_cost (f
, bp
.vpos
+ top
- scroll_amount
,
1680 top
+ height
- max (0, scroll_amount
),
1682 > xp
.bufpos
- bp
.bufpos
- 20)
1683 /* Return "try normal display with same window-start."
1684 Too bad we can't prevent further scroll-thinking. */
1686 /* If pure deletion, scroll up as many lines as possible.
1687 In common case of killing a line, this can save the
1688 following line from being overwritten by scrolling
1689 and therefore having to be redrawn. */
1690 tem
= scroll_frame_lines (f
, bp
.vpos
+ top
- scroll_amount
,
1691 top
+ height
- max (0, scroll_amount
),
1692 scroll_amount
, bp
.bufpos
);
1697 /* scroll_frame_lines did not properly adjust subsequent
1698 lines' charstarts in the case where the text of the
1699 screen line at bp.vpos has changed.
1700 (This can happen in a deletion that ends in mid-line.)
1701 To adjust properly, we need to make things constent at
1703 So do a second adjust to make that happen.
1704 Note that stop_vpos >= ep.vpos, so it is sufficient
1705 to update the charstarts for lines at ep.vpos and below. */
1707 = FRAME_CURRENT_GLYPHS (f
)->charstarts
[ep
.vpos
+ top
][0];
1708 adjust_window_charstarts (w
, ep
.vpos
+ top
- 1,
1709 ep
.bufpos
- oldstart
);
1712 else if (scroll_amount
)
1714 /* If reprinting everything is nearly as fast as scrolling,
1715 don't bother scrolling. Can happen if lines are short. */
1716 /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
1717 overestimate of cost of reprinting, since xp.bufpos
1718 would end up below the bottom of the window. */
1719 if (scroll_cost (f
, ep
.vpos
+ top
- scroll_amount
,
1720 top
+ height
- max (0, scroll_amount
),
1722 > xp
.bufpos
- ep
.bufpos
- 20)
1723 /* Return "try normal display with same window-start."
1724 Too bad we can't prevent further scroll-thinking. */
1726 tem
= scroll_frame_lines (f
, ep
.vpos
+ top
- scroll_amount
,
1727 top
+ height
- max (0, scroll_amount
),
1728 scroll_amount
, ep
.bufpos
);
1729 if (!tem
) stop_vpos
= height
;
1733 /* In any case, do not display past bottom of window */
1734 if (stop_vpos
>= height
)
1740 /* Handle case where pos is before w->start --
1741 can happen if part of line had been clipped and is not clipped now */
1742 if (vpos
== 0 && pos
< marker_position (w
->start
))
1743 Fset_marker (w
->start
, make_number (pos
), Qnil
);
1745 /* Redisplay the lines where the text was changed */
1746 last_text_vpos
= vpos
;
1747 tab_offset
= pos_tab_offset (w
, pos
);
1748 /* If we are starting display in mid-character, correct tab_offset
1749 to account for passing the line that that character really starts in. */
1750 if (val
.hpos
< lmargin
)
1751 tab_offset
+= width
;
1752 while (vpos
< stop_vpos
)
1754 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1755 tab_offset
+= width
;
1756 if (val
.vpos
) tab_offset
= 0;
1757 if (pos
!= val
.bufpos
)
1759 /* Next line, unless prev line ended in end of buffer with no cr */
1760 = vpos
- (val
.vpos
&& FETCH_CHAR (val
.bufpos
- 1) != '\n');
1764 /* There are two cases:
1765 1) we have displayed down to the bottom of the window
1766 2) we have scrolled lines below stop_vpos by scroll_amount */
1770 /* If last line is continued in middle of character,
1771 include the split character in the text considered on the frame */
1772 if (val
.hpos
< lmargin
)
1774 XSETFASTINT (w
->window_end_vpos
, last_text_vpos
);
1775 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
1778 /* If scrolling made blank lines at window bottom,
1779 redisplay to fill those lines */
1780 if (scroll_amount
< 0)
1782 /* Don't consider these lines for general-purpose scrolling.
1783 That will save time in the scrolling computation. */
1784 FRAME_SCROLL_BOTTOM_VPOS (f
) = xp
.vpos
;
1789 vpos
= height
+ scroll_amount
;
1790 else if (xp
.contin
&& xp
.hpos
!= lmargin
)
1792 val
.hpos
= xp
.prevhpos
- width
+ lmargin
;
1796 blank_end_of_window
= 1;
1797 tab_offset
= pos_tab_offset (w
, pos
);
1798 /* If we are starting display in mid-character, correct tab_offset
1799 to account for passing the line that that character starts in. */
1800 if (val
.hpos
< lmargin
)
1801 tab_offset
+= width
;
1803 while (vpos
< height
)
1805 val
= *display_text_line (w
, pos
, top
+ vpos
++, val
.hpos
, tab_offset
);
1806 tab_offset
+= width
;
1807 if (val
.vpos
) tab_offset
= 0;
1811 /* Here is a case where display_text_line sets cursor_vpos wrong.
1812 Make it be fixed up, below. */
1818 /* If bottom just moved off end of frame, change mode line percentage. */
1819 if (XFASTINT (w
->window_end_pos
) == 0
1821 w
->update_mode_line
= Qt
;
1823 /* Attempt to adjust end-of-text positions to new bottom line */
1826 delta
= height
- xp
.vpos
;
1828 || (delta
> 0 && xp
.bufpos
<= ZV
)
1829 || (delta
== 0 && xp
.hpos
))
1831 val
= *vmotion (Z
- XFASTINT (w
->window_end_pos
),
1832 delta
, width
, hscroll
, window
);
1833 XSETFASTINT (w
->window_end_pos
, Z
- val
.bufpos
);
1834 XSETFASTINT (w
->window_end_vpos
,
1835 XFASTINT (w
->window_end_vpos
) + val
.vpos
);
1839 w
->window_end_valid
= Qnil
;
1841 /* If point was not in a line that was displayed, find it */
1842 if (cursor_vpos
< 0)
1844 val
= *compute_motion (start
, 0, lmargin
, PT
, 10000, 10000,
1845 width
, hscroll
, pos_tab_offset (w
, start
), w
);
1846 /* Admit failure if point is off frame now */
1847 if (val
.vpos
>= height
)
1849 for (vpos
= 0; vpos
< height
; vpos
++)
1850 cancel_line (vpos
+ top
, f
);
1853 cursor_vpos
= val
.vpos
+ top
;
1854 cursor_hpos
= val
.hpos
+ XFASTINT (w
->left
);
1857 FRAME_CURSOR_X (f
) = max (0, cursor_hpos
);
1858 FRAME_CURSOR_Y (f
) = cursor_vpos
;
1862 val
= *compute_motion (start
, 0, lmargin
, ZV
,
1863 height
, - (1 << (SHORTBITS
- 1)),
1864 width
, hscroll
, pos_tab_offset (w
, start
), w
);
1865 if (val
.vpos
!= XFASTINT (w
->window_end_vpos
))
1867 if (XFASTINT (w
->window_end_pos
)
1875 /* Mark a section of BUF as modified, but only for the sake of redisplay.
1876 This is useful for recording changes to overlays.
1878 We increment the buffer's modification timestamp and set the
1879 redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
1880 as if the region of text between START and END had been modified;
1881 the redisplay code will check this against the windows' timestamps,
1882 and redraw the appropriate area of the buffer.
1884 However, if the buffer is unmodified, we bump the last-save
1885 timestamp as well, so that incrementing the timestamp doesn't fool
1886 Emacs into thinking that the buffer's text has been modified.
1888 Tweaking the timestamps shouldn't hurt the first-modification
1889 timestamps recorded in the undo records; those values aren't
1890 written until just before a real text modification is made, so they
1891 will never catch the timestamp value just before this function gets
1895 redisplay_region (buf
, start
, end
)
1905 start
= end
; end
= temp
;
1908 /* If this is a buffer not in the selected window,
1909 we must do other windows. */
1910 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
1911 windows_or_buffers_changed
= 1;
1912 /* If it's not current, we can't use beg_unchanged, end_unchanged for it. */
1913 else if (buf
!= current_buffer
)
1914 windows_or_buffers_changed
= 1;
1915 /* If multiple windows show this buffer, we must do other windows. */
1916 else if (buffer_shared
> 1)
1917 windows_or_buffers_changed
= 1;
1920 if (unchanged_modified
== MODIFF
)
1922 beg_unchanged
= start
- BEG
;
1923 end_unchanged
= Z
- end
;
1927 if (Z
- end
< end_unchanged
)
1928 end_unchanged
= Z
- end
;
1929 if (start
- BEG
< beg_unchanged
)
1930 beg_unchanged
= start
- BEG
;
1934 /* Increment the buffer's time stamp, but also increment the save
1935 and autosave timestamps, so as not to screw up that timekeeping. */
1936 if (BUF_MODIFF (buf
) == buf
->save_modified
)
1937 buf
->save_modified
++;
1938 if (BUF_MODIFF (buf
) == buf
->auto_save_modified
)
1939 buf
->auto_save_modified
++;
1941 BUF_MODIFF (buf
) ++;
1945 /* Copy LEN glyphs starting address FROM to the rope TO.
1946 But don't actually copy the parts that would come in before S.
1947 Value is TO, advanced past the copied data.
1948 F is the frame we are displaying in. */
1951 copy_part_of_rope (f
, to
, s
, from
, len
, face
)
1953 register GLYPH
*to
; /* Copy to here. */
1954 register GLYPH
*s
; /* Starting point. */
1955 Lisp_Object
*from
; /* Data to copy. */
1957 int face
; /* Face to apply to glyphs which don't specify one. */
1960 register Lisp_Object
*fp
= from
;
1961 /* These cache the results of the last call to compute_glyph_face. */
1963 int last_merged
= 0;
1966 if (! FRAME_TERMCAP_P (f
))
1969 int glyph
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
1972 if (FAST_GLYPH_FACE (glyph
) == 0)
1973 /* If GLYPH has no face code, use FACE. */
1975 else if (FAST_GLYPH_FACE (glyph
) == last_code
)
1976 /* If it's same as previous glyph, use same result. */
1977 facecode
= last_merged
;
1980 /* Merge this glyph's face and remember the result. */
1981 last_code
= FAST_GLYPH_FACE (glyph
);
1982 last_merged
= facecode
= compute_glyph_face (f
, last_code
, face
);
1986 *to
= FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph
), facecode
);
1994 if (to
>= s
) *to
= (INTEGERP (*fp
) ? XFASTINT (*fp
) : 0);
2001 /* Correct a glyph by replacing its specified user-level face code
2002 with a displayable computed face code. */
2005 fix_glyph (f
, glyph
, cface
)
2011 if (! FRAME_TERMCAP_P (f
))
2013 if (FAST_GLYPH_FACE (glyph
) != 0)
2014 cface
= compute_glyph_face (f
, FAST_GLYPH_FACE (glyph
), cface
);
2015 glyph
= FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph
), cface
);
2021 /* Display one line of window W, starting at position START in W's buffer.
2023 Display starting at horizontal position HPOS, expressed relative to
2024 W's left edge. In situations where the text at START shouldn't
2025 start at the left margin (i.e. when the window is hscrolled, or
2026 we're continuing a line which left off in the midst of a
2027 multi-column character), HPOS should be negative; we throw away
2028 characters up 'til hpos = 0. So, HPOS must take hscrolling into
2031 TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
2033 Display on position VPOS on the frame. It is origin 0, relative to
2034 the top of the frame, not W.
2036 Returns a STRUCT POSITION giving character to start next line with
2037 and where to display it, including a zero or negative hpos.
2038 The vpos field is not really a vpos; it is 1 unless the line is continued */
2040 struct position val_display_text_line
;
2042 static struct position
*
2043 display_text_line (w
, start
, vpos
, hpos
, taboffset
)
2050 register int pos
= start
;
2055 register unsigned char *p
;
2057 register GLYPH
*leftmargin
;
2058 register GLYPH
*p1prev
= 0;
2059 register GLYPH
*p1start
;
2061 FRAME_PTR f
= XFRAME (w
->frame
);
2062 int tab_width
= XINT (current_buffer
->tab_width
);
2063 int ctl_arrow
= !NILP (current_buffer
->ctl_arrow
);
2064 int width
= window_internal_width (w
) - 1;
2065 struct position val
;
2068 int hscroll
= XINT (w
->hscroll
);
2069 int truncate
= (hscroll
2070 || (truncate_partial_width_windows
2071 && XFASTINT (w
->width
) < FRAME_WIDTH (f
))
2072 || !NILP (current_buffer
->truncate_lines
));
2074 /* 1 if we should highlight the region. */
2075 int highlight_region
2076 = !NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
);
2077 int region_beg
, region_end
;
2079 int selective
= (INTEGERP (current_buffer
->selective_display
)
2080 ? XINT (current_buffer
->selective_display
)
2081 : !NILP (current_buffer
->selective_display
) ? -1 : 0);
2082 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
2083 register struct Lisp_Vector
*dp
= window_display_table (w
);
2085 Lisp_Object default_invis_vector
[3];
2086 /* Nonzero means display something where there are invisible lines.
2087 The precise value is the number of glyphs to display. */
2089 = (selective
&& dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
2090 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->size
2091 : selective
&& !NILP (current_buffer
->selective_display_ellipses
)
2093 /* This is the sequence of Lisp objects to display
2094 when there are invisible lines. */
2095 Lisp_Object
*invis_vector_contents
2096 = (dp
&& VECTORP (DISP_INVIS_VECTOR (dp
))
2097 ? XVECTOR (DISP_INVIS_VECTOR (dp
))->contents
2098 : default_invis_vector
);
2100 GLYPH truncator
= (dp
== 0 || !INTEGERP (DISP_TRUNC_GLYPH (dp
))
2101 ? '$' : XINT (DISP_TRUNC_GLYPH (dp
)));
2102 GLYPH continuer
= (dp
== 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp
))
2103 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp
)));
2105 /* The next buffer location at which the face should change, due
2106 to overlays or text property changes. */
2107 int next_face_change
;
2109 #ifdef USE_TEXT_PROPERTIES
2110 /* The next location where the `invisible' property changes */
2114 /* The face we're currently using. */
2115 int current_face
= 0;
2118 XSETFASTINT (default_invis_vector
[2], '.');
2119 default_invis_vector
[0] = default_invis_vector
[1] = default_invis_vector
[2];
2121 hpos
+= XFASTINT (w
->left
);
2122 get_display_line (f
, vpos
, XFASTINT (w
->left
));
2123 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
2125 /* Show where to highlight the region. */
2126 if (highlight_region
&& XMARKER (current_buffer
->mark
)->buffer
!= 0
2127 /* Maybe highlight only in selected window. */
2128 && (highlight_nonselected_windows
2129 || w
== XWINDOW (selected_window
)))
2131 region_beg
= marker_position (current_buffer
->mark
);
2132 if (PT
< region_beg
)
2134 region_end
= region_beg
;
2139 w
->region_showing
= Qt
;
2142 region_beg
= region_end
= -1;
2144 if (MINI_WINDOW_P (w
)
2146 && vpos
== XFASTINT (w
->top
))
2148 if (! NILP (minibuf_prompt
))
2150 minibuf_prompt_width
2151 = (display_string (w
, vpos
, XSTRING (minibuf_prompt
)->data
,
2152 XSTRING (minibuf_prompt
)->size
, hpos
,
2153 /* Display a space if we truncate. */
2156 /* Truncate the prompt a little before the
2157 margin, so user input can at least start
2158 on the first line. */
2159 w
->width
> 10 ? w
->width
- 4 : -1)
2161 hpos
+= minibuf_prompt_width
;
2164 minibuf_prompt_width
= 0;
2169 /* If we're hscrolled at all, use compute_motion to skip over any
2170 text off the left edge of the window. compute_motion may know
2171 tricks to do this faster than we can. */
2174 struct position
*left_edge
2175 = compute_motion (pos
, vpos
, hpos
,
2177 width
, hscroll
, taboffset
, w
);
2179 /* Retrieve the buffer position and column provided by
2180 compute_motion. We can't assume that the column will be
2181 zero, because you may have multi-column characters crossing
2184 compute_motion may have moved us past the screen position we
2185 requested, if we hit a multi-column character, or the end of
2186 the line. If so, back up. */
2187 if (left_edge
->vpos
> vpos
2188 || left_edge
->hpos
> 0)
2190 pos
= left_edge
->bufpos
- 1;
2191 hpos
= left_edge
->prevhpos
;
2195 pos
= left_edge
->bufpos
;
2196 hpos
= left_edge
->hpos
;
2200 desired_glyphs
->bufp
[vpos
] = start
;
2201 p1
= desired_glyphs
->glyphs
[vpos
] + hpos
;
2203 charstart
= desired_glyphs
->charstarts
[vpos
] + hpos
;
2204 /* In case we don't ever write anything into it... */
2205 desired_glyphs
->charstarts
[vpos
][XFASTINT (w
->left
)] = -1;
2206 leftmargin
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
2207 endp
= leftmargin
+ width
;
2209 /* Arrange the overlays nicely for our purposes. Usually, we call
2210 display_text_line on only one line at a time, in which case this
2211 can't really hurt too much, or we call it on lines which appear
2212 one after another in the buffer, in which case all calls to
2213 recenter_overlay_lists but the first will be pretty cheap. */
2214 recenter_overlay_lists (current_buffer
, pos
);
2216 /* Loop generating characters.
2217 Stop at end of buffer, before newline,
2218 if reach or pass continuation column,
2219 or at face change. */
2221 next_face_change
= pos
;
2222 #ifdef USE_TEXT_PROPERTIES
2223 next_invisible
= pos
;
2227 /* Record which glyph starts a character,
2228 and the character position of that character. */
2229 if (p1
>= leftmargin
)
2230 charstart
[p1
- p1start
] = pos
;
2238 /* Did we hit the end of the visible region of the buffer?
2243 /* Did we reach point? Record the cursor location. */
2244 if (pos
== PT
&& cursor_vpos
< 0)
2247 cursor_hpos
= p1
- leftmargin
;
2250 #ifdef USE_TEXT_PROPERTIES
2251 /* if the `invisible' property is set to t, we can skip to
2252 the next property change */
2253 while (pos
== next_invisible
&& pos
< end
)
2255 Lisp_Object position
, limit
, endpos
, prop
, ww
;
2256 XSETFASTINT (position
, pos
);
2258 prop
= Fget_char_property (position
, Qinvisible
, ww
);
2259 /* This is just an estimate to give reasonable
2260 performance; nothing should go wrong if it is too small. */
2261 limit
= Fnext_overlay_change (position
);
2262 if (XFASTINT (limit
) > pos
+ 50)
2263 XSETFASTINT (limit
, pos
+ 50);
2264 endpos
= Fnext_single_property_change (position
, Qinvisible
,
2265 Fcurrent_buffer (), limit
);
2266 if (INTEGERP (endpos
))
2267 next_invisible
= XINT (endpos
);
2269 next_invisible
= end
;
2272 if (pos
< PT
&& next_invisible
>= PT
)
2275 cursor_hpos
= p1
- leftmargin
;
2277 pos
= next_invisible
;
2285 /* Did we hit a face change? Figure out what face we should
2286 use now. We also hit this the first time through the
2287 loop, to see what face we should start with. */
2288 if (pos
>= next_face_change
&& FRAME_X_P (f
))
2289 current_face
= compute_char_face (f
, w
, pos
,
2290 region_beg
, region_end
,
2291 &next_face_change
, pos
+ 50, 0);
2296 #ifdef USE_TEXT_PROPERTIES
2297 if (pos
< next_invisible
&& next_invisible
< pause
)
2298 pause
= next_invisible
;
2300 if (pos
< next_face_change
&& next_face_change
< pause
)
2301 pause
= next_face_change
;
2303 /* Wouldn't you hate to read the next line to someone over
2305 if (pos
< PT
&& PT
< pause
)
2307 if (pos
< GPT
&& GPT
< pause
)
2310 p
= &FETCH_CHAR (pos
);
2313 if (c
>= 040 && c
< 0177
2314 && (dp
== 0 || !VECTORP (DISP_CHAR_VECTOR (dp
, c
))))
2316 if (p1
>= leftmargin
)
2317 *p1
= MAKE_GLYPH (f
, c
, current_face
);
2323 while (pos
+ 1 < end
2325 && indented_beyond_p (pos
+ 1, selective
))
2328 pos
= find_next_newline (pos
+ 1, 1);
2329 if (FETCH_CHAR (pos
- 1) == '\n')
2332 if (invis
&& selective_rlen
> 0 && p1
>= leftmargin
)
2334 p1
+= selective_rlen
;
2335 if (p1
- leftmargin
> width
)
2337 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
2338 (p1
- p1prev
), current_face
);
2341 /* Draw the face of the newline character as extending all the
2342 way to the end of the frame line. */
2345 if (p1
< leftmargin
)
2348 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
);
2357 if (p1
>= leftmargin
&& p1
< endp
)
2358 *p1
= MAKE_GLYPH (f
, ' ', current_face
);
2361 while ((p1
- leftmargin
+ taboffset
+ hscroll
- (hscroll
> 0))
2364 else if (c
== Ctl ('M') && selective
== -1)
2366 pos
= find_next_newline (pos
, 1);
2367 if (FETCH_CHAR (pos
- 1) == '\n')
2369 if (selective_rlen
> 0)
2371 p1
+= selective_rlen
;
2372 if (p1
- leftmargin
> width
)
2374 copy_part_of_rope (f
, p1prev
, p1prev
, invis_vector_contents
,
2375 (p1
- p1prev
), current_face
);
2378 /* Draw the face of the newline character as extending all the
2379 way to the end of the frame line. */
2382 if (p1
< leftmargin
)
2385 *p1
++ = FAST_MAKE_GLYPH (' ', current_face
);
2390 else if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
2392 p1
= copy_part_of_rope (f
, p1
, leftmargin
,
2393 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
2394 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
2397 else if (c
< 0200 && ctl_arrow
)
2399 if (p1
>= leftmargin
)
2400 *p1
= fix_glyph (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
2401 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
2404 if (p1
>= leftmargin
&& p1
< endp
)
2405 *p1
= MAKE_GLYPH (f
, c
^ 0100, current_face
);
2410 if (p1
>= leftmargin
)
2411 *p1
= fix_glyph (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
2412 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
2415 if (p1
>= leftmargin
&& p1
< endp
)
2416 *p1
= MAKE_GLYPH (f
, (c
>> 6) + '0', current_face
);
2418 if (p1
>= leftmargin
&& p1
< endp
)
2419 *p1
= MAKE_GLYPH (f
, (7 & (c
>> 3)) + '0', current_face
);
2421 if (p1
>= leftmargin
&& p1
< endp
)
2422 *p1
= MAKE_GLYPH (f
, (7 & c
) + '0', current_face
);
2426 /* Do nothing here for a char that's entirely off the left edge. */
2427 if (p1
>= leftmargin
)
2429 /* For all the glyphs occupied by this character, except for the
2430 first, store -1 in charstarts. */
2433 int *p2x
= &charstart
[p1prev
- p1start
];
2434 int *p2
= &charstart
[(p1
< endp
? p1
: endp
) - p1start
];
2436 /* The window's left column should always
2437 contain a character position.
2438 And don't clobber anything to the left of that. */
2439 if (p1prev
< leftmargin
)
2441 p2x
= charstart
+ (leftmargin
- p1start
);
2445 /* This loop skips over the char p2x initially points to. */
2454 val
.hpos
= - XINT (w
->hscroll
);
2462 /* Store 0 in this charstart line for the positions where
2463 there is no character. But do leave what was recorded
2464 for the character that ended the line. */
2465 /* Add 1 in the endtest to compensate for the fact that ENDP was
2466 made from WIDTH, which is 1 less than the window's actual
2468 i
= p1
- p1start
+ 1;
2469 if (p1
< leftmargin
)
2470 i
+= leftmargin
- p1
;
2471 for (; i
< endp
- p1start
+ 1; i
++)
2474 /* Handle continuation in middle of a character */
2475 /* by backing up over it */
2478 /* Don't back up if we never actually displayed any text.
2479 This occurs when the minibuffer prompt takes up the whole line. */
2482 /* Start the next line with that same character */
2484 /* but at negative hpos, to skip the columns output on this line. */
2485 val
.hpos
+= p1prev
- endp
;
2488 /* Keep in this line everything up to the continuation column. */
2492 /* Finish deciding which character to start the next line on,
2493 and what hpos to start it at.
2494 Also set `lastpos' to the last position which counts as "on this line"
2495 for cursor-positioning. */
2499 if (FETCH_CHAR (pos
) == '\n')
2501 /* If stopped due to a newline, start next line after it */
2503 /* Check again for hidden lines, in case the newline occurred exactly
2504 at the right margin. */
2505 while (pos
< ZV
&& selective
> 0
2506 && indented_beyond_p (pos
, selective
))
2507 pos
= find_next_newline (pos
, 1);
2510 /* Stopped due to right margin of window */
2514 *p1
++ = fix_glyph (f
, truncator
, 0);
2515 /* Truncating => start next line after next newline,
2516 and point is on this line if it is before the newline,
2517 and skip none of first char of next line */
2519 pos
= find_next_newline (pos
, 1);
2520 while (pos
< ZV
&& selective
> 0
2521 && indented_beyond_p (pos
, selective
));
2522 val
.hpos
= XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0;
2524 lastpos
= pos
- (FETCH_CHAR (pos
- 1) == '\n');
2528 *p1
++ = fix_glyph (f
, continuer
, 0);
2535 /* If point is at eol or in invisible text at eol,
2536 record its frame location now. */
2538 if (start
<= PT
&& PT
<= lastpos
&& cursor_vpos
< 0)
2541 cursor_hpos
= p1
- leftmargin
;
2544 if (cursor_vpos
== vpos
)
2546 if (cursor_hpos
< 0) cursor_hpos
= 0;
2547 if (cursor_hpos
> width
) cursor_hpos
= width
;
2548 cursor_hpos
+= XFASTINT (w
->left
);
2549 if (w
== XWINDOW (FRAME_SELECTED_WINDOW (f
)))
2551 FRAME_CURSOR_Y (f
) = cursor_vpos
;
2552 FRAME_CURSOR_X (f
) = cursor_hpos
;
2554 if (w
== XWINDOW (selected_window
))
2556 /* Line is not continued and did not start
2557 in middle of character */
2558 if ((hpos
- XFASTINT (w
->left
)
2559 == (XINT (w
->hscroll
) ? 1 - XINT (w
->hscroll
) : 0))
2562 this_line_bufpos
= start
;
2563 this_line_buffer
= current_buffer
;
2564 this_line_vpos
= cursor_vpos
;
2565 this_line_start_hpos
= hpos
;
2566 this_line_endpos
= Z
- lastpos
;
2569 this_line_bufpos
= 0;
2574 /* If hscroll and line not empty, insert truncation-at-left marker */
2575 if (hscroll
&& lastpos
!= start
)
2577 *leftmargin
= fix_glyph (f
, truncator
, 0);
2578 if (p1
<= leftmargin
)
2579 p1
= leftmargin
+ 1;
2582 if (XFASTINT (w
->width
) + XFASTINT (w
->left
) != FRAME_WIDTH (f
))
2585 if (p1
< leftmargin
) p1
= leftmargin
;
2586 while (p1
< endp
) *p1
++ = SPACEGLYPH
;
2588 /* Don't draw vertical bars if we're using scroll bars. They're
2589 covered up by the scroll bars, and it's distracting to see
2590 them when the scroll bar windows are flickering around to be
2592 *p1
++ = (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
2594 : (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2595 ? DISP_BORDER_GLYPH (dp
)
2598 desired_glyphs
->used
[vpos
] = max (desired_glyphs
->used
[vpos
],
2599 p1
- desired_glyphs
->glyphs
[vpos
]);
2600 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
2602 /* If the start of this line is the overlay arrow-position,
2603 then put the arrow string into the display-line. */
2605 if (MARKERP (Voverlay_arrow_position
)
2606 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
2607 && start
== marker_position (Voverlay_arrow_position
)
2608 && STRINGP (Voverlay_arrow_string
)
2609 && ! overlay_arrow_seen
)
2611 unsigned char *p
= XSTRING (Voverlay_arrow_string
)->data
;
2613 int len
= XSTRING (Voverlay_arrow_string
)->size
;
2619 if (!NULL_INTERVAL_P (XSTRING (Voverlay_arrow_string
)->intervals
))
2621 /* If the arrow string has text props, obey them when displaying. */
2622 for (i
= 0; i
< len
; i
++)
2625 Lisp_Object face
, ilisp
;
2628 XSETFASTINT (ilisp
, i
);
2629 face
= Fget_text_property (ilisp
, Qface
, Voverlay_arrow_string
);
2630 newface
= compute_glyph_face_1 (f
, face
, 0);
2631 leftmargin
[i
] = FAST_MAKE_GLYPH (c
, newface
);
2635 #endif /* HAVE_FACES */
2637 for (i
= 0; i
< len
; i
++)
2638 leftmargin
[i
] = p
[i
];
2641 /* Bug in SunOS 4.1.1 compiler requires this intermediate variable. */
2642 arrow_end
= (leftmargin
- desired_glyphs
->glyphs
[vpos
]) + len
;
2643 if (desired_glyphs
->used
[vpos
] < arrow_end
)
2644 desired_glyphs
->used
[vpos
] = arrow_end
;
2646 overlay_arrow_seen
= 1;
2650 val_display_text_line
= val
;
2651 return &val_display_text_line
;
2654 /* Redisplay the menu bar in the frame for window W. */
2657 display_menu_bar (w
)
2660 Lisp_Object items
, tail
;
2661 register int vpos
= 0;
2662 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2663 int maxendcol
= FRAME_WIDTH (f
);
2667 #ifndef USE_X_TOOLKIT
2668 if (FRAME_MENU_BAR_LINES (f
) <= 0)
2671 get_display_line (f
, vpos
, 0);
2673 items
= FRAME_MENU_BAR_ITEMS (f
);
2674 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 3)
2676 Lisp_Object pos
, string
;
2677 string
= XVECTOR (items
)->contents
[i
+ 1];
2681 XSETFASTINT (XVECTOR (items
)->contents
[i
+ 2], hpos
);
2683 if (hpos
< maxendcol
)
2684 hpos
= display_string (XWINDOW (FRAME_ROOT_WINDOW (f
)), vpos
,
2685 XSTRING (string
)->data
,
2686 XSTRING (string
)->size
,
2687 hpos
, 0, 0, hpos
, maxendcol
);
2688 /* Put a gap of 3 spaces between items. */
2689 if (hpos
< maxendcol
)
2691 int hpos1
= hpos
+ 3;
2692 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0,
2693 min (hpos1
, maxendcol
), maxendcol
);
2697 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2698 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2700 /* Fill out the line with spaces. */
2701 if (maxendcol
> hpos
)
2702 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 0, maxendcol
, maxendcol
);
2704 /* Clear the rest of the lines allocated to the menu bar. */
2706 while (vpos
< FRAME_MENU_BAR_LINES (f
))
2707 get_display_line (f
, vpos
++, 0);
2708 #endif /* not USE_X_TOOLKIT */
2711 /* Display the mode line for window w */
2714 display_mode_line (w
)
2717 register int vpos
= XFASTINT (w
->height
) + XFASTINT (w
->top
) - 1;
2718 register int left
= XFASTINT (w
->left
);
2719 register int right
= XFASTINT (w
->width
) + left
;
2720 register FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2722 line_number_displayed
= 0;
2723 column_number_displayed
= 0;
2725 get_display_line (f
, vpos
, left
);
2726 display_mode_element (w
, vpos
, left
, 0, right
, right
,
2727 current_buffer
->mode_line_format
);
2728 FRAME_DESIRED_GLYPHS (f
)->bufp
[vpos
] = 0;
2730 /* Make the mode line inverse video if the entire line
2731 is made of mode lines.
2732 I.e. if this window is full width,
2733 or if it is the child of a full width window
2734 (which implies that that window is split side-by-side
2735 and the rest of this line is mode lines of the sibling windows). */
2736 if (XFASTINT (w
->width
) == FRAME_WIDTH (f
)
2737 || XFASTINT (XWINDOW (w
->parent
)->width
) == FRAME_WIDTH (f
))
2738 FRAME_DESIRED_GLYPHS (f
)->highlight
[vpos
] = mode_line_inverse_video
;
2740 else if (! FRAME_TERMCAP_P (f
))
2742 /* For a partial width window, explicitly set face of each glyph. */
2744 GLYPH
*ptr
= FRAME_DESIRED_GLYPHS (f
)->glyphs
[vpos
];
2745 for (i
= left
; i
< right
; ++i
)
2746 ptr
[i
] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr
[i
]), 1);
2751 /* Contribute ELT to the mode line for window W.
2752 How it translates into text depends on its data type.
2754 VPOS is the position of the mode line being displayed.
2756 HPOS is the position (absolute on frame) where this element's text
2757 should start. The output is truncated automatically at the right
2760 DEPTH is the depth in recursion. It is used to prevent
2761 infinite recursion here.
2763 MINENDCOL is the hpos before which the element may not end.
2764 The element is padded at the right with spaces if nec
2765 to reach this column.
2767 MAXENDCOL is the hpos past which this element may not extend.
2768 If MINENDCOL is > MAXENDCOL, MINENDCOL takes priority.
2769 (This is necessary to make nested padding and truncation work.)
2771 Returns the hpos of the end of the text generated by ELT.
2772 The next element will receive that value as its HPOS arg,
2773 so as to concatenate the elements. */
2776 display_mode_element (w
, vpos
, hpos
, depth
, minendcol
, maxendcol
, elt
)
2778 register int vpos
, hpos
;
2781 register int maxendcol
;
2782 register Lisp_Object elt
;
2790 #ifdef SWITCH_ENUM_BUG
2791 switch ((int) XTYPE (elt
))
2793 switch (XTYPE (elt
))
2798 /* A string: output it and check for %-constructs within it. */
2799 register unsigned char c
;
2800 register unsigned char *this = XSTRING (elt
)->data
;
2802 while (hpos
< maxendcol
&& *this)
2804 unsigned char *last
= this;
2805 while ((c
= *this++) != '\0' && c
!= '%')
2807 if (this - 1 != last
)
2809 register int lim
= --this - last
+ hpos
;
2810 if (frame_title_ptr
)
2811 hpos
= store_frame_title (last
, hpos
, min (lim
, maxendcol
));
2813 hpos
= display_string (w
, vpos
, last
, -1, hpos
, 0, 1,
2814 hpos
, min (lim
, maxendcol
));
2818 register int spec_width
= 0;
2820 /* We can't allow -ve args due to the "%-" construct */
2821 /* Argument specifies minwidth but not maxwidth
2822 (maxwidth can be specified by
2823 (<negative-number> . <stuff>) mode-line elements) */
2825 while ((c
= *this++) >= '0' && c
<= '9')
2827 spec_width
= spec_width
* 10 + (c
- '0');
2831 if (spec_width
> maxendcol
)
2832 spec_width
= maxendcol
;
2835 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2836 spec_width
, maxendcol
,
2837 Vglobal_mode_string
);
2840 char *spec
= decode_mode_spec (w
, c
, maxendcol
- hpos
);
2841 if (frame_title_ptr
)
2842 hpos
= store_frame_title (spec
, spec_width
, maxendcol
);
2844 hpos
= display_string (w
, vpos
, spec
, -1,
2846 spec_width
, maxendcol
);
2854 /* A symbol: process the value of the symbol recursively
2855 as if it appeared here directly. Avoid error if symbol void.
2856 Special case: if value of symbol is a string, output the string
2859 register Lisp_Object tem
;
2860 tem
= Fboundp (elt
);
2863 tem
= Fsymbol_value (elt
);
2864 /* If value is a string, output that string literally:
2865 don't check for % within it. */
2868 if (frame_title_ptr
)
2869 hpos
= store_frame_title (XSTRING (tem
)->data
,
2870 minendcol
, maxendcol
);
2872 hpos
= display_string (w
, vpos
, XSTRING (tem
)->data
,
2873 XSTRING (tem
)->size
,
2874 hpos
, 0, 1, minendcol
, maxendcol
);
2876 /* Give up right away for nil or t. */
2877 else if (!EQ (tem
, elt
))
2878 { elt
= tem
; goto tail_recurse
; }
2885 register Lisp_Object car
, tem
;
2887 /* A cons cell: three distinct cases.
2888 If first element is a string or a cons, process all the elements
2889 and effectively concatenate them.
2890 If first element is a negative number, truncate displaying cdr to
2891 at most that many characters. If positive, pad (with spaces)
2892 to at least that many characters.
2893 If first element is a symbol, process the cadr or caddr recursively
2894 according to whether the symbol's value is non-nil or nil. */
2895 car
= XCONS (elt
)->car
;
2898 tem
= Fboundp (car
);
2899 elt
= XCONS (elt
)->cdr
;
2902 /* elt is now the cdr, and we know it is a cons cell.
2903 Use its car if CAR has a non-nil value. */
2906 tem
= Fsymbol_value (car
);
2908 { elt
= XCONS (elt
)->car
; goto tail_recurse
; }
2910 /* Symbol's value is nil (or symbol is unbound)
2911 Get the cddr of the original list
2912 and if possible find the caddr and use that. */
2913 elt
= XCONS (elt
)->cdr
;
2916 else if (!CONSP (elt
))
2918 elt
= XCONS (elt
)->car
;
2921 else if (INTEGERP (car
))
2923 register int lim
= XINT (car
);
2924 elt
= XCONS (elt
)->cdr
;
2926 /* Negative int means reduce maximum width.
2927 DO NOT change MINENDCOL here!
2928 (20 -10 . foo) should truncate foo to 10 col
2929 and then pad to 20. */
2930 maxendcol
= min (maxendcol
, hpos
- lim
);
2933 /* Padding specified. Don't let it be more than
2936 if (lim
> maxendcol
)
2938 /* If that's more padding than already wanted, queue it.
2939 But don't reduce padding already specified even if
2940 that is beyond the current truncation point. */
2941 if (lim
> minendcol
)
2946 else if (STRINGP (car
) || CONSP (car
))
2948 register int limit
= 50;
2949 /* LIMIT is to protect against circular lists. */
2950 while (CONSP (elt
) && --limit
> 0
2951 && hpos
< maxendcol
)
2953 hpos
= display_mode_element (w
, vpos
, hpos
, depth
,
2956 elt
= XCONS (elt
)->cdr
;
2964 if (frame_title_ptr
)
2965 hpos
= store_frame_title ("*invalid*", minendcol
, maxendcol
);
2967 hpos
= display_string (w
, vpos
, "*invalid*", -1, hpos
, 0, 1,
2968 minendcol
, maxendcol
);
2972 if (minendcol
> hpos
)
2973 if (frame_title_ptr
)
2974 hpos
= store_frame_title ("", minendcol
, maxendcol
);
2976 hpos
= display_string (w
, vpos
, "", 0, hpos
, 0, 1, minendcol
, maxendcol
);
2980 /* Return a string for the output of a mode line %-spec for window W,
2981 generated by character C and width MAXWIDTH. */
2983 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
2986 decode_mode_spec (w
, c
, maxwidth
)
2989 register int maxwidth
;
2992 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
2993 char *decode_mode_spec_buf
= (char *) FRAME_TEMP_GLYPHS (f
)->total_contents
;
2994 struct buffer
*b
= XBUFFER (w
->buffer
);
2997 if (maxwidth
> FRAME_WIDTH (f
))
2998 maxwidth
= FRAME_WIDTH (f
);
3005 if (maxwidth
>= 3 && XSTRING (obj
)->size
> maxwidth
)
3007 bcopy (XSTRING (obj
)->data
, decode_mode_spec_buf
, maxwidth
- 1);
3008 decode_mode_spec_buf
[maxwidth
- 1] = '\\';
3009 decode_mode_spec_buf
[maxwidth
] = '\0';
3010 return decode_mode_spec_buf
;
3020 else if (STRINGP (obj
) && XSTRING (obj
)->size
> maxwidth
)
3022 bcopy ("...", decode_mode_spec_buf
, 3);
3023 bcopy (XSTRING (obj
)->data
+ XSTRING (obj
)->size
- maxwidth
+ 3,
3024 decode_mode_spec_buf
+ 3, maxwidth
- 3);
3025 return decode_mode_spec_buf
;
3031 column_number_displayed
= 1;
3032 sprintf (decode_mode_spec_buf
, "%d", current_column ());
3033 return decode_mode_spec_buf
;
3037 int startpos
= marker_position (w
->start
);
3038 int line
, linepos
, topline
;
3041 int height
= XFASTINT (w
->height
);
3043 /* If we decided that this buffer isn't suitable for line numbers,
3044 don't forget that too fast. */
3045 if (EQ (w
->base_line_pos
, w
->buffer
))
3048 /* If the buffer is very big, don't waste time. */
3049 if (BUF_ZV (b
) - BUF_BEGV (b
) > line_number_display_limit
)
3051 w
->base_line_pos
= Qnil
;
3052 w
->base_line_number
= Qnil
;
3056 if (!NILP (w
->base_line_number
)
3057 && !NILP (w
->base_line_pos
)
3058 && XFASTINT (w
->base_line_pos
) <= marker_position (w
->start
))
3060 line
= XFASTINT (w
->base_line_number
);
3061 linepos
= XFASTINT (w
->base_line_pos
);
3066 linepos
= BUF_BEGV (b
);
3069 /* Count lines from base line to window start position. */
3070 nlines
= display_count_lines (linepos
, startpos
, startpos
, &junk
);
3072 topline
= nlines
+ line
;
3074 /* Determine a new base line, if the old one is too close
3075 or too far away, or if we did not have one.
3076 "Too close" means it's plausible a scroll-down would
3078 if (startpos
== BUF_BEGV (b
))
3080 XSETFASTINT (w
->base_line_number
, topline
);
3081 XSETFASTINT (w
->base_line_pos
, BUF_BEGV (b
));
3083 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
3084 || linepos
== BUF_BEGV (b
))
3086 int limit
= BUF_BEGV (b
);
3088 int distance
= (height
* 2 + 30) * 200;
3090 if (startpos
- distance
> limit
)
3091 limit
= startpos
- distance
;
3093 nlines
= display_count_lines (startpos
, limit
,
3096 /* If we couldn't find the lines we wanted within
3098 give up on line numbers for this window. */
3099 if (position
== startpos
- distance
)
3101 w
->base_line_pos
= w
->buffer
;
3102 w
->base_line_number
= Qnil
;
3106 XSETFASTINT (w
->base_line_number
, topline
- nlines
);
3107 XSETFASTINT (w
->base_line_pos
, position
);
3110 /* Now count lines from the start pos to point. */
3111 nlines
= display_count_lines (startpos
, PT
, PT
, &junk
);
3113 /* Record that we did display the line number. */
3114 line_number_displayed
= 1;
3116 /* Make the string to show. */
3117 sprintf (decode_mode_spec_buf
, "%d", topline
+ nlines
);
3118 return decode_mode_spec_buf
;
3127 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
3132 if (!NILP (b
->read_only
))
3134 if (BUF_MODIFF (b
) > b
->save_modified
)
3139 /* This differs from %* only for a modified read-only buffer. */
3140 if (BUF_MODIFF (b
) > b
->save_modified
)
3142 if (!NILP (b
->read_only
))
3147 /* This differs from %* in ignoring read-only-ness. */
3148 if (BUF_MODIFF (b
) > b
->save_modified
)
3153 /* status of process */
3154 obj
= Fget_buffer_process (w
->buffer
);
3156 return "no process";
3158 obj
= Fsymbol_name (Fprocess_status (obj
));
3162 case 't': /* indicate TEXT or BINARY */
3163 #ifdef MODE_LINE_BINARY_TEXT
3164 return MODE_LINE_BINARY_TEXT (b
);
3171 int pos
= marker_position (w
->start
);
3172 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
3174 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
3176 if (pos
<= BUF_BEGV (b
))
3181 else if (pos
<= BUF_BEGV (b
))
3185 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
3186 /* We can't normally display a 3-digit number,
3187 so get us a 2-digit number that is close. */
3190 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
3191 return decode_mode_spec_buf
;
3195 /* Display percentage of size above the bottom of the screen. */
3198 int toppos
= marker_position (w
->start
);
3199 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
3200 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
3202 if (botpos
>= BUF_ZV (b
))
3204 if (toppos
<= BUF_BEGV (b
))
3211 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
3212 /* We can't normally display a 3-digit number,
3213 so get us a 2-digit number that is close. */
3216 if (toppos
<= BUF_BEGV (b
))
3217 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
3219 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
3220 return decode_mode_spec_buf
;
3232 if (command_loop_level
> 5)
3234 p
= decode_mode_spec_buf
;
3235 for (i
= 0; i
< command_loop_level
; i
++)
3238 return decode_mode_spec_buf
;
3246 if (command_loop_level
> 5)
3248 p
= decode_mode_spec_buf
;
3249 for (i
= 0; i
< command_loop_level
; i
++)
3252 return decode_mode_spec_buf
;
3260 if (maxwidth
< sizeof (lots_of_dashes
))
3261 return lots_of_dashes
;
3264 for (p
= decode_mode_spec_buf
, i
= maxwidth
; i
> 0; i
--)
3268 return decode_mode_spec_buf
;
3273 return (char *) XSTRING (obj
)->data
;
3278 /* Search for COUNT instances of a line boundary, which means either a
3279 newline or (if selective display enabled) a carriage return.
3280 Start at START. If COUNT is negative, search backwards.
3282 If we find COUNT instances, set *SHORTAGE to zero, and return the
3283 position after the COUNTth match. Note that for reverse motion
3284 this is not the same as the usual convention for Emacs motion commands.
3286 If we don't find COUNT instances before reaching the end of the
3287 buffer (or the beginning, if scanning backwards), set *SHORTAGE to
3288 the number of line boundaries left unfound, and return the end of the
3289 buffer we bumped up against. */
3292 display_scan_buffer (start
, count
, shortage
)
3293 int *shortage
, start
;
3296 int limit
= ((count
> 0) ? ZV
- 1 : BEGV
);
3297 int direction
= ((count
> 0) ? 1 : -1);
3299 register unsigned char *cursor
;
3300 unsigned char *base
;
3302 register int ceiling
;
3303 register unsigned char *ceiling_addr
;
3305 /* If we are not in selective display mode,
3306 check only for newlines. */
3307 if (! (!NILP (current_buffer
->selective_display
)
3308 && !INTEGERP (current_buffer
->selective_display
)))
3309 return scan_buffer ('\n', start
, 0, count
, shortage
, 0);
3311 /* The code that follows is like scan_buffer
3312 but checks for either newline or carriage return. */
3318 while (start
!= limit
+ 1)
3320 ceiling
= BUFFER_CEILING_OF (start
);
3321 ceiling
= min (limit
, ceiling
);
3322 ceiling_addr
= &FETCH_CHAR (ceiling
) + 1;
3323 base
= (cursor
= &FETCH_CHAR (start
));
3326 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
3328 if (cursor
!= ceiling_addr
)
3333 return (start
+ cursor
- base
+ 1);
3336 if (++cursor
== ceiling_addr
)
3342 start
+= cursor
- base
;
3346 start
--; /* first character we scan */
3347 while (start
> limit
- 1)
3348 { /* we WILL scan under start */
3349 ceiling
= BUFFER_FLOOR_OF (start
);
3350 ceiling
= max (limit
, ceiling
);
3351 ceiling_addr
= &FETCH_CHAR (ceiling
) - 1;
3352 base
= (cursor
= &FETCH_CHAR (start
));
3356 while (--cursor
!= ceiling_addr
3357 && *cursor
!= '\n' && *cursor
!= 015)
3359 if (cursor
!= ceiling_addr
)
3364 return (start
+ cursor
- base
+ 1);
3370 start
+= cursor
- base
;
3375 *shortage
= count
* direction
;
3376 return (start
+ ((direction
== 1 ? 0 : 1)));
3379 /* Count up to N lines starting from FROM.
3380 But don't go beyond LIMIT.
3381 Return the number of lines thus found (always positive).
3382 Store the position after what was found into *POS_PTR. */
3385 display_count_lines (from
, limit
, n
, pos_ptr
)
3398 *pos_ptr
= display_scan_buffer (from
, n
, &shortage
);
3404 /* When scanning backwards, scan_buffer stops *after* the last newline
3405 it finds, but does count it. Compensate for that. */
3406 return - n
- shortage
- (*pos_ptr
!= limit
);
3407 return n
- shortage
;
3410 /* Display STRING on one line of window W, starting at HPOS.
3411 Display at position VPOS. Caller should have done get_display_line.
3412 If VPOS == -1, display it as the current frame's title.
3413 LENGTH is the length of STRING, or -1 meaning STRING is null-terminated.
3415 TRUNCATE is GLYPH to display at end if truncated. Zero for none.
3417 MINCOL is the first column ok to end at. (Pad with spaces to this col.)
3418 MAXCOL is the last column ok to end at. Truncate here.
3419 -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
3420 Both count from the left edge of the frame, as does HPOS.
3421 The right edge of W is an implicit maximum.
3422 If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
3424 OBEY_WINDOW_WIDTH says to put spaces or vertical bars
3425 at the place where the current window ends in this line
3426 and not display anything beyond there. Otherwise, only MAXCOL
3427 controls where to stop output.
3429 Returns ending hpos. */
3432 display_string (w
, vpos
, string
, length
, hpos
, truncate
,
3433 obey_window_width
, mincol
, maxcol
)
3435 unsigned char *string
;
3439 int obey_window_width
;
3444 int hscroll
= XINT (w
->hscroll
);
3445 int tab_width
= XINT (XBUFFER (w
->buffer
)->tab_width
);
3446 register GLYPH
*start
;
3447 register GLYPH
*end
;
3448 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
3449 struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (f
);
3450 GLYPH
*p1start
= desired_glyphs
->glyphs
[vpos
] + hpos
;
3451 int window_width
= XFASTINT (w
->width
);
3453 /* Use the standard display table, not the window's display table.
3454 We don't want the mode line in rot13. */
3455 register struct Lisp_Vector
*dp
= 0;
3458 if (VECTORP (Vstandard_display_table
)
3459 && XVECTOR (Vstandard_display_table
)->size
== DISP_TABLE_SIZE
)
3460 dp
= XVECTOR (Vstandard_display_table
);
3462 if (tab_width
<= 0 || tab_width
> 1000) tab_width
= 8;
3465 start
= desired_glyphs
->glyphs
[vpos
] + XFASTINT (w
->left
);
3467 if (obey_window_width
)
3469 end
= start
+ window_width
- (truncate
!= 0);
3471 if ((window_width
+ XFASTINT (w
->left
)) != FRAME_WIDTH (f
))
3473 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3477 for (i
= 0; i
< FRAME_SCROLL_BAR_COLS (f
); i
++)
3485 if (! obey_window_width
3486 || (maxcol
>= 0 && end
- desired_glyphs
->glyphs
[vpos
] > maxcol
))
3487 end
= desired_glyphs
->glyphs
[vpos
] + maxcol
;
3489 /* Store 0 in charstart for these columns. */
3490 for (i
= (hpos
>= 0 ? hpos
: 0); i
< end
- p1start
+ hpos
; i
++)
3491 desired_glyphs
->charstarts
[vpos
][i
] = 0;
3493 if (maxcol
>= 0 && mincol
> maxcol
)
3501 /* Specified length. */
3504 /* Unspecified length (null-terminated string). */
3508 if (c
>= 040 && c
< 0177
3509 && (dp
== 0 || !VECTORP (DISP_CHAR_VECTOR (dp
, c
))))
3519 if (p1
>= start
&& p1
< end
)
3523 while ((p1
- start
+ hscroll
- (hscroll
> 0)) % tab_width
);
3525 else if (dp
!= 0 && VECTORP (DISP_CHAR_VECTOR (dp
, c
)))
3527 p1
= copy_part_of_rope (f
, p1
, start
,
3528 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->contents
,
3529 XVECTOR (DISP_CHAR_VECTOR (dp
, c
))->size
,
3532 else if (c
< 0200 && ! NILP (buffer_defaults
.ctl_arrow
))
3535 *p1
= fix_glyph (f
, (dp
&& INTEGERP (DISP_CTRL_GLYPH (dp
))
3536 ? XINT (DISP_CTRL_GLYPH (dp
)) : '^'),
3539 if (p1
>= start
&& p1
< end
)
3546 *p1
= fix_glyph (f
, (dp
&& INTEGERP (DISP_ESCAPE_GLYPH (dp
))
3547 ? XINT (DISP_ESCAPE_GLYPH (dp
)) : '\\'),
3550 if (p1
>= start
&& p1
< end
)
3551 *p1
= (c
>> 6) + '0';
3553 if (p1
>= start
&& p1
< end
)
3554 *p1
= (7 & (c
>> 3)) + '0';
3556 if (p1
>= start
&& p1
< end
)
3557 *p1
= (7 & c
) + '0';
3562 if (c
&& length
> 0)
3565 if (truncate
) *p1
++ = fix_glyph (f
, truncate
, 0);
3567 else if (mincol
>= 0)
3569 end
= desired_glyphs
->glyphs
[vpos
] + mincol
;
3575 register int len
= p1
- desired_glyphs
->glyphs
[vpos
];
3577 if (len
> desired_glyphs
->used
[vpos
])
3578 desired_glyphs
->used
[vpos
] = len
;
3579 desired_glyphs
->glyphs
[vpos
][desired_glyphs
->used
[vpos
]] = 0;
3588 staticpro (&Qmenu_bar_update_hook
);
3589 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
3591 staticpro (&last_arrow_position
);
3592 staticpro (&last_arrow_string
);
3593 last_arrow_position
= Qnil
;
3594 last_arrow_string
= Qnil
;
3596 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
3597 "String (or mode line construct) included (normally) in `mode-line-format'.");
3598 Vglobal_mode_string
= Qnil
;
3600 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
3601 "Marker for where to display an arrow on top of the buffer text.\n\
3602 This must be the beginning of a line in order to work.\n\
3603 See also `overlay-arrow-string'.");
3604 Voverlay_arrow_position
= Qnil
;
3606 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
3607 "String to display as an arrow. See also `overlay-arrow-position'.");
3608 Voverlay_arrow_string
= Qnil
;
3610 DEFVAR_INT ("scroll-step", &scroll_step
,
3611 "*The number of lines to try scrolling a window by when point moves out.\n\
3612 If that fails to bring point back on frame, point is centered instead.\n\
3613 If this is zero, point is always centered after it moves off frame.");
3615 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
3617 DEFVAR_BOOL ("truncate-partial-width-windows",
3618 &truncate_partial_width_windows
,
3619 "*Non-nil means truncate lines in all windows less than full frame wide.");
3620 truncate_partial_width_windows
= 1;
3622 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
3623 "*Non-nil means use inverse video for the mode line.");
3624 mode_line_inverse_video
= 1;
3626 DEFVAR_INT ("line-number-display-limit", &line_number_display_limit
,
3627 "*Maximum buffer size for which line number should be displayed.");
3628 line_number_display_limit
= 1000000;
3630 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
3631 "*Non-nil means highlight region even in nonselected windows.");
3632 highlight_nonselected_windows
= 1;
3634 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
3635 "Non-nil means more than one frame is in use, not counting minibuffer frames.\n\
3636 Not guaranteed to be accurate except while parsing frame-title-format.");
3638 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
3639 "Template for displaying the titlebar of visible frames.\n\
3640 \(Assuming the window manager supports this feature.)\n\
3641 This variable has the same structure as `mode-line-format' (which see),\n\
3642 and is used only on frames for which no explicit name has been set\n\
3643 \(see `modify-frame-parameters').");
3644 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
3645 "Template for displaying the titlebar of an iconified frame.\n\
3646 \(Assuming the window manager supports this feature.)\n\
3647 This variable has the same structure as `mode-line-format' (which see),\n\
3648 and is used only on frames for which no explicit name has been set\n\
3649 \(see `modify-frame-parameters').");
3651 = Vframe_title_format
3652 = Fcons (intern ("multiple-frames"),
3653 Fcons (build_string ("%b"),
3654 Fcons (Fcons (build_string (""),
3655 Fcons (intern ("invocation-name"),
3656 Fcons (build_string ("@"),
3657 Fcons (intern ("system-name"),
3662 /* initialize the window system */
3665 Lisp_Object root_window
;
3666 #ifndef COMPILER_REGISTER_BUG
3668 #endif /* COMPILER_REGISTER_BUG */
3669 struct window
*mini_w
;
3671 this_line_bufpos
= 0;
3673 mini_w
= XWINDOW (minibuf_window
);
3674 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
3676 echo_area_glyphs
= 0;
3677 previous_echo_glyphs
= 0;
3679 if (!noninteractive
)
3681 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
3682 XSETFASTINT (XWINDOW (root_window
)->top
, 0);
3683 set_window_height (root_window
, FRAME_HEIGHT (f
) - 1, 0);
3684 XSETFASTINT (mini_w
->top
, FRAME_HEIGHT (f
) - 1);
3685 set_window_height (minibuf_window
, 1, 0);
3687 XSETFASTINT (XWINDOW (root_window
)->width
, FRAME_WIDTH (f
));
3688 XSETFASTINT (mini_w
->width
, FRAME_WIDTH (f
));