/* Display generation from window structure and buffer text.
- Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
+ Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 1997
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "termchar.h"
#include "dispextern.h"
#include "buffer.h"
+#include "charset.h"
#include "indent.h"
#include "commands.h"
#include "macros.h"
#include "termhooks.h"
#include "intervals.h"
#include "keyboard.h"
+#include "coding.h"
+#include "process.h"
#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
extern void set_frame_menubar ();
+extern int pending_menu_activation;
#endif
extern int interrupt_input;
extern int command_loop_level;
+extern int minibuffer_auto_raise;
+
extern Lisp_Object Qface;
extern Lisp_Object Voverriding_local_map;
/* String to display for the arrow. */
Lisp_Object Voverlay_arrow_string;
+/* Values of those variables at last redisplay.
+ However, if Voverlay_arrow_position is a marker,
+ last_arrow_position is its numerical position. */
+static Lisp_Object last_arrow_position, last_arrow_string;
+
/* Like mode-line-format, but for the titlebar on a visible frame. */
Lisp_Object Vframe_title_format;
have changed. */
static Lisp_Object Vwindow_size_change_functions;
-/* Values of those variables at last redisplay. */
-static Lisp_Object last_arrow_position, last_arrow_string;
-
Lisp_Object Qmenu_bar_update_hook;
/* Nonzero if overlay arrow has been displayed once in this window. */
Try scrolling this many lines up or down if that will bring it back. */
static int scroll_step;
+/* Non-0 means scroll just far enough to bring point back on the screen,
+ when appropriate. */
+static int scroll_conservatively;
+
+/* Recenter the window whenever point gets within this many lines
+ of the top or bottom of the window. */
+int scroll_margin;
+
+/* Number of characters of overlap to show,
+ when scrolling a one-line window such as a minibuffer. */
+static int minibuffer_scroll_overlap;
+
/* Nonzero if try_window_id has made blank lines at window bottom
since the last redisplay that paused */
static int blank_end_of_window;
/* Nonzero means display mode line highlighted */
int mode_line_inverse_video;
+static void redisplay_internal ();
static int message_log_check_duplicate ();
static void echo_area_display ();
void mark_window_display_accurate ();
same window currently active as a minibuffer. */
Lisp_Object echo_area_window;
+/* Nonzero means multibyte characters were enabled when the echo area
+ message was specified. */
+int message_enable_multibyte;
+
/* true iff we should redraw the mode lines on the next redisplay */
int update_mode_lines;
int end_unchanged;
/* MODIFF as of last redisplay that finished;
- if it matches MODIFF, beg_unchanged and end_unchanged
+ if it matches MODIFF, and overlay_unchanged_modified
+ matches OVERLAY_MODIFF, that means beg_unchanged and end_unchanged
contain no useful information */
int unchanged_modified;
+/* OVERLAY_MODIFF as of last redisplay that finished. */
+int overlay_unchanged_modified;
+
/* Nonzero if window sizes or contents have changed
since last redisplay that finished */
int windows_or_buffers_changed;
/* Number of lines to keep in the message log buffer.
t means infinite. nil means don't log at all. */
Lisp_Object Vmessage_log_max;
+
+#define COERCE_MARKER(X) \
+ (MARKERP ((X)) ? Fmarker_position (X) : (X))
\f
+/* Output a newline in the *Messages* buffer if "needs" one. */
+
void
message_log_maybe_newline ()
{
struct buffer *oldbuf;
int oldpoint, oldbegv, oldzv;
int old_windows_or_buffers_changed = windows_or_buffers_changed;
+ int point_at_end = 0;
+ int zv_at_end = 0;
oldbuf = current_buffer;
Fset_buffer (Fget_buffer_create (build_string ("*Messages*")));
BEGV = BEG;
ZV = Z;
if (oldpoint == Z)
- oldpoint += len + nlflag;
+ point_at_end = 1;
if (oldzv == Z)
- oldzv += len + nlflag;
+ zv_at_end = 1;
TEMP_SET_PT (Z);
- if (len)
+
+ /* Insert the string--maybe converting multibyte to single byte
+ or vice versa, so that all the text fits the buffer. */
+ if (! NILP (oldbuf->enable_multibyte_characters)
+ && NILP (current_buffer->enable_multibyte_characters))
+ {
+ int c, i = 0, nbytes;
+ /* Convert a multibyte string to single-byte
+ for the *Message* buffer. */
+ while (i < len)
+ {
+ c = STRING_CHAR (m + i, len - i);
+ i += XFASTINT (Fchar_bytes (make_number (c)));
+ /* Truncate the character to its last byte--we can only hope
+ the user is happy with the character he gets,
+ since if it isn't right, there is no way to do it right. */
+ c &= 0xff;
+ insert_char (c);
+ }
+ }
+ else if (NILP (oldbuf->enable_multibyte_characters)
+ && ! NILP (current_buffer->enable_multibyte_characters))
+ {
+ int c, i = 0;
+ /* Convert a single-byte string to multibyte
+ for the *Message* buffer. */
+ while (i < len)
+ {
+ c = m[i++];
+ /* Convert non-ascii chars as if for self-insert. */
+ if (c >= 0200 && c <= 0377)
+ c += nonascii_insert_offset;
+ insert_char (c);
+ }
+ }
+ else if (len)
insert_1 (m, len, 1, 0);
+
if (nlflag)
{
int this_bol, prev_bol, dup;
}
}
BEGV = oldbegv;
- ZV = oldzv;
- TEMP_SET_PT (oldpoint);
+ if (zv_at_end)
+ ZV = Z;
+ else
+ ZV = oldzv;
+ if (point_at_end)
+ TEMP_SET_PT (Z);
+ else
+ TEMP_SET_PT (oldpoint);
set_buffer_internal (oldbuf);
windows_or_buffers_changed = old_windows_or_buffers_changed;
message_log_need_newline = !nlflag;
}
}
-
/* We are at the end of the buffer after just having inserted a newline.
(Note: We depend on the fact we won't be crossing the gap.)
Check to see if the most recent message looks a lot like the previous one.
}
return 0;
}
-
+\f
/* Display an echo area message M with a specified length of LEN chars.
- The string may include null characters. If m is 0, clear out any
+ The string may include null characters. If M is 0, clear out any
existing message, and let the minibuffer text show through.
- Do not pass text that is stored in a Lisp string. */
+
+ The buffer M must continue to exist until after the echo area
+ gets cleared or some other message gets displayed there.
+
+ Do not pass text that is stored in a Lisp string.
+ Do not pass text in a buffer that was alloca'd. */
void
message2 (m, len)
}
-/* The non-logging part of that function. */
+/* The non-logging counterpart of message2. */
void
message2_nolog (m, len)
char *m;
int len;
{
+ message_enable_multibyte
+ = ! NILP (current_buffer->enable_multibyte_characters);
+
if (noninteractive)
{
if (noninteractive_need_newline)
putc ('\n', stderr);
noninteractive_need_newline = 0;
- fwrite (m, len, 1, stderr);
+ if (m)
+ fwrite (m, len, 1, stderr);
if (cursor_in_echo_area == 0)
fprintf (stderr, "\n");
fflush (stderr);
mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
-#ifdef MULTI_FRAME
FRAME_SAMPLE_VISIBILITY (f);
if (FRAME_VISIBLE_P (selected_frame)
&& ! FRAME_VISIBLE_P (f))
Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window)));
-#endif
if (m)
{
echo_area_glyphs = m;
echo_area_glyphs_length = len;
+
+ if (minibuffer_auto_raise)
+ Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
}
else
echo_area_glyphs = previous_echo_glyphs = 0;
(*frame_up_to_date_hook) (f);
}
}
+\f
+/* Display a null-terminated echo area message M. If M is 0, clear out any
+ existing message, and let the minibuffer text show through.
+
+ The buffer M must continue to exist until after the echo area
+ gets cleared or some other message gets displayed there.
+
+ Do not pass text that is stored in a Lisp string.
+ Do not pass text in a buffer that was alloca'd. */
void
message1 (m)
zero if being used by message. */
int message_buf_print;
-/* Dump an informative message to the minibuf. If m is 0, clear out
+/* Dump an informative message to the minibuf. If M is 0, clear out
any existing message, and let the minibuffer text show through. */
+
/* VARARGS 1 */
void
message (m, a1, a2, a3)
{
int len;
#ifdef NO_ARG_ARRAY
- EMACS_INT a[3];
- a[0] = a1;
- a[1] = a2;
- a[2] = a3;
+ char *a[3];
+ a[0] = (char *) a1;
+ a[1] = (char *) a2;
+ a[2] = (char *) a3;
len = doprnt (FRAME_MESSAGE_BUF (f),
- FRAME_WIDTH (f), m, (char *)0, 3, a);
+ FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3, a);
#else
len = doprnt (FRAME_MESSAGE_BUF (f),
- FRAME_WIDTH (f), m, (char *)0, 3, &a1);
+ FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3, &a1);
#endif /* NO_ARG_ARRAY */
message2 (FRAME_MESSAGE_BUF (f), len);
}
}
-/* The non-logging version of that function. */
+/* The non-logging version of message. */
void
message_nolog (m, a1, a2, a3)
char *m;
{
message2 (echo_area_glyphs, echo_area_glyphs_length);
}
-
+\f
static void
echo_area_display ()
{
if (echo_area_glyphs || minibuf_level == 0)
{
+ int i;
+
echo_area_window = mini_window;
vpos = XFASTINT (XWINDOW (mini_window)->top);
get_display_line (f, vpos, 0);
+
+ /* Make sure the columns that overlap a left-hand scroll bar
+ are always clear. */
+ for (i = 0; i < FRAME_LEFT_SCROLL_BAR_WIDTH (f); i++)
+ f->desired_glyphs->glyphs[vpos][i] = SPACEGLYPH;
+
display_string (XWINDOW (mini_window), vpos,
echo_area_glyphs ? echo_area_glyphs : "",
echo_area_glyphs ? echo_area_glyphs_length : -1,
- 0, 0, 0, 0, FRAME_WIDTH (f));
+ FRAME_LEFT_SCROLL_BAR_WIDTH (f),
+ 0, 0, 0,
+ FRAME_WIDTH (f) + FRAME_LEFT_SCROLL_BAR_WIDTH (f),
+ message_enable_multibyte);
#if 0 /* This just gets in the way. update_frame does the job. */
/* If desired cursor location is on this line, put it at end of text */
i < vpos + XFASTINT (XWINDOW (mini_window)->height); i++)
{
get_display_line (f, i, 0);
- display_string (XWINDOW (mini_window), vpos,
- "", 0, 0, 0, 0, 0, FRAME_WIDTH (f));
+ /* We don't use FRAME_SCROLL_BAR_WIDTH (f) as the starting
+ hpos, because it is good to clear whatever is behind the
+ scroll bar. This does not affect the scroll bar itself. */
+ display_string (XWINDOW (mini_window), i,
+ "", 0,
+ 0, 0, 0,
+ 0, FRAME_WIDTH (f) + FRAME_SCROLL_BAR_WIDTH (f),
+ 0);
}
}
}
previous_echo_glyphs = echo_area_glyphs;
}
+\f
+/* Update frame titles. */
#ifdef HAVE_WINDOW_SYSTEM
static char frame_title_buf[512];
Lisp_Object tail, frame;
int count = specpdl_ptr - specpdl;
- record_unwind_protect (Fstore_match_data, Fmatch_data ());
+ record_unwind_protect (Fstore_match_data, Fmatch_data (Qnil, Qnil));
FOR_EACH_FRAME (tail, frame)
{
}
else
update_menu_bar (selected_frame, 1);
+
+ /* Motif needs this. See comment in xmenu.c.
+ Turn it off when pending_menu_activation is not defined. */
+#ifdef USE_X_TOOLKIT
+ pending_menu_activation = 0;
+#endif
}
\f
/* Do a frame update, taking possible shortcuts into account.
void
redisplay ()
+{
+ redisplay_internal (0);
+}
+
+/* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay
+ is not in response to any user action; therefore, we should
+ preserve the echo area. (Actually, our caller does that job.)
+ Perhaps in the future avoid recentering windows
+ if it is not necessary; currently that causes some problems. */
+
+static void
+redisplay_internal (preserve_echo_area)
+ int preserve_echo_area;
{
register struct window *w = XWINDOW (selected_window);
register int pause;
int all_windows;
register int tlbufpos, tlendpos;
struct position pos;
+ int number_of_visible_frames;
if (noninteractive)
return;
-#ifdef MULTI_FRAME
- if (FRAME_TERMCAP_P (selected_frame)
+#ifdef USE_X_TOOLKIT
+ if (popup_activated ())
+ return;
+#endif
+
+ retry:
+
+ if (! FRAME_WINDOW_P (selected_frame)
&& previous_terminal_frame != selected_frame)
{
/* Since frames on an ASCII terminal share the same display area,
XSETFRAME (Vterminal_frame, selected_frame);
}
previous_terminal_frame = selected_frame;
-#endif
/* Set the visible flags for all frames.
Do this before checking for resized or garbaged frames; they want
{
Lisp_Object tail, frame;
+ number_of_visible_frames = 0;
+
FOR_EACH_FRAME (tail, frame)
{
FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
+ if (FRAME_VISIBLE_P (XFRAME (frame)))
+ number_of_visible_frames++;
+
/* Clear out all the display lines in which we will generate the
glyphs to display. */
init_desired_glyphs (XFRAME (frame));
if (windows_or_buffers_changed)
update_mode_lines++;
- /* Detect case that we need to write a star in the mode line. */
- if (XFASTINT (w->last_modified) < MODIFF
- && XFASTINT (w->last_modified) <= SAVE_MODIFF)
+ /* Detect case that we need to write or remove a star in the mode line. */
+ if ((SAVE_MODIFF < MODIFF) != !NILP (w->last_had_star))
{
w->update_mode_line = Qt;
if (buffer_shared > 1)
/* This alternative quickly identifies a common case
where no change is needed. */
&& !(PT == XFASTINT (w->last_point)
- && XFASTINT (w->last_modified) >= MODIFF)
+ && XFASTINT (w->last_modified) >= MODIFF
+ && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
&& XFASTINT (w->column_number_displayed) != current_column ())
w->update_mode_line = Qt;
/* If specs for an arrow have changed, do thorough redisplay
to ensure we remove any arrow that should no longer exist. */
- if (! EQ (Voverlay_arrow_position, last_arrow_position)
+ if (! EQ (COERCE_MARKER (Voverlay_arrow_position), last_arrow_position)
|| ! EQ (Voverlay_arrow_string, last_arrow_string))
all_windows = 1;
if (!all_windows && tlbufpos > 0 && NILP (w->update_mode_line)
&& !current_buffer->clip_changed
&& FRAME_VISIBLE_P (XFRAME (w->frame))
+ && !FRAME_OBSCURED_P (XFRAME (w->frame))
/* Make sure recorded data applies to current buffer, etc */
&& this_line_buffer == current_buffer
&& current_buffer == XBUFFER (w->buffer)
&& PT <= Z - tlendpos
/* All text outside that line, including its final newline,
must be unchanged */
- && (XFASTINT (w->last_modified) >= MODIFF
+ && ((XFASTINT (w->last_modified) >= MODIFF
+ && (XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF))
|| (beg_unchanged >= tlbufpos - 1
&& GPT >= tlbufpos
/* If selective display, can't optimize
&& end_unchanged >= tlendpos
&& Z - GPT >= tlendpos)))
{
- if (tlbufpos > BEGV && FETCH_CHAR (tlbufpos - 1) != '\n'
+ if (tlbufpos > BEGV && FETCH_BYTE (tlbufpos - 1) != '\n'
&& (tlbufpos == ZV
- || FETCH_CHAR (tlbufpos) == '\n'))
+ || FETCH_BYTE (tlbufpos) == '\n'))
/* Former continuation line has disappeared by becoming empty */
goto cancel;
else if (XFASTINT (w->last_modified) < MODIFF
+ || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF
|| MINI_WINDOW_P (w))
{
+ /* We have to handle the case of continuation around a
+ wide-column character (See the comment in indent.c around
+ line 885).
+
+ For instance, in the following case:
+
+ -------- Insert --------
+ K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
+ J_I_ ==> J_I_ `^^' are cursors.
+ ^^ ^^
+ -------- --------
+
+ As we have to redraw the line above, we should goto cancel. */
+
+ struct position val;
+ int prevline;
+
+ prevline = find_next_newline (tlbufpos, -1);
+ val = *compute_motion (prevline, 0,
+ XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0,
+ 0,
+ tlbufpos,
+ 1 << (BITS_PER_SHORT - 1),
+ 1 << (BITS_PER_SHORT - 1),
+ window_internal_width (w) - 1,
+ XINT (w->hscroll), 0, w);
+ if (val.hpos != this_line_start_hpos)
+ goto cancel;
+
cursor_vpos = -1;
overlay_arrow_seen = 0;
zv_strings_seen = 0;
display_text_line (w, tlbufpos, this_line_vpos, this_line_start_hpos,
- pos_tab_offset (w, tlbufpos));
+ pos_tab_offset (w, tlbufpos), 0);
/* If line contains point, is not continued,
and ends at same distance from eob as before, we win */
if (cursor_vpos >= 0 && this_line_bufpos
if (this_line_vpos + 1
< XFASTINT (w->top) + window_internal_height (w))
{
- int left = XFASTINT (w->left);
+ int left = WINDOW_LEFT_MARGIN (w);
int *charstart_next_line
= FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w)))->charstarts[this_line_vpos + 1];
int adjust;
adjust_window_charstarts (w, this_line_vpos, adjust);
}
- if (XFASTINT (w->width) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w))))
+ if (!WINDOW_FULL_WIDTH_P (w))
preserve_other_columns (w);
goto update;
}
then we can't just move the cursor. */
else if (! (!NILP (Vtransient_mark_mode)
&& !NILP (current_buffer->mark_active))
+ && (w == XWINDOW (current_buffer->last_selected_window)
+ || highlight_nonselected_windows)
&& NILP (w->region_showing)
&& !cursor_in_echo_area)
{
{
int width = window_internal_width (w) - 1;
FRAME_CURSOR_X (selected_frame)
- = XFASTINT (w->left) + minmax (0, pos.hpos, width);
+ = WINDOW_LEFT_MARGIN (w) + minmax (0, pos.hpos, width);
FRAME_CURSOR_Y (selected_frame) = this_line_vpos;
goto update;
}
FOR_EACH_FRAME (tail, frame)
{
FRAME_PTR f = XFRAME (frame);
- if (! FRAME_TERMCAP_P (f) || f == selected_frame)
+ if (FRAME_WINDOW_P (f) || f == selected_frame)
{
/* Mark all the scroll bars to be removed; we'll redeem the ones
if (condemn_scroll_bars_hook)
(*condemn_scroll_bars_hook) (f);
- if (FRAME_VISIBLE_P (f))
- redisplay_windows (FRAME_ROOT_WINDOW (f));
+ if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
+ redisplay_windows (FRAME_ROOT_WINDOW (f), preserve_echo_area);
/* Any scroll bars which redisplay_windows should have nuked
should now go away. */
}
}
}
- else if (FRAME_VISIBLE_P (selected_frame))
+ else if (FRAME_VISIBLE_P (selected_frame) && !FRAME_OBSCURED_P (selected_frame))
{
- redisplay_window (selected_window, 1);
- if (XFASTINT (w->width) != FRAME_WIDTH (selected_frame))
+ redisplay_window (selected_window, 1, preserve_echo_area);
+ if (!WINDOW_FULL_WIDTH_P (w))
preserve_other_columns (w);
}
unrequest_sigio ();
stop_polling ();
-#ifdef MULTI_FRAME
if (all_windows)
{
Lisp_Object tail;
f = XFRAME (XCONS (tail)->car);
- if ((! FRAME_TERMCAP_P (f) || f == selected_frame)
- && FRAME_VISIBLE_P (f))
+ if ((FRAME_WINDOW_P (f) || f == selected_frame)
+ && FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
{
pause |= update_frame (f, 0, 0);
if (!pause)
}
}
else
-#endif /* MULTI_FRAME */
{
- if (FRAME_VISIBLE_P (selected_frame))
+ if (FRAME_VISIBLE_P (selected_frame) && !FRAME_OBSCURED_P (selected_frame))
pause = update_frame (selected_frame, 0, 0);
else
pause = 0;
mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
- if (mini_frame != selected_frame
- && ! FRAME_TERMCAP_P (mini_frame))
+ if (mini_frame != selected_frame && FRAME_WINDOW_P (mini_frame))
pause |= update_frame (mini_frame, 0, 0);
}
}
may be null, so preserve_other_columns won't be able to
preserve all the vertical-bar separators. So, avoid using it
in that case. */
- if (XFASTINT (w->width) != FRAME_WIDTH (selected_frame))
+ if (!WINDOW_FULL_WIDTH_P (w))
update_mode_lines = 1;
}
blank_end_of_window = 0;
unchanged_modified = BUF_MODIFF (b);
+ overlay_unchanged_modified = BUF_OVERLAY_MODIFF (b);
beg_unchanged = BUF_GPT (b) - BUF_BEG (b);
end_unchanged = BUF_Z (b) - BUF_GPT (b);
b->clip_changed = 0;
w->update_mode_line = Qnil;
XSETFASTINT (w->last_modified, BUF_MODIFF (b));
+ XSETFASTINT (w->last_overlay_modified, BUF_OVERLAY_MODIFF (b));
+ w->last_had_star
+ = (BUF_MODIFF (XBUFFER (w->buffer)) > BUF_SAVE_MODIFF (XBUFFER (w->buffer))
+ ? Qt : Qnil);
+
+ /* Record if we are showing a region, so can make sure to
+ update it fully at next redisplay. */
+ w->region_showing = (!NILP (Vtransient_mark_mode)
+ && (w == XWINDOW (current_buffer->last_selected_window)
+ || highlight_nonselected_windows)
+ && !NILP (XBUFFER (w->buffer)->mark_active)
+ ? Fmarker_position (XBUFFER (w->buffer)->mark)
+ : Qnil);
+
w->window_end_valid = w->buffer;
- last_arrow_position = Voverlay_arrow_position;
+ last_arrow_position = COERCE_MARKER (Voverlay_arrow_position);
last_arrow_string = Voverlay_arrow_string;
if (do_verify_charstarts)
verify_charstarts (w);
request_sigio ();
start_polling ();
+ /* If something has become visible now which was not before,
+ redisplay again, so that we get them. */
+ if (!pause)
+ {
+ Lisp_Object tail, frame;
+ int new_count = 0;
+
+ FOR_EACH_FRAME (tail, frame)
+ {
+ int this_is_visible = 0;
+
+ if (XFRAME (frame)->visible)
+ this_is_visible = 1;
+ FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
+ if (XFRAME (frame)->visible)
+ this_is_visible = 1;
+
+ if (this_is_visible)
+ new_count++;
+ }
+
+ if (new_count != number_of_visible_frames)
+ windows_or_buffers_changed++;
+ }
+
/* Change frame size now if a change is pending. */
do_pending_window_change ();
- /* If we just did a pending size change, redisplay again
- for the new size. */
+ /* If we just did a pending size change, or have additional
+ visible frames, redisplay again. */
if (windows_or_buffers_changed && !pause)
- redisplay ();
+ goto retry;
}
/* Redisplay, but leave alone any recent echo area message
area to be cleared. See tracking_off and
wait_reading_process_input for examples of these situations. */
+void
redisplay_preserve_echo_area ()
{
if (echo_area_glyphs == 0 && previous_echo_glyphs != 0)
{
echo_area_glyphs = previous_echo_glyphs;
- redisplay ();
+ redisplay_internal (1);
echo_area_glyphs = 0;
}
else
- redisplay ();
+ redisplay_internal (1);
}
void
{
XSETFASTINT (w->last_modified,
!flag ? 0 : BUF_MODIFF (XBUFFER (w->buffer)));
+ XSETFASTINT (w->last_overlay_modified,
+ !flag ? 0 : BUF_OVERLAY_MODIFF (XBUFFER (w->buffer)));
+ w->last_had_star
+ = (BUF_MODIFF (XBUFFER (w->buffer)) > BUF_SAVE_MODIFF (XBUFFER (w->buffer))
+ ? Qt : Qnil);
/* Record if we are showing a region, so can make sure to
update it fully at next redisplay. */
w->region_showing = (!NILP (Vtransient_mark_mode)
+ && (w == XWINDOW (current_buffer->last_selected_window)
+ || highlight_nonselected_windows)
&& !NILP (XBUFFER (w->buffer)->mark_active)
? Fmarker_position (XBUFFER (w->buffer)->mark)
: Qnil);
w->window_end_valid = w->buffer;
w->update_mode_line = Qnil;
- if (!NILP (w->buffer))
+ if (!NILP (w->buffer) && flag)
XBUFFER (w->buffer)->clip_changed = 0;
if (!NILP (w->vchild))
if (flag)
{
- last_arrow_position = Voverlay_arrow_position;
+ last_arrow_position = COERCE_MARKER (Voverlay_arrow_position);
last_arrow_string = Voverlay_arrow_string;
}
else
if (update_mode_lines)
w->update_mode_line = Qt;
- if (FRAME_X_P (f)
+ if (FRAME_WINDOW_P (f)
?
#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
FRAME_EXTERNAL_MENU_BAR (f)
windows_or_buffers_changed anyway. */
if (windows_or_buffers_changed
|| !NILP (w->update_mode_line)
- || (XFASTINT (w->last_modified) < MODIFF
- && (XFASTINT (w->last_modified)
- <= BUF_SAVE_MODIFF (XBUFFER (w->buffer))))
+ || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
+ < BUF_MODIFF (XBUFFER (w->buffer)))
+ != !NILP (w->last_had_star))
|| ((!NILP (Vtransient_mark_mode)
&& !NILP (XBUFFER (w->buffer)->mark_active))
!= !NILP (w->region_showing)))
set_buffer_internal_1 (XBUFFER (w->buffer));
if (save_match_data)
- record_unwind_protect (Fstore_match_data, Fmatch_data ());
+ record_unwind_protect (Fstore_match_data, Fmatch_data (Qnil, Qnil));
if (NILP (Voverriding_local_map_menu_flag))
{
specbind (Qoverriding_terminal_local_map, Qnil);
really recompute the menubar from the value. */
if (! NILP (Vlucid_menu_bar_dirty_flag))
call0 (Qrecompute_lucid_menubar);
- call1 (Vrun_hooks, Qmenu_bar_update_hook);
+ safe_run_hooks (Qmenu_bar_update_hook);
FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
+ /* Redisplay the menu bar in case we changed it. */
#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
- if (FRAME_X_P (f))
+ if (FRAME_WINDOW_P (f))
set_frame_menubar (f, 0, 0);
-#endif /* USE_X_TOOLKIT || HAVE_NTGUI */
+ else
+ /* On a terminal screen, the menu bar is an ordinary screen
+ line, and this makes it get updated. */
+ w->update_mode_line = Qt;
+#else /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
+ /* In the non-toolkit version, the menu bar is an ordinary screen
+ line, and this makes it get updated. */
+ w->update_mode_line = Qt;
+#endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
unbind_to (count, Qnil);
set_buffer_internal_1 (prev);
/* Redisplay WINDOW and its subwindows and siblings. */
static void
-redisplay_windows (window)
+redisplay_windows (window, preserve_echo_area)
Lisp_Object window;
+ int preserve_echo_area;
{
for (; !NILP (window); window = XWINDOW (window)->next)
- redisplay_window (window, 0);
+ redisplay_window (window, 0, preserve_echo_area);
+}
+
+/* Return value in display table DP (Lisp_Char_Table *) for character
+ C. Since a display table doesn't have any parent, we don't have to
+ follow parent. Do not call this function directly but use the
+ macro DISP_CHAR_VECTOR. */
+Lisp_Object
+disp_char_vector (dp, c)
+ struct Lisp_Char_Table *dp;
+ int c;
+{
+ int code[4], i;
+ Lisp_Object val;
+
+ if (SINGLE_BYTE_CHAR_P (c)) return (dp->contents[c]);
+
+ SPLIT_NON_ASCII_CHAR (c, code[0], code[1], code[2]);
+ if (code[0] != CHARSET_COMPOSITION)
+ {
+ if (code[1] < 32) code[1] = -1;
+ else if (code[2] < 32) code[2] = -1;
+ }
+ /* Here, the possible range of CODE[0] (== charset ID) is
+ 128..MAX_CHARSET. Since the top level char table contains data
+ for multibyte characters after 256th element, we must increment
+ CODE[0] by 128 to get a correct index. */
+ code[0] += 128;
+ code[3] = -1; /* anchor */
+
+ for (i = 0; code[i] >= 0; i++, dp = XCHAR_TABLE (val))
+ {
+ val = dp->contents[code[i]];
+ if (!SUB_CHAR_TABLE_P (val))
+ return (NILP (val) ? dp->defalt : val);
+ }
+ /* Here, VAL is a sub char table. We return the default value of it. */
+ return (dp->defalt);
}
/* Redisplay window WINDOW and its subwindows. */
static void
-redisplay_window (window, just_this_one)
+redisplay_window (window, just_this_one, preserve_echo_area)
Lisp_Object window;
- int just_this_one;
+ int just_this_one, preserve_echo_area;
{
register struct window *w = XWINDOW (window);
FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
if (!NILP (w->vchild))
{
- redisplay_windows (w->vchild);
+ redisplay_windows (w->vchild, preserve_echo_area);
return;
}
if (!NILP (w->hchild))
{
- redisplay_windows (w->hchild);
+ redisplay_windows (w->hchild, preserve_echo_area);
return;
}
if (NILP (w->buffer))
for (i = 0; i < height; i++)
{
get_display_line (f, vpos + i, 0);
- display_string (w, vpos + i, "", 0, 0, 0, 1, 0, width);
+ display_string (w, vpos + i, "", 0,
+ FRAME_LEFT_SCROLL_BAR_WIDTH (f),
+ 0, 1, 0, width, 0);
}
goto finish_scroll_bars;
/* This alternative quickly identifies a common case
where no change is needed. */
&& !(PT == XFASTINT (w->last_point)
- && XFASTINT (w->last_modified) >= MODIFF)
+ && XFASTINT (w->last_modified) >= MODIFF
+ && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
&& XFASTINT (w->column_number_displayed) != current_column ())
update_mode_line = 1;
startp = marker_position (w->start);
+ /* If someone specified a new starting point but did not insist,
+ check whether it can be used. */
+ if (!NILP (w->optional_new_start))
+ {
+ w->optional_new_start = Qnil;
+ /* Check whether this start pos is usable given where point is. */
+
+ pos = *compute_motion (startp, 0,
+ (((EQ (window, minibuf_window)
+ && startp == BEG)
+ ? minibuf_prompt_width : 0)
+ + (hscroll ? 1 - hscroll : 0)),
+ 0,
+ PT, height,
+ /* BUG FIX: See the comment of
+ Fpos_visible_in_window_p (window.c). */
+ - (1 << (BITS_PER_SHORT - 1)),
+ width, hscroll, pos_tab_offset (w, startp), w);
+ /* If PT does fit on the screen, we will use this start pos,
+ so do so by setting force_start. */
+ if (pos.bufpos == PT)
+ w->force_start = Qt;
+ }
+
/* Handle case where place to start displaying has been specified,
unless the specified location is outside the accessible range. */
if (!NILP (w->force_start))
update_mode_line = 1;
w->update_mode_line = Qt;
if (! NILP (Vwindow_scroll_functions))
- run_hook_with_args_2 (Qwindow_scroll_functions, window,
- make_number (startp));
+ {
+ run_hook_with_args_2 (Qwindow_scroll_functions, window,
+ make_number (startp));
+ startp = marker_position (w->start);
+ }
}
XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->last_overlay_modified, 0);
if (startp < BEGV) startp = BEGV;
if (startp > ZV) startp = ZV;
try_window (window, startp);
{
if (current_buffer == old)
lpoint = PT;
- FRAME_CURSOR_X (f) = (XFASTINT (w->left)
+ FRAME_CURSOR_X (f) = (WINDOW_LEFT_MARGIN (w)
+ minmax (0, pos.hpos, width));
FRAME_CURSOR_Y (f) = pos.vpos + XFASTINT (w->top);
}
in redisplay handles the same cases. */
if (XFASTINT (w->last_modified) >= MODIFF
+ && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF
&& PT >= startp && !current_buffer->clip_changed
- && (just_this_one || XFASTINT (w->width) == FRAME_WIDTH (f))
+ && (just_this_one || WINDOW_FULL_WIDTH_P (w))
/* If force-mode-line-update was called, really redisplay;
that's how redisplay is forced after e.g. changing
buffer-invisibility-spec. */
/* If end pos is out of date, scroll bar and percentage will be wrong */
&& INTEGERP (w->window_end_vpos)
&& XFASTINT (w->window_end_vpos) < XFASTINT (w->height)
- && !EQ (window, minibuf_window))
+ && !EQ (window, minibuf_window)
+ && (!MARKERP (Voverlay_arrow_position)
+ || current_buffer != XMARKER (Voverlay_arrow_position)->buffer))
{
- pos = *compute_motion (startp, 0, (hscroll ? 1 - hscroll : 0), 0,
- PT, height, 0, width, hscroll,
- pos_tab_offset (w, startp), w);
+ /* All positions in this clause are relative to the window edge. */
+
+ int this_scroll_margin = scroll_margin;
+ int last_point_y = XFASTINT (w->last_point_y) - XINT (w->top);
+ int last_point_x = (XFASTINT (w->last_point_x) - WINDOW_LEFT_MARGIN (w));
- if (pos.vpos < height)
+ /* Find where PT is located now on the frame. */
+ /* Check just_this_one as a way of verifying that the
+ window edges have not changed. */
+ if (PT == XFASTINT (w->last_point) && just_this_one)
+ {
+ pos.hpos = last_point_x;
+ pos.vpos = last_point_y;
+ pos.bufpos = PT;
+ }
+ else if (PT > XFASTINT (w->last_point)
+ && XFASTINT (w->last_point) > startp && just_this_one
+ /* We can't use this if point is in the left margin of a
+ hscrolled window, because w->last_point_x has been
+ clipped to the window edges. */
+ && !(last_point_x <= 0 && hscroll))
+ {
+ pos = *compute_motion (XFASTINT (w->last_point),
+ last_point_y, last_point_x, 0,
+ PT, height,
+ /* BUG FIX: See the comment of
+ Fpos_visible_in_window_p (window.c). */
+ - (1 << (BITS_PER_SHORT - 1)),
+ width, hscroll,
+ pos_tab_offset (w, startp), w);
+ }
+ else
+ {
+ pos = *compute_motion (startp, 0, (hscroll ? 1 - hscroll : 0), 0,
+ PT, height,
+ /* BUG FIX: See the comment of
+ Fpos_visible_in_window_p (window.c). */
+ - (1 << (BITS_PER_SHORT - 1)),
+ width, hscroll,
+ pos_tab_offset (w, startp), w);
+ }
+
+ /* Don't use a scroll margin that is negative or too large. */
+ if (this_scroll_margin < 0)
+ this_scroll_margin = 0;
+
+ if (XINT (w->height) < 4 * scroll_margin)
+ this_scroll_margin = XINT (w->height) / 4;
+
+ /* If point fits on the screen, and not within the scroll margin,
+ we are ok. */
+ if (pos.vpos < height - this_scroll_margin
+ && (pos.vpos >= this_scroll_margin || startp == BEGV))
{
/* Ok, point is still on frame */
if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)))
{
/* These variables are supposed to be origin 1 */
- FRAME_CURSOR_X (f) = (XFASTINT (w->left)
+ FRAME_CURSOR_X (f) = (WINDOW_LEFT_MARGIN (w)
+ minmax (0, pos.hpos, width));
FRAME_CURSOR_Y (f) = pos.vpos + XFASTINT (w->top);
}
this one must be redisplayed, this does nothing because there
is nothing in DesiredFrame yet, and then the other window is
redisplayed, making likes that are empty in this window's columns.
- if (XFASTINT (w->width) != FRAME_WIDTH (f))
+ if (WINDOW_FULL_WIDTH_P (w))
preserve_my_columns (w);
*/
+ if (current_buffer->clip_changed
+ && ! NILP (Vwindow_scroll_functions))
+ run_hook_with_args_2 (Qwindow_scroll_functions, window,
+ make_number (marker_position (w->start)));
+
goto done;
}
/* Don't bother trying redisplay with same start;
but no longer is, find a new starting point. */
else if (!NILP (w->start_at_line_beg)
&& !(startp <= BEGV
- || FETCH_CHAR (startp - 1) == '\n'))
+ || FETCH_BYTE (startp - 1) == '\n'))
{
goto recenter;
}
&& ! EQ (w->window_end_valid, Qnil)
&& do_id && !current_buffer->clip_changed
&& !blank_end_of_window
- && XFASTINT (w->width) == FRAME_WIDTH (f)
+ && WINDOW_FULL_WIDTH_P (w)
/* Can't use this case if highlighting a region. */
&& !(!NILP (Vtransient_mark_mode)
&& !NILP (current_buffer->mark_active))
doesn't display as the end of a line. */
&& !(dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, '\n')))
&& NILP (w->region_showing)
- && EQ (last_arrow_position, Voverlay_arrow_position)
+ && EQ (last_arrow_position, COERCE_MARKER (Voverlay_arrow_position))
&& EQ (last_arrow_string, Voverlay_arrow_string)
&& (tem = try_window_id (FRAME_SELECTED_WINDOW (f)))
&& tem != -2)
goto done;
}
else if (startp >= BEGV && startp <= ZV
- /* Avoid starting display at end of buffer! */
- && (startp < ZV || startp == BEGV
- || (XFASTINT (w->last_modified) >= MODIFF)))
+ && (startp < ZV
+ /* Avoid starting at end of buffer. */
+#if 0 /* This change causes trouble for M-! finger & RET.
+ It will have to be considered later. */
+ || ! EQ (window, selected_window)
+ /* Don't do the recentering if redisplay
+ is not for no user action. */
+ || preserve_echo_area
+#endif
+ || startp == BEGV
+ || (XFASTINT (w->last_modified) >= MODIFF
+ && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)))
{
/* Try to redisplay starting at same place as before */
/* If point has not moved off frame, accept the results */
|| beg_unchanged < startp)
/* Forget any recorded base line for line number display. */
w->base_line_number = Qnil;
+
+ if (current_buffer->clip_changed
+ && ! NILP (Vwindow_scroll_functions))
+ run_hook_with_args_2 (Qwindow_scroll_functions, window,
+ make_number (marker_position (w->start)));
+
goto done;
}
else
}
XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->last_overlay_modified, 0);
/* Redisplay the mode line. Select the buffer properly for that. */
if (!update_mode_line)
{
/* Try to scroll by specified few lines */
+ if (scroll_conservatively && !current_buffer->clip_changed
+ && startp >= BEGV && startp <= ZV)
+ {
+ int this_scroll_margin = scroll_margin;
+ int scroll_margin_pos;
+
+ /* Don't use a scroll margin that is negative or too large. */
+ if (this_scroll_margin < 0)
+ this_scroll_margin = 0;
+
+ if (XINT (w->height) < 4 * this_scroll_margin)
+ this_scroll_margin = XINT (w->height) / 4;
+
+ scroll_margin_pos = Z - XFASTINT (w->window_end_pos);
+ if (this_scroll_margin)
+ {
+ pos = *vmotion (scroll_margin_pos, -this_scroll_margin, w);
+ scroll_margin_pos = pos.bufpos;
+ }
+ if (PT >= scroll_margin_pos)
+ {
+ struct position pos;
+ pos = *compute_motion (scroll_margin_pos, 0, 0, 0,
+ PT, XFASTINT (w->height), 0,
+ XFASTINT (w->width), XFASTINT (w->hscroll),
+ pos_tab_offset (w, startp), w);
+ if (pos.vpos > scroll_conservatively)
+ goto scroll_fail_1;
+
+ pos = *vmotion (startp, pos.vpos + 1, w);
+
+ if (! NILP (Vwindow_scroll_functions))
+ {
+ Fset_marker (w->start, make_number (pos.bufpos), Qnil);
+ run_hook_with_args_2 (Qwindow_scroll_functions, window,
+ make_number (pos.bufpos));
+ pos.bufpos = marker_position (w->start);
+ }
+ try_window (window, pos.bufpos);
+ if (cursor_vpos >= 0)
+ {
+ if (!just_this_one || current_buffer->clip_changed
+ || beg_unchanged < startp)
+ /* Forget any recorded base line for line number display. */
+ w->base_line_number = Qnil;
+ goto done;
+ }
+ else
+ cancel_my_columns (w);
+ }
+
+ scroll_margin_pos = startp;
+ if (this_scroll_margin)
+ {
+ pos = *vmotion (scroll_margin_pos, this_scroll_margin, w);
+ scroll_margin_pos = pos.bufpos;
+ }
+ if (PT < scroll_margin_pos)
+ {
+ struct position pos;
+ pos = *compute_motion (PT, 0, 0, 0,
+ scroll_margin_pos, XFASTINT (w->height), 0,
+ XFASTINT (w->width), XFASTINT (w->hscroll),
+ pos_tab_offset (w, startp), w);
+ if (pos.vpos > scroll_conservatively)
+ goto scroll_fail_1;
+
+ pos = *vmotion (startp, -pos.vpos, w);
+
+ if (! NILP (Vwindow_scroll_functions))
+ {
+ Fset_marker (w->start, make_number (pos.bufpos), Qnil);
+ run_hook_with_args_2 (Qwindow_scroll_functions, window,
+ make_number (pos.bufpos));
+ pos.bufpos = marker_position (w->start);
+ }
+ try_window (window, pos.bufpos);
+ if (cursor_vpos >= 0)
+ {
+ if (!just_this_one || current_buffer->clip_changed
+ || beg_unchanged < startp)
+ /* Forget any recorded base line for line number display. */
+ w->base_line_number = Qnil;
+ goto done;
+ }
+ else
+ cancel_my_columns (w);
+ }
+ scroll_fail_1: ;
+ }
+
if (scroll_step && !current_buffer->clip_changed
&& startp >= BEGV && startp <= ZV)
{
if (PT >= pos.bufpos)
{
if (! NILP (Vwindow_scroll_functions))
- run_hook_with_args_2 (Qwindow_scroll_functions, window,
- make_number (pos.bufpos));
+ {
+ Fset_marker (w->start, make_number (pos.bufpos), Qnil);
+ run_hook_with_args_2 (Qwindow_scroll_functions, window,
+ make_number (pos.bufpos));
+ pos.bufpos = marker_position (w->start);
+ }
try_window (window, pos.bufpos);
if (cursor_vpos >= 0)
{
w->base_line_number = Qnil;
pos = *vmotion (PT, - (height / 2), w);
+
+ /* The minibuffer is often just one line. Ordinary scrolling
+ gives little overlap and looks bad. So show 20 chars before point. */
+ if (height == 1
+ && (pos.bufpos >= PT - minibuffer_scroll_overlap
+ /* If we scrolled less than 1/2 line forward, we will
+ get too much overlap, so change to the usual amount. */
+ || pos.bufpos < startp + width / 2)
+ && PT > BEGV + minibuffer_scroll_overlap
+ /* If we scrolled to an actual line boundary,
+ that's different; don't ignore line boundaries. */
+ && FETCH_CHAR (pos.bufpos - 1) != '\n')
+ pos.bufpos = PT - minibuffer_scroll_overlap;
+
/* Set startp here explicitly in case that helps avoid an infinite loop
in case the window-scroll-functions functions get errors. */
Fset_marker (w->start, make_number (pos.bufpos), Qnil);
if (! NILP (Vwindow_scroll_functions))
- run_hook_with_args_2 (Qwindow_scroll_functions, window,
- make_number (pos.bufpos));
+ {
+ run_hook_with_args_2 (Qwindow_scroll_functions, window,
+ make_number (pos.bufpos));
+ pos.bufpos = marker_position (w->start);
+ }
try_window (window, pos.bufpos);
startp = marker_position (w->start);
w->start_at_line_beg
- = (startp == BEGV || FETCH_CHAR (startp - 1) == '\n') ? Qt : Qnil;
+ = (startp == BEGV || FETCH_BYTE (startp - 1) == '\n') ? Qt : Qnil;
done:
if ((update_mode_line
/* If window not full width, must redo its mode line
if the window to its side is being redone */
- || (!just_this_one && width < FRAME_WIDTH (f) - 1)
+ || (!just_this_one && !WINDOW_FULL_WIDTH_P (w))
|| INTEGERP (w->base_line_pos)
|| (!NILP (w->column_number_displayed)
&& XFASTINT (w->column_number_displayed) != current_column ()))
/* When we reach a frame's selected window, redo the frame's menu bar. */
if (update_mode_line
- && (FRAME_X_P (f)
+ && (FRAME_WINDOW_P (f)
?
#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
FRAME_EXTERNAL_MENU_BAR (f)
register int height = window_internal_height (w);
register int vpos = XFASTINT (w->top);
register int last_text_vpos = vpos;
- int tab_offset = pos_tab_offset (w, pos);
FRAME_PTR f = XFRAME (w->frame);
int width = window_internal_width (w) - 1;
struct position val;
+ /* POS should never be out of range! */
+ if (pos < XBUFFER (w->buffer)->begv
+ || pos > XBUFFER (w->buffer)->zv)
+ abort ();
+
Fset_marker (w->start, make_number (pos), Qnil);
cursor_vpos = -1;
overlay_arrow_seen = 0;
zv_strings_seen = 0;
val.hpos = XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0;
+ val.ovstring_chars_done = 0;
+ val.tab_offset = pos_tab_offset (w, pos);
while (--height >= 0)
{
- val = *display_text_line (w, pos, vpos, val.hpos, tab_offset);
+ val = *display_text_line (w, pos, vpos, val.hpos, val.tab_offset,
+ val.ovstring_chars_done);
+ /* The following code is omitted because we maintain tab_offset
+ in VAL. */
+#if 0
tab_offset += width;
- /* For the first line displayed, display_text_line
- subtracts the prompt width from the tab offset.
- But it does not affect the value of our variable tab_offset.
- So we do the subtraction again,
- for the sake of continuation lines of that first line. */
- if (MINI_WINDOW_P (w) && vpos == XFASTINT (w->top))
- tab_offset -= minibuf_prompt_width;
-
if (val.vpos) tab_offset = 0;
+#endif /* 0 */
vpos++;
if (pos != val.bufpos)
{
last_text_vpos
/* Next line, unless prev line ended in end of buffer with no cr */
= vpos - (val.vpos
- && (FETCH_CHAR (val.bufpos - 1) != '\n' || invis));
+ && (FETCH_BYTE (val.bufpos - 1) != '\n' || invis));
}
pos = val.bufpos;
}
struct position val, bp, ep, xp, pp;
int scroll_amount = 0;
int delta;
- int tab_offset, epto, old_tick;
+ int epto, old_tick;
if (GPT - BEG < beg_unchanged)
beg_unchanged = GPT - BEG;
/* Find position before which nothing is changed. */
bp = *compute_motion (start, 0, lmargin, 0,
- min (ZV, beg_unchanged + BEG), height, 0,
+ min (ZV, beg_unchanged + BEG), height,
+ /* BUG FIX: See the comment of
+ Fpos_visible_in_window_p() (window.c). */
+ - (1 << (BITS_PER_SHORT - 1)),
width, hscroll, pos_tab_offset (w, start), w);
if (bp.vpos >= height)
{
But we need to update window_end_pos to account for
any change in buffer size. */
bp = *compute_motion (start, 0, lmargin, 0,
- ZV, height, 0,
+ ZV, height,
+ /* BUG FIX: See the comment of
+ Fpos_visible_in_window_p() (window.c). */
+ - (1 << (BITS_PER_SHORT - 1)),
width, hscroll, pos_tab_offset (w, start), w);
XSETFASTINT (w->window_end_vpos, height);
XSETFASTINT (w->window_end_pos, Z - bp.bufpos);
--vpos;
pos = bp.bufpos;
}
+ val.tab_offset = bp.tab_offset; /* Update tab offset. */
if (bp.contin && bp.hpos != lmargin)
{
val.hpos = bp.prevhpos - width + lmargin;
+ val.tab_offset = bp.tab_offset + bp.prevhpos - width;
did_motion = 1;
- pos--;
+ DEC_POS (pos);
}
bp.vpos = vpos;
/* Compute the cursor position after that newline. */
ep = *compute_motion (pos, vpos, val.hpos, did_motion, tem,
height, - (1 << (BITS_PER_SHORT - 1)),
- width, hscroll, pos_tab_offset (w, bp.bufpos), w);
+ width, hscroll,
+ /* We have tab offset in VAL, use it. */
+ val.tab_offset, w);
/* If changes reach past the text available on the frame,
just display rest of frame. */
newline before it, so the following line must be redrawn. */
if (stop_vpos == ep.vpos
&& (ep.bufpos == BEGV
- || FETCH_CHAR (ep.bufpos - 1) != '\n'
+ || FETCH_BYTE (ep.bufpos - 1) != '\n'
|| ep.bufpos == Z - end_unchanged))
stop_vpos = ep.vpos + 1;
if (stop_vpos < height)
{
/* Now determine how far up or down the rest of the window has moved */
- epto = pos_tab_offset (w, ep.bufpos);
xp = *compute_motion (ep.bufpos, ep.vpos, ep.hpos, 1,
Z - XFASTINT (w->window_end_pos),
- 10000, 0, width, hscroll, epto, w);
+ /* Don't care for VPOS... */
+ 1 << (BITS_PER_SHORT - 1),
+ /* ... nor HPOS. */
+ 1 << (BITS_PER_SHORT - 1),
+ width, hscroll, ep.tab_offset, w);
scroll_amount = xp.vpos - XFASTINT (w->window_end_vpos);
/* Is everything on frame below the changes whitespace?
If so, no scrolling is really necessary. */
for (i = ep.bufpos; i < xp.bufpos; i++)
{
- tem = FETCH_CHAR (i);
+ tem = FETCH_BYTE (i);
if (tem != ' ' && tem != '\n' && tem != '\t')
break;
}
XFASTINT (w->window_end_vpos) + scroll_amount);
/* Before doing any scrolling, verify that point will be on frame. */
- if (PT > ep.bufpos && !(PT <= xp.bufpos && xp.bufpos < height))
+ if (PT > ep.bufpos && !(PT <= xp.bufpos && xp.vpos < height))
{
if (PT <= xp.bufpos)
{
pp = *compute_motion (ep.bufpos, ep.vpos, ep.hpos, 1,
PT, height, - (1 << (BITS_PER_SHORT - 1)),
- width, hscroll, epto, w);
+ width, hscroll,
+ /* We have tab offset in EP, use it. */
+ ep.tab_offset, w);
}
else
{
pp = *compute_motion (xp.bufpos, xp.vpos, xp.hpos, 1,
PT, height, - (1 << (BITS_PER_SHORT - 1)),
width, hscroll,
- pos_tab_offset (w, xp.bufpos), w);
+ /* We have tab offset in XP, use it. */
+ xp.tab_offset, w);
}
if (pp.bufpos < PT || pp.vpos == height)
return 0;
cursor_vpos = pp.vpos + top;
- cursor_hpos = XFASTINT (w->left) + minmax (0, pp.hpos, width);
+ cursor_hpos = WINDOW_LEFT_MARGIN (w) + minmax (0, pp.hpos, width);
}
if (stop_vpos - scroll_amount >= height
/* Redisplay the lines where the text was changed */
last_text_vpos = vpos;
+ /* The following code is omitted because we maintain tab offset in
+ val.tab_offset. */
+#if 0
tab_offset = pos_tab_offset (w, pos);
/* If we are starting display in mid-character, correct tab_offset
to account for passing the line that that character really starts in. */
if (val.hpos < lmargin)
tab_offset += width;
+#endif /* 0 */
old_tick = MODIFF;
while (vpos < stop_vpos)
{
- val = *display_text_line (w, pos, top + vpos++, val.hpos, tab_offset);
+ val = *display_text_line (w, pos, top + vpos++, val.hpos, val.tab_offset,
+ val.ovstring_chars_done);
/* If display_text_line ran a hook and changed some text,
redisplay all the way to bottom of buffer
So that we show the changes. */
if (old_tick != MODIFF)
stop_vpos = height;
+ /* The following code is omitted because we maintain tab offset
+ in val.tab_offset. */
+#if 0
tab_offset += width;
if (val.vpos) tab_offset = 0;
+#endif
if (pos != val.bufpos)
last_text_vpos
/* Next line, unless prev line ended in end of buffer with no cr */
- = vpos - (val.vpos && FETCH_CHAR (val.bufpos - 1) != '\n');
+ = vpos - (val.vpos && FETCH_BYTE (val.bufpos - 1) != '\n');
pos = val.bufpos;
}
FRAME_SCROLL_BOTTOM_VPOS (f) = xp.vpos;
vpos = xp.vpos;
pos = xp.bufpos;
- val.hpos = lmargin;
+ val.hpos = xp.hpos;
+ val.tab_offset = xp.tab_offset;
if (pos == ZV)
- vpos = height + scroll_amount;
+ { /* Display from next line */
+ vpos = height + scroll_amount;
+ val.hpos = lmargin;
+ val.tab_offset = 0;
+ }
else if (xp.contin && xp.hpos != lmargin)
{
val.hpos = xp.prevhpos - width + lmargin;
- pos--;
+ val.tab_offset = xp.tab_offset + bp.prevhpos - width;
+ DEC_POS (pos);
}
blank_end_of_window = 1;
+ /* The following code is omitted because we maintain tab offset
+ in val.tab_offset. */
+#if 0
tab_offset = pos_tab_offset (w, pos);
/* If we are starting display in mid-character, correct tab_offset
to account for passing the line that that character starts in. */
if (val.hpos < lmargin)
tab_offset += width;
-
+#endif
while (vpos < height)
{
- val = *display_text_line (w, pos, top + vpos++, val.hpos, tab_offset);
+ val = *display_text_line (w, pos, top + vpos++, val.hpos,
+ val.tab_offset, val.ovstring_chars_done);
+ /* The following code is omitted because we maintain tab
+ offset in val.tab_offset. */
+#if 0
tab_offset += width;
if (val.vpos) tab_offset = 0;
+#endif /* 0 */
pos = val.bufpos;
}
if (cursor_vpos < 0)
{
findpoint:
- val = *compute_motion (start, 0, lmargin, 0, PT, 10000, 10000,
+ val = *compute_motion (start, 0, lmargin, 0, PT,
+ /* Don't care for VPOS... */
+ 1 << (BITS_PER_SHORT - 1),
+ /* ... nor HPOS. */
+ 1 << (BITS_PER_SHORT - 1),
width, hscroll, pos_tab_offset (w, start), w);
/* Admit failure if point is off frame now */
if (val.vpos >= height)
return 0;
}
cursor_vpos = val.vpos + top;
- cursor_hpos = XFASTINT (w->left) + minmax (0, val.hpos, width);
+ cursor_hpos = WINDOW_LEFT_MARGIN (w) + minmax (0, val.hpos, width);
}
FRAME_CURSOR_X (f) = cursor_hpos;
return 1;
}
-\f
-/* Mark a section of BUF as modified, but only for the sake of redisplay.
- This is useful for recording changes to overlays.
-
- We increment the buffer's modification timestamp and set the
- redisplay caches (windows_or_buffers_changed, beg_unchanged, etc)
- as if the region of text between START and END had been modified;
- the redisplay code will check this against the windows' timestamps,
- and redraw the appropriate area of the buffer.
-
- However, if the buffer is unmodified, we bump the last-save
- timestamp as well, so that incrementing the timestamp doesn't fool
- Emacs into thinking that the buffer's text has been modified.
-
- Tweaking the timestamps shouldn't hurt the first-modification
- timestamps recorded in the undo records; those values aren't
- written until just before a real text modification is made, so they
- will never catch the timestamp value just before this function gets
- called. */
-
-void
-redisplay_region (buf, start, end)
- struct buffer *buf;
- int start, end;
-{
- if (start == end)
- return;
-
- if (start > end)
- {
- int temp = start;
- start = end; end = temp;
- }
-
- /* If this is a buffer not in the selected window,
- we must do other windows. */
- if (buf != XBUFFER (XWINDOW (selected_window)->buffer))
- windows_or_buffers_changed = 1;
- /* If it's not current, we can't use beg_unchanged, end_unchanged for it. */
- else if (buf != current_buffer)
- windows_or_buffers_changed = 1;
- /* If multiple windows show this buffer, we must do other windows. */
- else if (buffer_shared > 1)
- windows_or_buffers_changed = 1;
- else
- {
- if (unchanged_modified == MODIFF)
- {
- beg_unchanged = start - BEG;
- end_unchanged = Z - end;
- }
- else
- {
- if (Z - end < end_unchanged)
- end_unchanged = Z - end;
- if (start - BEG < beg_unchanged)
- beg_unchanged = start - BEG;
- }
- }
-
- /* Increment the buffer's time stamp, but also increment the save
- and autosave timestamps, so as not to screw up that timekeeping. */
- if (BUF_MODIFF (buf) == BUF_SAVE_MODIFF (buf))
- BUF_SAVE_MODIFF (buf)++;
- if (BUF_MODIFF (buf) == buf->auto_save_modified)
- buf->auto_save_modified++;
-
- BUF_MODIFF (buf) ++;
-}
-
\f
/* Copy LEN glyphs starting address FROM to the rope TO.
But don't actually copy the parts that would come in before S.
if (! FRAME_TERMCAP_P (f))
while (n--)
{
- int glyph = (INTEGERP (*fp) ? XFASTINT (*fp) : 0);
+ GLYPH glyph = (INTEGERP (*fp) ? XFASTINT (*fp) : 0);
int facecode;
+ unsigned int c = FAST_GLYPH_CHAR (glyph);
+
+ if (c > MAX_CHAR)
+ /* For an invalid character code, use space. */
+ c = ' ';
if (FAST_GLYPH_FACE (glyph) == 0)
/* If GLYPH has no face code, use FACE. */
}
if (to >= s)
- *to = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph), facecode);
+ *to = FAST_MAKE_GLYPH (c, facecode);
++to;
++fp;
}
TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
+ OVSTR_DONE is the number of chars of overlay before/after strings
+ at this position which have already been processed.
+
Display on position VPOS on the frame. It is origin 0, relative to
the top of the frame, not W.
struct position val_display_text_line;
static struct position *
-display_text_line (w, start, vpos, hpos, taboffset)
+display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
struct window *w;
int start;
int vpos;
int hpos;
int taboffset;
+ int ovstr_done;
{
register int pos = start;
register int c;
int hscroll = XINT (w->hscroll);
int truncate = (hscroll
|| (truncate_partial_width_windows
- && XFASTINT (w->width) < FRAME_WIDTH (f))
+ && !WINDOW_FULL_WIDTH_P (w))
|| !NILP (current_buffer->truncate_lines));
- /* 1 if we should highlight the region. */
+ /* 1 if this buffer has a region to highlight. */
int highlight_region
- = !NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active);
+ = (!NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active)
+ && XMARKER (current_buffer->mark)->buffer != 0);
int region_beg, region_end;
int selective = (INTEGERP (current_buffer->selective_display)
: default_invis_vector);
GLYPH truncator = (dp == 0 || !INTEGERP (DISP_TRUNC_GLYPH (dp))
+ || !GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (dp)))
? '$' : XINT (DISP_TRUNC_GLYPH (dp)));
GLYPH continuer = (dp == 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp))
+ || !GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (dp)))
? '\\' : XINT (DISP_CONTINUE_GLYPH (dp)));
+ /* If 1, we must handle multibyte characters. */
+ int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+ /* Length of multibyte form of each character. */
+ int len;
+ /* Glyphs generated should be set this bit mask if text must be
+ displayed from right to left. */
+ GLYPH rev_dir_bit = (NILP (current_buffer->direction_reversed)
+ ? 0 : GLYPH_MASK_REV_DIR);
+
/* The next buffer location at which the face should change, due
to overlays or text property changes. */
int next_face_change;
XSETFASTINT (default_invis_vector[2], '.');
default_invis_vector[0] = default_invis_vector[1] = default_invis_vector[2];
- hpos += XFASTINT (w->left);
- get_display_line (f, vpos, XFASTINT (w->left));
+ get_display_line (f, vpos, WINDOW_LEFT_MARGIN (w));
if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
/* Show where to highlight the region. */
- if (highlight_region && XMARKER (current_buffer->mark)->buffer != 0
+ if (highlight_region
/* Maybe highlight only in selected window. */
&& (highlight_nonselected_windows
- || w == XWINDOW (selected_window)))
+ || w == XWINDOW (selected_window)
+ || (MINI_WINDOW_P (XWINDOW (selected_window))
+ && w == XWINDOW (Vminibuf_scroll_window))))
{
region_beg = marker_position (current_buffer->mark);
if (PT < region_beg)
w->region_showing = Qt;
}
else
- region_beg = region_end = -1;
+ {
+ region_beg = region_end = -1;
+ w->region_showing = Qnil;
+ }
if (MINI_WINDOW_P (w)
&& start == BEG
{
if (! NILP (minibuf_prompt))
{
+ int old_width = minibuf_prompt_width;
+
minibuf_prompt_width
= (display_string (w, vpos, XSTRING (minibuf_prompt)->data,
- XSTRING (minibuf_prompt)->size, hpos,
+ XSTRING (minibuf_prompt)->size,
+ hpos + WINDOW_LEFT_MARGIN (w),
/* Display a space if we truncate. */
' ',
1, -1,
/* Truncate the prompt a little before the
margin, so user input can at least start
on the first line. */
- w->width > 10 ? w->width - 4 : -1)
- - hpos);
+ (XFASTINT (w->width) > 10
+ ? XFASTINT (w->width) - 4 : -1),
+ -1)
+ - hpos - WINDOW_LEFT_MARGIN (w));
hpos += minibuf_prompt_width;
- taboffset -= minibuf_prompt_width;
+ taboffset -= minibuf_prompt_width - old_width;
}
else
minibuf_prompt_width = 0;
if (left_edge->vpos > vpos
|| left_edge->hpos > 0)
{
- pos = left_edge->bufpos - 1;
+ pos = left_edge->bufpos;
+ /* Since this should not be a valid multibyte character, we
+ can decrease POS by 1. */
+ pos--;
hpos = left_edge->prevhpos;
}
else
}
}
+ hpos += WINDOW_LEFT_MARGIN (w);
+
desired_glyphs->bufp[vpos] = start;
p1 = desired_glyphs->glyphs[vpos] + hpos;
p1start = p1;
charstart = desired_glyphs->charstarts[vpos] + hpos;
/* In case we don't ever write anything into it... */
- desired_glyphs->charstarts[vpos][XFASTINT (w->left)] = -1;
- leftmargin = desired_glyphs->glyphs[vpos] + XFASTINT (w->left);
+ desired_glyphs->charstarts[vpos][WINDOW_LEFT_MARGIN (w)] = -1;
+ leftmargin = desired_glyphs->glyphs[vpos] + WINDOW_LEFT_MARGIN (w);
endp = leftmargin + width;
/* Arrange the overlays nicely for our purposes. Usually, we call
next_boundary = pos;
p1prev = p1;
prevpos = pos;
- while (1)
+
+ /* If the window is hscrolled and point is in the invisible part of the
+ current line beyond the left margin we can record the cursor location
+ right away. */
+ if (hscroll && start <= PT && PT < pos && cursor_vpos < 0)
+ {
+ cursor_vpos = vpos;
+ cursor_hpos = p1 - leftmargin;
+ }
+
+ while (p1 < endp)
{
if (pos >= pause)
{
if (pos < ZV || !zv_strings_seen++)
{
int ovlen;
- char *ovstr;
+ unsigned char *ovstr;
ovlen = overlay_strings (pos, w, &ovstr);
- for (; ovlen; ovlen--, ovstr++)
+
+ if (ovlen > 0)
{
- if (p1 >= leftmargin && p1 < endp)
- *p1 = MAKE_GLYPH (f, *ovstr, current_face);
- p1++;
+ /* Skip the ones we did in a previous line. */
+ ovstr += ovstr_done;
+ ovlen -= ovstr_done;
+
+ while (ovlen > 0)
+ {
+ int charset, cols;
+ GLYPH g;
+
+ if (multibyte)
+ {
+ c = STRING_CHAR_AND_LENGTH (ovstr, ovlen, len);
+ ovstr += len, ovlen -= len, ovstr_done += len;
+ charset = CHAR_CHARSET (c);
+ cols = (charset == CHARSET_COMPOSITION
+ ? cmpchar_table[COMPOSITE_CHAR_ID (c)]->width
+ : CHARSET_WIDTH (charset));
+ }
+ else
+ {
+ c = *ovstr++, ovlen--, ovstr_done++;
+ cols = 1;
+ }
+ g = MAKE_GLYPH (f, c, current_face) | rev_dir_bit;
+ while (cols-- > 0)
+ {
+ if (p1 >= leftmargin && p1 < endp)
+ *p1 = g, g |= GLYPH_MASK_PADDING;
+ p1++;
+ }
+ }
+ /* If we did all the overlay strings
+ and we have room for text, clear ovstr_done
+ just for neatness' sake. */
+ if (ovlen == 0 && p1 < endp)
+ ovstr_done = 0;
}
}
/* This is just an estimate to give reasonable
performance; nothing should go wrong if it is too small. */
if (XFASTINT (limit) > pos + 50)
- XSETFASTINT (limit, pos + 50);
+ {
+ int limitpos = pos + 50;
+ if (limitpos < Z)
+ INC_POS (limitpos); /* Adjust to character boundary. */
+ XSETFASTINT (limit, limitpos);
+ }
limit = Fnext_single_property_change (position, Qinvisible,
Fcurrent_buffer (), limit);
#endif
/* Did we hit a face change? Figure out what face we should
use now. We also hit this the first time through the
loop, to see what face we should start with. */
- if (pos >= next_face_change && (FRAME_WINDOW_P (f)))
- current_face = compute_char_face (f, w, pos,
- region_beg, region_end,
- &next_face_change, pos + 50, 0);
+ if (pos >= next_face_change
+ && (FRAME_WINDOW_P (f) || FRAME_MSDOS_P (f)))
+ {
+ int limit = pos + 50;
+
+ if (limit < Z && !CHAR_HEAD_P (POS_ADDR (limit)))
+ INC_POS (limit); /* Adjust to character boundary. */
+ current_face = compute_char_face (f, w, pos,
+ region_beg, region_end,
+ &next_face_change, limit, 0);
+ }
#endif
/* Compute the next place we need to stop
if (pos < GPT && GPT < pause)
pause = GPT;
- p = &FETCH_CHAR (pos);
+ p = POS_ADDR (pos);
}
if (p1 >= endp)
p1prev = p1;
- c = *p++;
+ if (multibyte)
+ /* PAUSE is surely at character boundary. */
+ c = STRING_CHAR_AND_LENGTH (p, pause - pos, len), p += len;
+ else
+ c = *p++, len = 1;
/* Let a display table override all standard display methods. */
if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
{
p1 = copy_part_of_rope (f, p1, leftmargin,
XVECTOR (DISP_CHAR_VECTOR (dp, c))->contents,
XVECTOR (DISP_CHAR_VECTOR (dp, c))->size,
- current_face);
+ current_face, rev_dir_bit);
}
else if (c >= 040 && c < 0177)
{
if (p1 >= leftmargin)
- *p1 = MAKE_GLYPH (f, c, current_face);
+ *p1 = MAKE_GLYPH (f, c, current_face) | rev_dir_bit;
p1++;
}
else if (c == '\n')
{
+#if 0
+ /* Same as p1prev, but after the invis_vector_contents text
+ (if we have that on this line). */
+ GLYPH *p1prev_modified;
+#endif
+
invis = 0;
if (last_invis_skip == pos
&& TEXT_PROP_MEANS_INVISIBLE_WITH_ELLIPSIS (last_invis_prop))
{
invis = 1;
pos = find_next_newline (pos + 1, 1);
- if (FETCH_CHAR (pos - 1) == '\n')
+ if (FETCH_BYTE (pos - 1) == '\n')
pos--;
}
if (invis && selective_rlen > 0 && p1 >= leftmargin)
{
+#if 0
+ GLYPH *cs, *csend;
+
+ cs = charstart + (p1 - p1start);
+#endif
+
p1 += selective_rlen;
if (p1 - leftmargin > width)
p1 = endp;
+
+#if 0 /* This needs more work; charstarts needs to record
+ both whether a position ho;ds an ellipsis character
+ and what buffer position it corresponds to. */
+ csend = charstart + (p1 - p1start);
+ while (cs != csend)
+ *cs++ = -2;
+ /* The idea is to use p1prev_modified instead of p1prev
+ in the loop below over p2x. */
+ p1prev_modified = p1;
+#endif
+
copy_part_of_rope (f, p1prev, p1prev, invis_vector_contents,
- (p1 - p1prev), current_face);
+ (p1 - p1prev), current_face, rev_dir_bit);
}
-#ifdef HAVE_FACES
- /* Draw the face of the newline character as extending all the
- way to the end of the frame line. */
- if (current_face)
- {
- if (p1 < leftmargin)
- p1 = leftmargin;
- while (p1 < endp)
- *p1++ = FAST_MAKE_GLYPH (' ', current_face);
- }
-#endif
/* Update charstarts for the newline that ended this line. */
/* Do nothing here for a char that's entirely off the left edge
while (p2x < p2)
*p2x++ = -1;
}
+#ifdef HAVE_FACES
+ /* Draw the face of the newline character as extending all the
+ way to the end of the frame line. */
+ if (current_face)
+ {
+ if (p1 < leftmargin)
+ p1 = leftmargin;
+ while (p1 < endp)
+ *p1++ = FAST_MAKE_GLYPH (' ', current_face) | rev_dir_bit;
+ }
+#endif
break;
}
do
{
if (p1 >= leftmargin && p1 < endp)
- *p1 = MAKE_GLYPH (f, ' ', current_face);
+ *p1 = MAKE_GLYPH (f, ' ', current_face) | rev_dir_bit;
p1++;
}
while ((p1 - leftmargin + taboffset + hscroll - (hscroll > 0))
else if (c == Ctl ('M') && selective == -1)
{
pos = find_next_newline (pos, 1);
- if (FETCH_CHAR (pos - 1) == '\n')
+ if (FETCH_BYTE (pos - 1) == '\n')
pos--;
if (selective_rlen > 0)
{
if (p1 - leftmargin > width)
p1 = endp;
copy_part_of_rope (f, p1prev, p1prev, invis_vector_contents,
- (p1 - p1prev), current_face);
+ (p1 - p1prev), current_face, rev_dir_bit);
}
#ifdef HAVE_FACES
/* Draw the face of the newline character as extending all the
if (p1 < leftmargin)
p1 = leftmargin;
while (p1 < endp)
- *p1++ = FAST_MAKE_GLYPH (' ', current_face);
+ *p1++ = FAST_MAKE_GLYPH (' ', current_face) | rev_dir_bit;
}
#endif
else if (c < 0200 && ctl_arrow)
{
if (p1 >= leftmargin)
- *p1 = fix_glyph (f, (dp && INTEGERP (DISP_CTRL_GLYPH (dp))
- ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
- current_face);
+ *p1 = (fix_glyph
+ (f, (dp && INTEGERP (DISP_CTRL_GLYPH (dp))
+ && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp)))
+ ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
+ current_face)
+ | rev_dir_bit);
p1++;
if (p1 >= leftmargin && p1 < endp)
- *p1 = MAKE_GLYPH (f, c ^ 0100, current_face);
+ *p1 = MAKE_GLYPH (f, c ^ 0100, current_face) | rev_dir_bit;
p1++;
}
- else
+ else if (len == 1)
{
+ /* C is not a multibyte character. */
if (p1 >= leftmargin)
- *p1 = fix_glyph (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
- ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
- current_face);
+ *p1 = (fix_glyph
+ (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
+ && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp)))
+ ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
+ current_face)
+ | rev_dir_bit);
p1++;
if (p1 >= leftmargin && p1 < endp)
- *p1 = MAKE_GLYPH (f, (c >> 6) + '0', current_face);
+ *p1 = MAKE_GLYPH (f, (c >> 6) + '0', current_face) | rev_dir_bit;
p1++;
if (p1 >= leftmargin && p1 < endp)
- *p1 = MAKE_GLYPH (f, (7 & (c >> 3)) + '0', current_face);
+ *p1 = (MAKE_GLYPH (f, (7 & (c >> 3)) + '0', current_face)
+ | rev_dir_bit);
p1++;
if (p1 >= leftmargin && p1 < endp)
- *p1 = MAKE_GLYPH (f, (7 & c) + '0', current_face);
+ *p1 = MAKE_GLYPH (f, (7 & c) + '0', current_face) | rev_dir_bit;
p1++;
}
+ else
+ {
+ /* C is a multibyte character. */
+ int charset = CHAR_CHARSET (c);
+ int columns = (charset == CHARSET_COMPOSITION
+ ? cmpchar_table[COMPOSITE_CHAR_ID (c)]->width
+ : CHARSET_WIDTH (charset));
+ GLYPH g = MAKE_GLYPH (f, c, current_face) | rev_dir_bit;
+
+ while (columns--)
+ {
+ if (p1 >= leftmargin && p1 < endp)
+ *p1 = g, g |= GLYPH_MASK_PADDING;
+ p1++;
+ }
+ }
prevpos = pos;
- pos++;
+ pos += len;
/* Update charstarts for the character just output. */
This occurs when the minibuffer prompt takes up the whole line. */
if (p1prev)
{
- /* Start the next line with that same character */
- pos--;
- /* but at negative hpos, to skip the columns output on this line. */
- val.hpos += p1prev - endp;
+ /* Start the next line with that same character whose
+ character code is C and the length of multi-byte form is
+ LEN. */
+ pos = prevpos;
+
+ if (len == 1)
+ /* C is not a multi-byte character. We can break it and
+ start from the middle column in the next line. So,
+ adjust VAL.HPOS to skip the columns output on this
+ line. */
+ val.hpos += p1prev - endp;
+ else
+ {
+ /* C is a multibyte character. Since we can't broke it
+ in the middle, the whole character should be driven
+ into the next line. */
+ /* As the result, the actual columns occupied by the
+ text on this line is less than WIDTH. VAL.TAB_OFFSET
+ must be adjusted. */
+ taboffset = taboffset + (p1prev - endp);
+ /* Let's fill unused columns with TRUNCATOR or CONTINUER. */
+ {
+ GLYPH g = fix_glyph (f, truncate ? truncator : continuer, 0);
+ while (p1prev < endp)
+ *p1prev++ = g;
+ }
+ /* If POINT is at POS, cursor should not on this line. */
+ lastpos = pos;
+ if (PT == pos)
+ cursor_vpos = -1;
+ }
}
/* Keep in this line everything up to the continuation column. */
if (pos < ZV)
{
- if (FETCH_CHAR (pos) == '\n')
+ if (FETCH_BYTE (pos) == '\n')
{
/* If stopped due to a newline, start next line after it */
pos++;
+ val.tab_offset = 0;
/* Check again for hidden lines, in case the newline occurred exactly
at the right margin. */
while (pos < ZV && selective > 0
&& indented_beyond_p (pos, selective));
val.hpos = XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0;
- lastpos = pos - (FETCH_CHAR (pos - 1) == '\n');
+ lastpos = pos - (FETCH_BYTE (pos - 1) == '\n');
+ val.tab_offset = 0;
}
else
{
*p1++ = fix_glyph (f, continuer, 0);
val.vpos = 0;
lastpos--;
+ val.tab_offset = taboffset + width;
}
}
}
+ else
+ val.tab_offset = 0;
/* If point is at eol or in invisible text at eol,
record its frame location now. */
{
if (cursor_hpos < 0) cursor_hpos = 0;
if (cursor_hpos > width) cursor_hpos = width;
- cursor_hpos += XFASTINT (w->left);
+ cursor_hpos += WINDOW_LEFT_MARGIN (w);
if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)))
{
if (!(cursor_in_echo_area && FRAME_HAS_MINIBUF_P (f)
{
/* Line is not continued and did not start
in middle of character */
- if ((hpos - XFASTINT (w->left)
+ if ((hpos - WINDOW_LEFT_MARGIN (w)
== (XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0))
&& val.vpos)
{
this_line_bufpos = start;
this_line_buffer = current_buffer;
this_line_vpos = cursor_vpos;
- this_line_start_hpos = hpos;
+ this_line_start_hpos = hpos - WINDOW_LEFT_MARGIN (w);
this_line_endpos = Z - lastpos;
}
else
/* If hscroll and line not empty, insert truncation-at-left marker */
if (hscroll && lastpos != start)
{
- *leftmargin = fix_glyph (f, truncator, 0);
+ GLYPH g = fix_glyph (f, truncator, 0);
+ *leftmargin = g;
if (p1 <= leftmargin)
p1 = leftmargin + 1;
+ else /* MULE: it may be a wide-column character */
+ {
+ p1prev = leftmargin + 1;
+ while (p1prev < p1 && *p1prev & GLYPH_MASK_PADDING)
+ *p1prev++ = g;
+ }
}
- if (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f))
+ if (!WINDOW_RIGHTMOST_P (w))
{
endp++;
if (p1 < leftmargin) p1 = leftmargin;
covered up by the scroll bars, and it's distracting to see
them when the scroll bar windows are flickering around to be
reconfigured. */
- if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+ if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
{
int i;
for (i = 0; i < FRAME_SCROLL_BAR_COLS (f); i++)
*p1++ = SPACEGLYPH;
}
- else
+ else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f))
*p1++ = (dp && INTEGERP (DISP_BORDER_GLYPH (dp))
- ? DISP_BORDER_GLYPH (dp)
+ ? XINT (DISP_BORDER_GLYPH (dp))
: '|');
}
desired_glyphs->used[vpos] = max (desired_glyphs->used[vpos],
}
val.bufpos = pos;
+ val.ovstring_chars_done = ovstr_done;
val_display_text_line = val;
return &val_display_text_line;
}
Lisp_Object items, tail;
register int vpos = 0;
register FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
- int maxendcol = FRAME_WIDTH (f);
+ int maxendcol = FRAME_WIDTH (f) + WINDOW_LEFT_MARGIN (w);
int hpos = 0;
int i;
#ifdef HAVE_NTGUI
- return;
+ if (!NILP (Vwindow_system))
+ return;
#endif
#ifdef USE_X_TOOLKIT
get_display_line (f, vpos, 0);
items = FRAME_MENU_BAR_ITEMS (f);
- for (i = 0; i < XVECTOR (items)->size; i += 3)
+ for (i = 0; i < XVECTOR (items)->size; i += 4)
{
Lisp_Object pos, string;
string = XVECTOR (items)->contents[i + 1];
if (NILP (string))
break;
- XSETFASTINT (XVECTOR (items)->contents[i + 2], hpos);
+ XSETFASTINT (XVECTOR (items)->contents[i + 3], hpos);
if (hpos < maxendcol)
- hpos = display_string (XWINDOW (FRAME_ROOT_WINDOW (f)), vpos,
+ hpos = display_string (w, vpos,
XSTRING (string)->data,
XSTRING (string)->size,
- hpos, 0, 0, hpos, maxendcol);
+ hpos, 0, 0, hpos, maxendcol, -1);
/* Put a space between items. */
if (hpos < maxendcol)
{
int hpos1 = hpos + 1;
hpos = display_string (w, vpos, "", 0, hpos, 0, 0,
- min (hpos1, maxendcol), maxendcol);
+ min (hpos1, maxendcol), maxendcol, 0);
}
}
/* Fill out the line with spaces. */
if (maxendcol > hpos)
- hpos = display_string (w, vpos, "", 0, hpos, 0, 0, maxendcol, maxendcol);
+ hpos = display_string (w, vpos, "", 0, hpos, 0, 0, maxendcol, maxendcol, 0);
/* Clear the rest of the lines allocated to the menu bar. */
vpos++;
struct window *w;
{
register int vpos = XFASTINT (w->height) + XFASTINT (w->top) - 1;
- register int left = XFASTINT (w->left);
- register int right = XFASTINT (w->width) + left;
+ register int left = WINDOW_LEFT_MARGIN (w);
+ register int right = WINDOW_RIGHT_MARGIN (w);
register FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
line_number_displayed = 0;
FRAME_DESIRED_GLYPHS (f)->bufp[vpos] = 0;
- /* Make the mode line inverse video if the entire line
- is made of mode lines.
- I.e. if this window is full width,
- or if it is the child of a full width window
- (which implies that that window is split side-by-side
- and the rest of this line is mode lines of the sibling windows). */
- if (XFASTINT (w->width) == FRAME_WIDTH (f)
- || XFASTINT (XWINDOW (w->parent)->width) == FRAME_WIDTH (f))
- FRAME_DESIRED_GLYPHS (f)->highlight[vpos] = mode_line_inverse_video;
+ /* Put the mode line in inverse video.
+ Use faces if possible, since that lets us handle
+ partial-width windows and avoid inverting the scroll bar columns. */
#ifdef HAVE_FACES
- else if (! FRAME_TERMCAP_P (f) && mode_line_inverse_video)
+ if (! FRAME_TERMCAP_P (f) && mode_line_inverse_video)
{
/* For a partial width window, explicitly set face of each glyph. */
int i;
+ unsigned int padding;
GLYPH *ptr = FRAME_DESIRED_GLYPHS (f)->glyphs[vpos];
for (i = left; i < right; ++i)
- ptr[i] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr[i]), 1);
+ {
+ padding = ptr[i] & GLYPH_MASK_PADDING;
+ ptr[i] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr[i]), 1) | padding;
+ }
}
+ else
#endif
+
+ /* Make the mode line inverse video if the entire line
+ is made of mode lines.
+ I.e. if this window is full width,
+ or if it is the child of a full width window
+ (which implies that that window is split side-by-side
+ and the rest of this line is mode lines of the sibling windows). */
+ if (WINDOW_FULL_WIDTH_P (w)
+ || WINDOW_FULL_WIDTH_P (XWINDOW (w->parent)))
+ FRAME_DESIRED_GLYPHS (f)->highlight[vpos] = mode_line_inverse_video;
}
/* Contribute ELT to the mode line for window W.
hpos = store_frame_title (last, hpos, min (lim, maxendcol));
else
hpos = display_string (w, vpos, last, -1, hpos, 0, 1,
- hpos, min (lim, maxendcol));
+ hpos, min (lim, maxendcol), -1);
}
else /* c == '%' */
{
else
hpos = display_string (w, vpos, spec, -1,
hpos, 0, 1,
- minendcol, maxendcol);
+ minendcol, maxendcol, -1);
}
}
}
else
hpos = display_string (w, vpos, XSTRING (tem)->data,
XSTRING (tem)->size,
- hpos, 0, 1, minendcol, maxendcol);
+ hpos, 0, 1, minendcol, maxendcol, -1);
}
/* Give up right away for nil or t. */
else if (!EQ (tem, elt))
hpos = store_frame_title ("*invalid*", minendcol, maxendcol);
else
hpos = display_string (w, vpos, "*invalid*", -1, hpos, 0, 1,
- minendcol, maxendcol);
+ minendcol, maxendcol, 0);
return hpos;
}
if (frame_title_ptr)
hpos = store_frame_title ("", minendcol, maxendcol);
else
- hpos = display_string (w, vpos, "", 0, hpos, 0, 1, minendcol, maxendcol);
+ hpos = display_string (w, vpos, "", 0, hpos,
+ 0, 1, minendcol, maxendcol, 0);
return hpos;
}
\f
}
}
+/* Set a mnemonic character for CODING_SYSTEM (Lisp symbol) in BUF.
+ If EOL_FLAG is 1, set also a mnemonic character for end-of-line
+ type of CODING_SYSTEM. Return updated pointer into BUF. */
+
+static char *
+decode_mode_spec_coding (coding_system, buf, eol_flag)
+ Lisp_Object coding_system;
+ register char *buf;
+ int eol_flag;
+{
+ Lisp_Object val;
+ int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+
+ val = coding_system;
+
+ if (NILP (val)) /* Not yet decided. */
+ {
+ if (multibyte)
+ *buf++ = '-';
+ if (eol_flag)
+ *buf++ = eol_mnemonic_undecided;
+ /* Don't mention EOL conversion if it isn't decided. */
+ }
+ else
+ {
+ Lisp_Object eolvalue;
+
+ eolvalue = Fget (coding_system, Qeol_type);
+
+ while (!NILP (val) && SYMBOLP (val))
+ {
+ val = Fget (val, Qcoding_system);
+ if (NILP (eolvalue))
+ eolvalue = Fget (val, Qeol_type);
+ }
+
+ if (multibyte)
+ *buf++ = XFASTINT (XVECTOR (val)->contents[1]);
+
+ if (eol_flag)
+ {
+ /* The EOL conversion we are using. */
+ int eoltype;
+ /* The EOL conversion that is normal on this system. */
+
+ if (NILP (eolvalue)) /* Not yet decided. */
+ eoltype = eol_mnemonic_undecided;
+ else if (VECTORP (eolvalue)) /* Not yet decided. */
+ eoltype = eol_mnemonic_undecided;
+ else /* INTEGERP (eolvalue) -- 0:LF, 1:CRLF, 2:CR */
+ eoltype = (XFASTINT (eolvalue) == 0
+ ? eol_mnemonic_unix
+ : (XFASTINT (eolvalue) == 1
+ ? eol_mnemonic_dos : eol_mnemonic_mac));
+
+ /* Mention the EOL conversion if it is not the usual one. */
+ *buf++ = eoltype;
+ }
+ }
+ return buf;
+}
+
/* Return a string for the output of a mode line %-spec for window W,
generated by character C. SPEC_WIDTH is the field width when
padding to the left (%c, %l). The value returned from this
case 'F':
/* %F displays the frame name. */
-#ifdef MULTI_FRAME
- return (char *) XSTRING (selected_frame->name)->data;
-#else
+ /* Systems that can only display a single frame at a time should
+ NOT replace the frame name with the (constant) frame title,
+ since then they won't be able to tell which frame is that. */
+ if (FRAME_WINDOW_P (f) && !NILP (f->title))
+ return (char *) XSTRING (f->title)->data;
+ if (f->explicit_name || ! FRAME_WINDOW_P (f))
+ return (char *) XSTRING (f->name)->data;
return "Emacs";
-#endif
case 'f':
obj = b->filename;
don't forget that too fast. */
if (EQ (w->base_line_pos, w->buffer))
goto no_value;
+ /* But do forget it, if the window shows a different buffer now. */
+ else if (BUFFERP (w->base_line_pos))
+ w->base_line_pos = Qnil;
/* If the buffer is very big, don't waste time. */
if (BUF_ZV (b) - BUF_BEGV (b) > line_number_display_limit)
#else
return "T";
#endif
+
+ case 'z':
+ /* coding-system (not including end-of-line format) */
+ case 'Z':
+ /* coding-system (including end-of-line type) */
+ {
+ int eol_flag = (c == 'Z');
+ char *p = decode_mode_spec_buf;
+
+ if (! FRAME_WINDOW_P (f))
+ {
+ /* No need to mention EOL here--the terminal never needs
+ to do EOL conversion. */
+ p = decode_mode_spec_coding (keyboard_coding.symbol, p, 0);
+ p = decode_mode_spec_coding (terminal_coding.symbol, p, 0);
+ }
+ p = decode_mode_spec_coding (b->buffer_file_coding_system,
+ p, eol_flag);
+
+#if 0 /* This proves to be annoying; I think we can do without. -- rms. */
+#ifdef subprocesses
+ obj = Fget_buffer_process (Fcurrent_buffer ());
+ if (PROCESSP (obj))
+ {
+ p = decode_mode_spec_coding (XPROCESS (obj)->decode_coding_system,
+ p, eol_flag);
+ p = decode_mode_spec_coding (XPROCESS (obj)->encode_coding_system,
+ p, eol_flag);
+ }
+#endif /* subprocesses */
+#endif /* 0 */
+ *p = 0;
+ return decode_mode_spec_buf;
+ }
}
if (STRINGP (obj))
{
ceiling = BUFFER_CEILING_OF (start);
ceiling = min (limit, ceiling);
- ceiling_addr = &FETCH_CHAR (ceiling) + 1;
- base = (cursor = &FETCH_CHAR (start));
+ ceiling_addr = POS_ADDR (ceiling) + 1;
+ base = (cursor = POS_ADDR (start));
while (1)
{
while (*cursor != '\n' && *cursor != 015 && ++cursor != ceiling_addr)
{ /* we WILL scan under start */
ceiling = BUFFER_FLOOR_OF (start);
ceiling = max (limit, ceiling);
- ceiling_addr = &FETCH_CHAR (ceiling) - 1;
- base = (cursor = &FETCH_CHAR (start));
+ ceiling_addr = POS_ADDR (ceiling) - 1;
+ base = (cursor = POS_ADDR (start));
cursor++;
while (1)
{
and not display anything beyond there. Otherwise, only MAXCOL
controls where to stop output.
+ MULTIBYTE can be 0 meaning do not display multibyte chars,
+ 1 meaning do display them, or -1 meaning obey the current buffer's
+ value of enable_multibyte_characters.
+
Returns ending hpos. */
static int
display_string (w, vpos, string, length, hpos, truncate,
- obey_window_width, mincol, maxcol)
+ obey_window_width, mincol, maxcol, multibyte)
struct window *w;
unsigned char *string;
int length;
GLYPH truncate;
int obey_window_width;
int mincol, maxcol;
+ int multibyte;
{
register int c;
int truncated;
register struct Lisp_Char_Table *dp = 0;
int i;
+ if (multibyte == -1)
+ multibyte = !NILP (current_buffer->enable_multibyte_characters);
+ /* Now multibyte is 1 if we should display multibyte characters. */
+
if (DISP_TABLE_P (Vstandard_display_table))
dp = XCHAR_TABLE (Vstandard_display_table);
if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
p1 = p1start;
- start = desired_glyphs->glyphs[vpos] + XFASTINT (w->left);
+ start = desired_glyphs->glyphs[vpos];
if (obey_window_width)
{
+ start += XFASTINT (w->left);
end = start + window_width - (truncate != 0);
- if ((window_width + XFASTINT (w->left)) != FRAME_WIDTH (f))
+ if (!WINDOW_RIGHTMOST_P (w))
{
- if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+ if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
{
int i;
for (i = 0; i < FRAME_SCROLL_BAR_COLS (f); i++)
*end-- = ' ';
}
- else
+ else if (!FRAME_HAS_VERTICAL_SCROLL_BARS (f))
*end-- = '|';
}
}
if (maxcol >= 0 && mincol > maxcol)
mincol = maxcol;
+ if (length < 0)
+ /* We need this value for multibyte characters. */
+ length = strlen (string);
+
/* We set truncated to 1 if we get stopped by trying to pass END
(that is, trying to pass MAXCOL.) */
truncated = 0;
while (1)
{
- if (length == 0)
- break;
- c = *string++;
- /* Specified length. */
- if (length >= 0)
- length--;
- /* Unspecified length (null-terminated string). */
- else if (c == 0)
+ int len;
+
+ if (length <= 0)
break;
+ if (multibyte)
+ c = STRING_CHAR_AND_LENGTH (string, length, len);
+ else
+ c = *string, len = 1;
+
+ string += len, length -= len;
if (p1 >= end)
{
else if (c < 0200 && ! NILP (buffer_defaults.ctl_arrow))
{
if (p1 >= start)
- *p1 = fix_glyph (f, (dp && INTEGERP (DISP_CTRL_GLYPH (dp))
- ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
- 0);
+ *p1 = (fix_glyph
+ (f, (dp && INTEGERP (DISP_CTRL_GLYPH (dp))
+ && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (dp)))
+ ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
+ 0));
p1++;
if (p1 >= start && p1 < end)
*p1 = c ^ 0100;
p1++;
}
- else
+ else if (len == 1)
{
+ /* C is a control character or a binary byte data. */
if (p1 >= start)
- *p1 = fix_glyph (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
- ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
- 0);
+ *p1 = (fix_glyph
+ (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
+ && GLYPH_CHAR_VALID_P (XINT (DISP_ESCAPE_GLYPH (dp)))
+ ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
+ 0));
p1++;
if (p1 >= start && p1 < end)
*p1 = (c >> 6) + '0';
*p1 = (7 & c) + '0';
p1++;
}
+ else
+ {
+ /* C is a multibyte character. */
+ int charset = CHAR_CHARSET (c);
+ int columns = (charset == CHARSET_COMPOSITION
+ ? cmpchar_table[COMPOSITE_CHAR_ID (c)]->width
+ : CHARSET_WIDTH (charset));
+
+ if (p1 < start)
+ {
+ /* Since we can't show the left part of C, fill all
+ columns with spaces. */
+ columns -= start - p1;
+ p1 = start;
+ while (columns--)
+ {
+ if (p1 < end)
+ *p1 = SPACEGLYPH;
+ p1++;
+ }
+ }
+ else if (p1 + columns > end)
+ {
+ /* Since we can't show the right part of C, fill all
+ columns with TRUNCATE if TRUNCATE is specified. */
+ if (truncate)
+ {
+ while (p1 < end)
+ *p1++ = fix_glyph (f, truncate, 0);
+ /* And tell the line is truncated. */
+ truncated = 1;
+ }
+ break;
+ }
+ else
+ {
+ /* We can show the whole glyph of C. */
+ *p1++ = c;
+ while (--columns)
+ *p1++ = c | GLYPH_MASK_PADDING;
+ }
+ }
}
if (truncated)
If that fails to bring point back on frame, point is centered instead.\n\
If this is zero, point is always centered after it moves off frame.");
+ DEFVAR_INT ("scroll-conservatively", &scroll_conservatively,
+ "*Scroll up to this many lines, to bring point back on screen.");
+ scroll_conservatively = 0;
+
+ DEFVAR_INT ("scroll-margin", &scroll_margin,
+ "*Number of lines of margin at the top and bottom of a window.\n\
+Recenter the window whenever point gets within this many lines\n\
+of the top or bottom of the window.");
+ scroll_margin = 0;
+
DEFVAR_INT ("debug-end-pos", &debug_end_pos, "Don't ask");
DEFVAR_BOOL ("truncate-partial-width-windows",
DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows,
"*Non-nil means highlight region even in nonselected windows.");
- highlight_nonselected_windows = 1;
+ highlight_nonselected_windows = 0;
DEFVAR_BOOL ("multiple-frames", &multiple_frames,
"Non-nil if more than one frame is visible on this display.\n\
Vwindow_size_change_functions = Qnil;
DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions,
- "List of Functions to call before redisplaying a window with scrolling.\n\
+ "List of functions to call before redisplaying a window with scrolling.\n\
Each function is called with two arguments, the window\n\
and its new display-start position. Note that the value of `window-end'\n\
is not valid when these functions are called.");
Vwindow_scroll_functions = Qnil;
+
+ DEFVAR_INT ("minibuffer-scroll-overlap", &minibuffer_scroll_overlap,
+ "*Number of characters of overlap when scrolling a one-line window.\n\
+This commonly affects the minibuffer window, hence the name of the variable.");
+ minibuffer_scroll_overlap = 20;
}
/* initialize the window system */
if (!noninteractive)
{
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (root_window)));
- XSETFASTINT (XWINDOW (root_window)->top, 0);
- set_window_height (root_window, FRAME_HEIGHT (f) - 1, 0);
+ XSETFASTINT (XWINDOW (root_window)->top, FRAME_MENU_BAR_LINES (f));
+ set_window_height (root_window,
+ FRAME_HEIGHT (f) - 1 - FRAME_MENU_BAR_LINES (f),
+ 0);
XSETFASTINT (mini_w->top, FRAME_HEIGHT (f) - 1);
set_window_height (minibuf_window, 1, 0);