/* Display generation from window structure and buffer text.
- Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1988, 1993 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
/*#include <ctype.h>*/
#undef NULL
#include "lisp.h"
-#include "screen.h"
+#include "frame.h"
#include "window.h"
#include "termchar.h"
#include "dispextern.h"
#include "commands.h"
#include "macros.h"
#include "disptab.h"
+#include "termhooks.h"
extern int interrupt_input;
extern int command_loop_level;
#define max(a, b) ((a) > (b) ? (a) : (b))
/* The buffer position of the first character appearing
- entirely or partially on the current screen line.
- Or zero, which disables the optimization for the current screen line. */
+ entirely or partially on the current frame line.
+ Or zero, which disables the optimization for the current frame line. */
static int this_line_bufpos;
/* Number of characters past the end of this line,
including the terminating newline */
static int this_line_endpos;
-/* The vertical position of this screen line. */
+/* The vertical position of this frame line. */
static int this_line_vpos;
-/* Hpos value for start of display on this screen line.
+/* Hpos value for start of display on this frame line.
Usually zero, but negative if first character really began
on previous line */
static int this_line_start_hpos;
static struct buffer *this_line_buffer;
/* Set by try_window_id to the vpos of first of any lines
- scrolled on to the bottom of the screen. These lines should
+ scrolled on to the bottom of the frame. These lines should
not be included in any general scroll computation. */
static int scroll_bottom_vpos;
/* Value of echo_area_glyphs when it was last acted on.
- If this is nonzero, there is a message on the screen
+ If this is nonzero, there is a message on the frame
in the minibuffer and it should be erased as soon
as it is no longer requested to appear. */
char *previous_echo_glyphs;
-/* Nonzero means truncate lines in all windows less wide than the screen */
+/* Nonzero means truncate lines in all windows less wide than the frame */
int truncate_partial_width_windows;
Lisp_Object Vglobal_mode_string;
Lisp_Object Voverlay_arrow_string;
/* Values of those variables at last redisplay. */
-Lisp_Object last_arrow_position, last_arrow_string;
+static Lisp_Object last_arrow_position, last_arrow_string;
/* Nonzero if overlay arrow has been displayed once in this window. */
static int overlay_arrow_seen;
-/* If cursor motion alone moves point off screen,
+/* Nonzero means highlight the region even in nonselected windows. */
+static int highlight_nonselected_windows;
+
+/* If cursor motion alone moves point off frame,
Try scrolling this many lines up or down if that will bring it back. */
int scroll_step;
keyboard.c refers to this. */
int buffer_shared;
-/* display_text_line sets these to the screen position (origin 0) of point,
+/* display_text_line sets these to the frame position (origin 0) of point,
whether the window is selected or not.
Set one to -1 first to determine whether point was found afterwards. */
static char *fmodetrunc ();
static char *decode_mode_spec ();
static int display_string ();
+static void display_menu_bar ();
+static int display_count_lines ();
/* Prompt to display in front of the minibuffer contents */
char *minibuf_prompt;
since last redisplay that finished */
int windows_or_buffers_changed;
-\f
-#ifndef MULTI_SCREEN
-
-DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
- "Clear the screen and output again what is supposed to appear on it.")
- ()
-{
- if (screen_height == 0) abort (); /* Some bug zeros some core */
- clear_screen ();
- fflush (stdout);
- clear_screen_records ();
- if (screen_height == 0) abort (); /* Some bug zeros some core */
- windows_or_buffers_changed++;
- /* Mark all windows as INaccurate,
- so that every window will have its redisplay done. */
- mark_window_display_accurate (XWINDOW (minibuf_window)->prev, 0);
- if (screen_height == 0) abort (); /* Some bug zeros some core */
- return Qnil;
-}
+/* Nonzero after display_mode_line if %l was used
+ and it displayed a line number. */
+int line_number_displayed;
-#endif /* not MULTI_SCREEN */
+/* Maximum buffer size for which to display line numbers. */
+int line_number_display_limit;
\f
-/* Buffer used for messages formatted by `message'. */
-char *message_buf;
-
-/* Nonzero if message_buf is being used by print;
- zero if being used by message. */
-int message_buf_print;
-
-/* dump an informative message to the minibuf */
-/* VARARGS 1 */
-
+/* Specify m, a string, as a message in the minibuf. If m is 0, clear out
+ any existing message, and let the minibuffer text show through. */
void
-message (m, a1, a2, a3)
+message1 (m)
char *m;
{
if (noninteractive)
if (noninteractive_need_newline)
putc ('\n', stderr);
noninteractive_need_newline = 0;
- fprintf (stderr, m, a1, a2, a3);
- fprintf (stderr, "\n");
+ if (cursor_in_echo_area != 0)
+ fprintf (stderr, "%s", m);
+ else
+ fprintf (stderr, "%s\n", m);
fflush (stderr);
}
- /* A null message buffer means that the screen hasn't really been
+ /* A null message buffer means that the frame hasn't really been
initialized yet. Error messages get reported properly by
cmd_error, so this must be just an informative message; toss it. */
- else if (INTERACTIVE && SCREEN_MESSAGE_BUF (selected_screen))
+ else if (INTERACTIVE && FRAME_MESSAGE_BUF (selected_frame))
{
-#ifdef MULTI_SCREEN
- choose_minibuf_screen ();
- Fmake_screen_visible (WINDOW_SCREEN (XWINDOW (minibuf_window)));
+#ifdef MULTI_FRAME
+ Lisp_Object minibuf_frame;
+
+ choose_minibuf_frame ();
+ minibuf_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
+ FRAME_SAMPLE_VISIBILITY (XFRAME (minibuf_frame));
+ if (FRAME_VISIBLE_P (selected_frame)
+ && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame)))
+ Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window)));
#endif
-#ifdef NO_ARG_ARRAY
- int a[3];
- a[0] = a1;
- a[1] = a2;
- a[2] = a3;
-
- doprnt (SCREEN_MESSAGE_BUF (selected_screen),
- SCREEN_WIDTH (selected_screen), m, 0, 3, a);
-#else
- doprnt (SCREEN_MESSAGE_BUF (selected_screen),
- SCREEN_WIDTH (selected_screen), m, 0, 3, &a1);
-#endif /* NO_ARG_ARRAY */
-
- echo_area_glyphs = SCREEN_MESSAGE_BUF (selected_screen);
-
- /* Print should start at the beginning of the message
- buffer next time. */
- message_buf_print = 0;
+ if (m)
+ echo_area_glyphs = m;
+ else
+ echo_area_glyphs = previous_echo_glyphs = 0;
do_pending_window_change ();
echo_area_display ();
- update_screen (XSCREEN (XWINDOW (minibuf_window)->screen), 1, 1);
+ update_frame (XFRAME (XWINDOW (minibuf_window)->frame), 1, 1);
do_pending_window_change ();
}
}
-/* Specify m, a string, as a message in the minibuf. */
+/* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
+ zero if being used by message. */
+int message_buf_print;
+
+/* 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
-message1 (m)
+message (m, a1, a2, a3)
char *m;
{
if (noninteractive)
{
- if (noninteractive_need_newline)
- putc ('\n', stderr);
- noninteractive_need_newline = 0;
- fprintf (stderr, "%s\n", m);
- fflush (stderr);
+ if (m)
+ {
+ if (noninteractive_need_newline)
+ putc ('\n', stderr);
+ noninteractive_need_newline = 0;
+ fprintf (stderr, m, a1, a2, a3);
+ if (cursor_in_echo_area == 0)
+ fprintf (stderr, "\n");
+ fflush (stderr);
+ }
}
- /* A null message buffer means that the screen hasn't really been
- initialized yet. Error messages get reported properly by
- cmd_error, so this must be just an informative message; toss it. */
- else if (INTERACTIVE && SCREEN_MESSAGE_BUF (selected_screen))
+ else if (INTERACTIVE)
{
-#ifdef MULTI_SCREEN
- choose_minibuf_screen ();
- Fmake_screen_visible (WINDOW_SCREEN (XWINDOW (minibuf_window)));
+ /* The frame whose minibuffer we're going to display the message on.
+ It may be larger than the selected frame, so we need
+ to use its buffer, not the selected frame's buffer. */
+ FRAME_PTR echo_frame;
+#ifdef MULTI_FRAME
+ choose_minibuf_frame ();
+ echo_frame = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
+#else
+ echo_frame = selected_frame;
#endif
- echo_area_glyphs = m;
- do_pending_window_change ();
- echo_area_display ();
- update_screen (XSCREEN (XWINDOW (minibuf_window)->screen), 1, 1);
- do_pending_window_change ();
+ /* A null message buffer means that the frame hasn't really been
+ initialized yet. Error messages get reported properly by
+ cmd_error, so this must be just an informative message; toss it. */
+ if (FRAME_MESSAGE_BUF (echo_frame))
+ {
+ if (m)
+ {
+ {
+#ifdef NO_ARG_ARRAY
+ int a[3];
+ a[0] = a1;
+ a[1] = a2;
+ a[2] = a3;
+
+ doprnt (FRAME_MESSAGE_BUF (echo_frame),
+ FRAME_WIDTH (echo_frame), m, 0, 3, a);
+#else
+ doprnt (FRAME_MESSAGE_BUF (echo_frame),
+ FRAME_WIDTH (echo_frame), m, 0, 3, &a1);
+#endif /* NO_ARG_ARRAY */
+ }
+
+ message1 (FRAME_MESSAGE_BUF (echo_frame));
+ }
+ else
+ message1 (0);
+
+ /* Print should start at the beginning of the message
+ buffer next time. */
+ message_buf_print = 0;
+ }
}
}
echo_area_display ()
{
register int vpos;
- SCREEN_PTR s;
+ FRAME_PTR f;
+
+#ifdef MULTI_FRAME
+ choose_minibuf_frame ();
+#endif
-#ifdef MULTI_SCREEN
- choose_minibuf_screen ();
- s = XSCREEN (WINDOW_SCREEN (XWINDOW (minibuf_window)));
+ f = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
- if (! SCREEN_VISIBLE_P (s))
+ if (! FRAME_VISIBLE_P (f))
return;
-#endif
- if (screen_garbaged)
+ if (frame_garbaged)
{
- Fredraw_display ();
- screen_garbaged = 0;
+ redraw_garbaged_frames ();
+ frame_garbaged = 0;
}
if (echo_area_glyphs || minibuf_level == 0)
{
vpos = XFASTINT (XWINDOW (minibuf_window)->top);
- get_display_line (s, vpos, 0);
+ get_display_line (f, vpos, 0);
display_string (XWINDOW (minibuf_window), vpos,
echo_area_glyphs ? echo_area_glyphs : "",
- 0, 0, 0, SCREEN_WIDTH (s));
+ 0, 0, 0, FRAME_WIDTH (f));
/* If desired cursor location is on this line, put it at end of text */
- if (SCREEN_CURSOR_Y (s) == vpos)
- SCREEN_CURSOR_X (s) = s->desired_glyphs->used[vpos];
+ if (FRAME_CURSOR_Y (f) == vpos)
+ FRAME_CURSOR_X (f) = FRAME_DESIRED_GLYPHS (f)->used[vpos];
+
+ /* Fill the rest of the minibuffer window with blank lines. */
+ {
+ int i;
+
+ for (i = vpos + 1; i < vpos + XWINDOW (minibuf_window)->height; i++)
+ {
+ get_display_line (f, i, 0);
+ display_string (XWINDOW (minibuf_window), vpos,
+ "", 0, 0, 0, FRAME_WIDTH (f));
+ }
+ }
}
else if (!EQ (minibuf_window, selected_window))
windows_or_buffers_changed++;
previous_echo_glyphs = echo_area_glyphs;
}
\f
-/* Do a screen update, taking possible shortcuts into account.
+/* Do a frame update, taking possible shortcuts into account.
This is the main external entry point for redisplay.
If the last redisplay displayed an echo area message and that
if (noninteractive)
return;
- /* Notice any pending interrupt request to change screen size. */
+ /* Set the visible flags for all frames.
+ Do this before checking for resized or garbaged frames; they want
+ to know if their frames are visible.
+ See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
+ {
+ Lisp_Object tail, frame;
+
+ FOR_EACH_FRAME (tail, frame)
+ FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
+ }
+
+ /* Notice any pending interrupt request to change frame size. */
do_pending_window_change ();
- if (screen_garbaged)
+ if (frame_garbaged)
{
- Fredraw_display ();
- screen_garbaged = 0;
+ redraw_garbaged_frames ();
+ frame_garbaged = 0;
}
/* Normally the message* functions will have already displayed and
- updated the echo area, but the screen may have been trashed, or
+ updated the echo area, but the frame may have been trashed, or
the update may have been preempted, so display the echo area
again here. */
if (echo_area_glyphs || previous_echo_glyphs)
update_mode_lines++;
}
- SCREEN_SCROLL_BOTTOM_VPOS (XSCREEN (w->screen)) = -1;
+ FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w->frame)) = -1;
all_windows = update_mode_lines || buffer_shared > 1;
/* If specs for an arrow have changed, do thorough redisplay
to ensure we remove any arrow that should no longer exist. */
- if (Voverlay_arrow_position != last_arrow_position
- || Voverlay_arrow_string != last_arrow_string)
+ if (! EQ (Voverlay_arrow_position, last_arrow_position)
+ || ! EQ (Voverlay_arrow_string, last_arrow_string))
all_windows = 1, clip_changed = 1;
+ /* If showing region, and mark has changed, must redisplay whole window. */
+ if (((!NILP (Vtransient_mark_mode)
+ && !NILP (XBUFFER (w->buffer)->mark_active))
+ != !NILP (w->region_showing))
+ || !EQ (w->region_showing,
+ Fmarker_position (XBUFFER (w->buffer)->mark)))
+ this_line_bufpos = -1;
+
tlbufpos = this_line_bufpos;
tlendpos = this_line_endpos;
- if (!all_windows && tlbufpos > 0 && NULL (w->update_mode_line)
- && SCREEN_VISIBLE_P (XSCREEN (w->screen))
+ if (!all_windows && tlbufpos > 0 && NILP (w->update_mode_line)
+ && FRAME_VISIBLE_P (XFRAME (w->frame))
/* Make sure recorded data applies to current buffer, etc */
&& this_line_buffer == current_buffer
&& current_buffer == XBUFFER (w->buffer)
- && NULL (w->force_start)
+ && NILP (w->force_start)
/* Point must be on the line that we have info recorded about */
&& point >= tlbufpos
&& point <= Z - tlendpos
&& (XFASTINT (w->last_modified) >= MODIFF
|| (beg_unchanged >= tlbufpos - 1
&& GPT >= tlbufpos
+ /* If selective display, can't optimize
+ if the changes start at the beginning of the line. */
+ && ((XTYPE (current_buffer->selective_display) == Lisp_Int
+ && XINT (current_buffer->selective_display) > 0
+ ? (beg_unchanged >= tlbufpos
+ && GPT > tlbufpos)
+ : 1))
&& end_unchanged >= tlendpos
&& Z - GPT >= tlendpos)))
{
if (cursor_vpos >= 0 && this_line_bufpos
&& this_line_endpos == tlendpos)
{
- if (XFASTINT (w->width) != SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (w))))
+ if (XFASTINT (w->width) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w))))
preserve_other_columns (w);
goto update;
}
}
goto update;
}
- else
+ /* If highlighting the region, we can't just move the cursor. */
+ else if (! (!NILP (Vtransient_mark_mode)
+ && !NILP (current_buffer->mark_active))
+ && NILP (w->region_showing))
{
pos = *compute_motion (tlbufpos, 0,
XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0,
point, 2, - (1 << (SHORTBITS - 1)),
- XFASTINT (w->width) - 1
- - (XFASTINT (w->width) + XFASTINT (w->left)
- != SCREEN_WIDTH (selected_screen)),
- XINT (w->hscroll), 0);
+ window_internal_width (w) - 1,
+ XINT (w->hscroll),
+ pos_tab_offset (w, tlbufpos));
if (pos.vpos < 1)
{
- SCREEN_CURSOR_X (selected_screen)
+ FRAME_CURSOR_X (selected_frame)
= XFASTINT (w->left) + max (pos.hpos, 0);
- SCREEN_CURSOR_Y (selected_screen) = this_line_vpos;
+ FRAME_CURSOR_Y (selected_frame) = this_line_vpos;
goto update;
}
else
}
cancel:
/* Text changed drastically or point moved off of line */
- cancel_line (this_line_vpos, selected_screen);
+ cancel_line (this_line_vpos, selected_frame);
}
this_line_bufpos = 0;
if (all_windows)
{
-#ifdef MULTI_SCREEN
- Lisp_Object tail;
+ Lisp_Object tail, frame;
+
+#ifdef HAVE_X_WINDOWS
+ /* Since we're doing a thorough redisplay, we might as well
+ recompute all our display faces. */
+ clear_face_vector ();
+#endif
/* Recompute # windows showing selected buffer.
This will be incremented each time such a window is displayed. */
buffer_shared = 0;
- for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
+ FOR_EACH_FRAME (tail, frame)
{
- SCREEN_PTR s;
+ FRAME_PTR f = XFRAME (frame);
- if (XTYPE (XCONS (tail)->car) != Lisp_Screen)
- continue;
+ /* Mark all the scroll bars to be removed; we'll redeem the ones
+ we want when we redisplay their windows. */
+ if (condemn_scroll_bars_hook)
+ (*condemn_scroll_bars_hook) (f);
+
+ if (FRAME_VISIBLE_P (f))
+ redisplay_windows (FRAME_ROOT_WINDOW (f));
- s = XSCREEN (XCONS (tail)->car);
- if (s->visible)
- /* Redraw its windows. */
- redisplay_windows (SCREEN_ROOT_WINDOW (s));
+ /* Any scroll bars which redisplay_windows should have nuked
+ should now go away. */
+ if (judge_scroll_bars_hook)
+ (*judge_scroll_bars_hook) (f);
}
-#else
- redisplay_windows (SCREEN_ROOT_WINDOW (s));
-#endif /* not MULTI_SCREEN */
}
- else if (SCREEN_VISIBLE_P (selected_screen))
+ else if (FRAME_VISIBLE_P (selected_frame))
{
redisplay_window (selected_window, 1);
- if (XFASTINT (w->width) != SCREEN_WIDTH (selected_screen))
+ if (XFASTINT (w->width) != FRAME_WIDTH (selected_frame))
preserve_other_columns (w);
}
unrequest_sigio ();
stop_polling ();
-#ifdef MULTI_SCREEN
+#ifdef MULTI_FRAME
if (all_windows)
{
Lisp_Object tail;
pause = 0;
- for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
{
- SCREEN_PTR s;
+ FRAME_PTR f;
- if (XTYPE (XCONS (tail)->car) != Lisp_Screen)
+ if (XTYPE (XCONS (tail)->car) != Lisp_Frame)
continue;
- s = XSCREEN (XCONS (tail)->car);
- if (s->visible)
+ f = XFRAME (XCONS (tail)->car);
+ if (FRAME_VISIBLE_P (f))
{
- pause |= update_screen (s, 0, 0);
+ pause |= update_frame (f, 0, 0);
if (!pause)
- mark_window_display_accurate (s->root_window, 1);
+ mark_window_display_accurate (f->root_window, 1);
}
}
}
else
-#endif /* MULTI_SCREEN */
+#endif /* MULTI_FRAME */
{
- if (SCREEN_VISIBLE_P (selected_screen))
- pause = update_screen (selected_screen, 0, 0);
-#ifdef MULTI_SCREEN
+ if (FRAME_VISIBLE_P (selected_frame))
+ pause = update_frame (selected_frame, 0, 0);
+
/* We may have called echo_area_display at the top of this
- function. If the echo area is on another screen, that may
- have put text on a screen other than the selected one, so the
- above call to update_screen would not have caught it. Catch
+ function. If the echo area is on another frame, that may
+ have put text on a frame other than the selected one, so the
+ above call to update_frame would not have caught it. Catch
it here. */
{
- SCREEN_PTR mini_screen =
- XSCREEN (WINDOW_SCREEN (XWINDOW (minibuf_window)));
+ FRAME_PTR mini_frame =
+ XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
- if (mini_screen != selected_screen)
- pause |= update_screen (mini_screen, 0, 0);
+ if (mini_frame != selected_frame)
+ pause |= update_frame (mini_frame, 0, 0);
}
-#endif
}
- /* If screen does not match, prevent doing single-line-update next time.
+ /* If frame does not match, prevent doing single-line-update next time.
Also, don't forget to check every line to update the arrow. */
if (pause)
{
this_line_bufpos = 0;
- if (!NULL (last_arrow_position))
+ if (!NILP (last_arrow_position))
{
last_arrow_position = Qt;
last_arrow_string = Qt;
}
- /* If we pause after scrolling, some lines in current_screen
+ /* If we pause after scrolling, some lines in current_frame
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) != SCREEN_WIDTH (selected_screen))
+ if (XFASTINT (w->width) != FRAME_WIDTH (selected_frame))
update_mode_lines = 1;
}
- /* Now text on screen agrees with windows, so
+ /* Now text on frame agrees with windows, so
put info into the windows for partial redisplay to follow */
if (!pause)
end_unchanged = BUF_Z (b) - BUF_GPT (b);
XFASTINT (w->last_point) = BUF_PT (b);
- XFASTINT (w->last_point_x) = SCREEN_CURSOR_X (selected_screen);
- XFASTINT (w->last_point_y) = SCREEN_CURSOR_Y (selected_screen);
+ XFASTINT (w->last_point_x) = FRAME_CURSOR_X (selected_frame);
+ XFASTINT (w->last_point_y) = FRAME_CURSOR_Y (selected_frame);
if (all_windows)
- mark_window_display_accurate (XWINDOW (minibuf_window)->prev, 1);
+ mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame), 1);
else
{
w->update_mode_line = Qnil;
request_sigio ();
start_polling ();
- /* Change screen size now if a change is pending. */
+ /* Change frame size now if a change is pending. */
do_pending_window_change ();
}
{
register struct window *w;
- for (;!NULL (window); window = w->next)
+ for (;!NILP (window); window = w->next)
{
+ if (XTYPE (window) != Lisp_Window) abort ();
w = XWINDOW (window);
- if (!NULL (w->buffer))
- XFASTINT (w->last_modified)
- = !flag ? 0
- : XBUFFER (w->buffer) == current_buffer
- ? MODIFF : BUF_MODIFF (XBUFFER (w->buffer));
+ if (!NILP (w->buffer))
+ {
+ XFASTINT (w->last_modified)
+ = !flag ? 0
+ : XBUFFER (w->buffer) == current_buffer
+ ? MODIFF : BUF_MODIFF (XBUFFER (w->buffer));
+
+ /* 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)
+ && !NILP (XBUFFER (w->buffer)->mark_active)
+ ? Fmarker_position (XBUFFER (w->buffer)->mark)
+ : Qnil);
+ }
+
w->window_end_valid = Qt;
w->update_mode_line = Qnil;
- if (!NULL (w->vchild))
+ if (!NILP (w->vchild))
mark_window_display_accurate (w->vchild, flag);
- if (!NULL (w->hchild))
+ if (!NILP (w->hchild))
mark_window_display_accurate (w->hchild, flag);
}
redisplay_windows (window)
Lisp_Object window;
{
- for (; !NULL (window); window = XWINDOW (window)->next)
+ for (; !NILP (window); window = XWINDOW (window)->next)
redisplay_window (window, 0);
}
int just_this_one;
{
register struct window *w = XWINDOW (window);
- SCREEN_PTR s = XSCREEN (w->screen);
+ FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
int height;
register int lpoint = point;
struct buffer *old = current_buffer;
- register int width = XFASTINT (w->width) - 1
- - (XFASTINT (w->width) + XFASTINT (w->left)
- != SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (w))));
+ register int width = window_internal_width (w) - 1;
register int startp;
register int hscroll = XINT (w->hscroll);
struct position pos;
- int opoint;
+ int opoint = point;
int tem;
int window_needs_modeline;
- if (SCREEN_HEIGHT (s) == 0) abort (); /* Some bug zeros some core */
+ if (FRAME_HEIGHT (f) == 0) abort (); /* Some bug zeros some core */
/* If this is a combination window, do its children; that's all. */
- if (!NULL (w->vchild))
+ if (!NILP (w->vchild))
{
redisplay_windows (w->vchild);
return;
}
- if (!NULL (w->hchild))
+ if (!NILP (w->hchild))
{
redisplay_windows (w->hchild);
return;
}
- if (NULL (w->buffer))
+ if (NILP (w->buffer))
abort ();
height = window_internal_height (w);
{
if (echo_area_glyphs)
/* We've already displayed the echo area glyphs, if any. */
- return;
+ goto finish_scroll_bars;
}
else
{
/* This is a minibuffer, but it's not the currently active one, so
clear it. */
- int vpos = XFASTINT (XWINDOW (SCREEN_MINIBUF_WINDOW (s))->top);
+ int vpos = XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top);
int i;
for (i = 0; i < height; i++)
{
- get_display_line (s, vpos + i, 0);
+ get_display_line (f, vpos + i, 0);
display_string (w, vpos + i, "", 0, 0, 0, width);
}
- return;
+ goto finish_scroll_bars;
}
}
SET_PT (marker_position (w->pointm));
if (point < BEGV)
{
- point = BEGV;
+ SET_PT (BEGV);
Fset_marker (w->pointm, make_number (point), Qnil);
}
else if (point > (ZV - 1))
{
- point = ZV;
+ SET_PT (ZV);
Fset_marker (w->pointm, make_number (point), Qnil);
}
}
startp = marker_position (w->start);
/* Handle case where place to start displaying has been specified,
- unless the specified location is outside the visible range. */
- if (!NULL (w->force_start))
+ unless the specified location is outside the accessible range. */
+ if (!NILP (w->force_start))
{
+ /* Forget any recorded base line for line number display. */
+ w->base_line_number = Qnil;
w->update_mode_line = Qt;
w->force_start = Qnil;
XFASTINT (w->last_modified) = 0;
try_window (window, startp);
if (cursor_vpos < 0)
{
+ /* ??? What should happen here if highlighting a region? */
/* If point does not appear, move point so it does appear */
pos = *compute_motion (startp, 0,
((EQ (window, minibuf_window) && startp == 1)
- (1 << (SHORTBITS - 1)),
width, hscroll, pos_tab_offset (w, startp));
SET_PT (pos.bufpos);
- if (w != XWINDOW (SCREEN_SELECTED_WINDOW (s)))
+ if (w != XWINDOW (FRAME_SELECTED_WINDOW (f)))
Fset_marker (w->pointm, make_number (point), Qnil);
else
{
lpoint = point;
- SCREEN_CURSOR_X (s) = max (0, pos.hpos) + XFASTINT (w->left);
- SCREEN_CURSOR_Y (s) = pos.vpos + XFASTINT (w->top);
+ FRAME_CURSOR_X (f) = max (0, pos.hpos) + XFASTINT (w->left);
+ FRAME_CURSOR_Y (f) = pos.vpos + XFASTINT (w->top);
}
}
goto done;
}
/* Handle case where text has not changed, only point,
- and it has not moved off the screen */
+ and it has not moved off the frame */
/* This code is not used for minibuffer for the sake of
the case of redisplaying to replace an echo area message;
if (XFASTINT (w->last_modified) >= MODIFF
&& point >= startp && !clip_changed
- && (just_this_one || XFASTINT (w->width) == SCREEN_WIDTH (s))
+ && (just_this_one || XFASTINT (w->width) == FRAME_WIDTH (f))
+ /* Can't use this case if highlighting a region. */
+ && !(!NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active))
+ && NILP (w->region_showing)
&& !EQ (window, minibuf_window))
{
pos = *compute_motion (startp, 0, (hscroll ? 1 - hscroll : 0),
if (pos.vpos < height)
{
- /* Ok, point is still on screen */
- if (w == XWINDOW (SCREEN_SELECTED_WINDOW (s)))
+ /* Ok, point is still on frame */
+ if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)))
{
/* These variables are supposed to be origin 1 */
- SCREEN_CURSOR_X (s) = max (0, pos.hpos) + XFASTINT (w->left);
- SCREEN_CURSOR_Y (s) = pos.vpos + XFASTINT (w->top);
+ FRAME_CURSOR_X (f) = max (0, pos.hpos) + XFASTINT (w->left);
+ FRAME_CURSOR_Y (f) = pos.vpos + XFASTINT (w->top);
}
/* This doesn't do the trick, because if a window to the right of
this one must be redisplayed, this does nothing because there
- is nothing in DesiredScreen yet, and then the other window is
+ 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) != SCREEN_WIDTH (s))
+ if (XFASTINT (w->width) != FRAME_WIDTH (f))
preserve_my_columns (w);
*/
goto done;
}
/* If current starting point was originally the beginning of a line
but no longer is, find a new starting point. */
- else if (!NULL (w->start_at_line_beg)
+ else if (!NILP (w->start_at_line_beg)
&& !(startp == BEGV
|| FETCH_CHAR (startp - 1) == '\n'))
{
else if (just_this_one && !MINI_WINDOW_P (w)
&& point >= startp
&& XFASTINT (w->last_modified)
+ /* or else vmotion on first line won't work. */
+ && ! NILP (w->start_at_line_beg)
&& ! EQ (w->window_end_valid, Qnil)
&& do_id && !clip_changed
&& !blank_end_of_window
- && XFASTINT (w->width) == SCREEN_WIDTH (s)
+ && XFASTINT (w->width) == FRAME_WIDTH (f)
+ /* Can't use this case if highlighting a region. */
+ && !(!NILP (Vtransient_mark_mode)
+ && !NILP (current_buffer->mark_active))
+ && NILP (w->region_showing)
&& EQ (last_arrow_position, Voverlay_arrow_position)
&& EQ (last_arrow_string, Voverlay_arrow_string)
- && (tem = try_window_id (SCREEN_SELECTED_WINDOW (s)))
+ && (tem = try_window_id (FRAME_SELECTED_WINDOW (f)))
&& tem != -2)
{
/* tem > 0 means success. tem == -1 means choose new start.
|| (XFASTINT (w->last_modified) >= MODIFF)))
{
/* Try to redisplay starting at same place as before */
- /* If point has not moved off screen, accept the results */
+ /* If point has not moved off frame, accept the results */
try_window (window, startp);
if (cursor_vpos >= 0)
- goto done;
+ {
+ if (!just_this_one || 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);
}
{
try_window (window, pos.bufpos);
if (cursor_vpos >= 0)
- goto done;
+ {
+ if (!just_this_one || 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);
}
/* Finally, just choose place to start which centers point */
recenter:
+ /* Forget any previously recorded base line for line number display. */
+ w->base_line_number = Qnil;
+
pos = *vmotion (point, - height / 2, width, hscroll, window);
try_window (window, pos.bufpos);
(startp == BEGV || FETCH_CHAR (startp - 1) == '\n') ? Qt : Qnil;
done:
- /* If window not full width, must redo its mode line
- if the window to its side is being redone */
- if ((!NULL (w->update_mode_line)
- || (!just_this_one && width < SCREEN_WIDTH (s) - 1))
+ if ((!NILP (w->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)
+ || INTEGERP (w->base_line_pos))
&& height != XFASTINT (w->height))
display_mode_line (w);
+ if (! line_number_displayed
+ && ! BUFFERP (w->base_line_pos))
+ {
+ w->base_line_pos = Qnil;
+ w->base_line_number = Qnil;
+ }
+
+ /* When we reach a frame's selected window, redo the frame's menu bar. */
+ if (!NILP (w->update_mode_line)
+ && FRAME_MENU_BAR_LINES (f) > 0
+ && EQ (FRAME_SELECTED_WINDOW (f), window))
+ display_menu_bar (w);
+
+ finish_scroll_bars:
+ if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+ {
+ int start, end, whole;
+
+ /* Calculate the start and end positions for the current window.
+ At some point, it would be nice to choose between scrollbars
+ which reflect the whole buffer size, with special markers
+ indicating narrowing, and scrollbars which reflect only the
+ visible region.
+
+ Note that minibuffers sometimes aren't displaying any text. */
+ if (! MINI_WINDOW_P (w)
+ || (w == XWINDOW (minibuf_window) && ! echo_area_glyphs))
+ {
+ whole = ZV - BEGV;
+ start = startp - BEGV;
+ /* I don't think this is guaranteed to be right. For the
+ moment, we'll pretend it is. */
+ end = (Z - XINT (w->window_end_pos)) - BEGV;
+
+ if (end < start) end = start;
+ if (whole < (end - start)) whole = end - start;
+ }
+ else
+ start = end = whole = 0;
+
+ /* Indicate what this scroll bar ought to be displaying now. */
+ (*set_vertical_scroll_bar_hook) (w, end - start, whole, start - 1);
+
+ /* Note that we actually used the scroll bar attached to this window,
+ so it shouldn't be deleted at the end of redisplay. */
+ (*redeem_scroll_bar_hook) (w);
+ }
SET_PT (opoint);
current_buffer = old;
register int vpos = XFASTINT (w->top);
register int last_text_vpos = vpos;
int tab_offset = pos_tab_offset (w, pos);
- SCREEN_PTR s = XSCREEN (w->screen);
- int width = XFASTINT (w->width) - 1
- - (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s));
+ FRAME_PTR f = XFRAME (w->frame);
+ int width = window_internal_width (w) - 1;
struct position val;
Fset_marker (w->start, make_number (pos), Qnil);
}
/* If last line is continued in middle of character,
- include the split character in the text considered on the screen */
+ include the split character in the text considered on the frame */
if (val.hpos < (XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0))
pos++;
- /* If bottom just moved off end of screen, change mode line percentage. */
+ /* If bottom just moved off end of frame, change mode line percentage. */
if (XFASTINT (w->window_end_pos) == 0
&& Z != pos)
w->update_mode_line = Qt;
- /* Say where last char on screen will be, once redisplay is finished. */
+ /* Say where last char on frame will be, once redisplay is finished. */
XFASTINT (w->window_end_pos) = Z - pos;
XFASTINT (w->window_end_vpos) = last_text_vpos - XFASTINT (w->top);
/* But that is not valid info until redisplay finishes. */
int pos;
register struct window *w = XWINDOW (window);
register int height = window_internal_height (w);
- SCREEN_PTR s = XSCREEN (w->screen);
+ FRAME_PTR f = XFRAME (w->frame);
int top = XFASTINT (w->top);
int start = marker_position (w->start);
- int width = XFASTINT (w->width) - 1
- - (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s));
+ int width = window_internal_width (w) - 1;
int hscroll = XINT (w->hscroll);
int lmargin = hscroll > 0 ? 1 - hscroll : 0;
register int vpos;
{
if (point < bp.bufpos && !bp.contin)
{
- /* All changes are below the screen, and point is on the screen.
- We don't need to change the screen at all.
+ /* All changes are below the frame, and point is on the frame.
+ We don't need to change the frame at all.
But we need to update window_end_pos to account for
any change in buffer size. */
bp = *compute_motion (start, 0, lmargin,
vpos = bp.vpos;
- /* Find beginning of that screen line. Must display from there. */
+ /* Find beginning of that frame line. Must display from there. */
bp = *vmotion (bp.bufpos, 0, width, hscroll, window);
pos = bp.bufpos;
return -1;
/* If about to start displaying at the beginning of a continuation line,
- really start with previous screen line, in case it was not
+ really start with previous frame line, in case it was not
continued when last redisplayed */
- if (bp.contin && bp.bufpos - 1 == beg_unchanged && vpos > 0)
+ if ((bp.contin && bp.bufpos - 1 == beg_unchanged && vpos > 0)
+ ||
+ /* Likewise if we have to worry about selective display. */
+ (XTYPE (current_buffer->selective_display) == Lisp_Int
+ && XINT (current_buffer->selective_display) > 0
+ && bp.bufpos - 1 == beg_unchanged && vpos > 0))
{
bp = *vmotion (bp.bufpos, -1, width, hscroll, window);
--vpos;
height, - (1 << (SHORTBITS - 1)),
width, hscroll, pos_tab_offset (w, bp.bufpos));
- /* If changes reach past the text available on the screen,
- just display rest of screen. */
+ /* If changes reach past the text available on the frame,
+ just display rest of frame. */
if (ep.bufpos > Z - XFASTINT (w->window_end_pos))
stop_vpos = height;
else
10000, 0, width, hscroll, epto);
scroll_amount = xp.vpos - XFASTINT (w->window_end_vpos);
- /* Is everything on screen below the changes whitespace?
+ /* Is everything on frame below the changes whitespace?
If so, no scrolling is really necessary. */
for (i = ep.bufpos; i < xp.bufpos; i++)
{
XFASTINT (w->window_end_vpos) += scroll_amount;
- /* Before doing any scrolling, verify that point will be on screen. */
+ /* Before doing any scrolling, verify that point will be on frame. */
if (point > ep.bufpos && !(point <= xp.bufpos && xp.bufpos < height))
{
if (point <= xp.bufpos)
/* In this path, we have altered window_end_vpos
and not left it negative.
We must make sure that, in case display is preempted
- before the screen changes to reflect what we do here,
+ before the frame changes to reflect what we do here,
further updates will not come to try_window_id
- and assume the screen and window_end_vpos match. */
+ and assume the frame and window_end_vpos match. */
blank_end_of_window = 1;
}
else if (!scroll_amount)
{
/* If reprinting everything is nearly as fast as scrolling,
don't bother scrolling. Can happen if lines are short. */
- if (scroll_cost (s, bp.vpos + top - scroll_amount,
+ if (scroll_cost (f, bp.vpos + top - scroll_amount,
top + height - max (0, scroll_amount),
scroll_amount)
> xp.bufpos - bp.bufpos - 20)
In common case of killing a line, this can save the
following line from being overwritten by scrolling
and therefore having to be redrawn. */
- tem = scroll_screen_lines (s, bp.vpos + top - scroll_amount,
+ tem = scroll_frame_lines (f, bp.vpos + top - scroll_amount,
top + height - max (0, scroll_amount),
scroll_amount);
if (!tem) stop_vpos = height;
/* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
overestimate of cost of reprinting, since xp.bufpos
would end up below the bottom of the window. */
- if (scroll_cost (s, ep.vpos + top - scroll_amount,
+ if (scroll_cost (f, ep.vpos + top - scroll_amount,
top + height - max (0, scroll_amount),
scroll_amount)
> xp.bufpos - ep.bufpos - 20)
/* Return "try normal display with same window-start."
Too bad we can't prevent further scroll-thinking. */
return -2;
- tem = scroll_screen_lines (s, ep.vpos + top - scroll_amount,
+ tem = scroll_frame_lines (f, ep.vpos + top - scroll_amount,
top + height - max (0, scroll_amount),
scroll_amount);
if (!tem) stop_vpos = height;
if (vpos == height)
{
/* If last line is continued in middle of character,
- include the split character in the text considered on the screen */
+ include the split character in the text considered on the frame */
if (val.hpos < lmargin)
val.bufpos++;
XFASTINT (w->window_end_vpos) = last_text_vpos;
{
/* Don't consider these lines for general-purpose scrolling.
That will save time in the scrolling computation. */
- SCREEN_SCROLL_BOTTOM_VPOS (s) = xp.vpos;
+ FRAME_SCROLL_BOTTOM_VPOS (f) = xp.vpos;
vpos = xp.vpos;
pos = xp.bufpos;
val.hpos = lmargin;
cursor_vpos = -1;
}
- /* If bottom just moved off end of screen, change mode line percentage. */
+ /* If bottom just moved off end of frame, change mode line percentage. */
if (XFASTINT (w->window_end_pos) == 0
&& Z != val.bufpos)
w->update_mode_line = Qt;
{
val = *compute_motion (start, 0, lmargin, point, 10000, 10000,
width, hscroll, pos_tab_offset (w, start));
- /* Admit failure if point is off screen now */
+ /* Admit failure if point is off frame now */
if (val.vpos >= height)
{
for (vpos = 0; vpos < height; vpos++)
- cancel_line (vpos + top, s);
+ cancel_line (vpos + top, f);
return 0;
}
cursor_vpos = val.vpos + top;
cursor_hpos = val.hpos + XFASTINT (w->left);
}
- SCREEN_CURSOR_X (s) = max (0, cursor_hpos);
- SCREEN_CURSOR_Y (s) = cursor_vpos;
+ FRAME_CURSOR_X (f) = max (0, cursor_hpos);
+ FRAME_CURSOR_Y (f) = cursor_vpos;
if (debug_end_pos)
{
return 1;
}
\f
-/* Copy glyphs from the rope FROM to T.
+/* 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 (buf != current_buffer)
+ 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_modified)
+ buf->save_modified++;
+ if (BUF_MODIFF (buf) == buf->auto_save_modified)
+ buf->auto_save_modified++;
+
+ BUF_MODIFF (buf) ++;
+}
+
+\f
+/* Copy glyphs from the vector FROM to the rope T.
But don't actually copy the parts that would come in before S.
- Value is T, advanced past the copied data.
+ Value is T, advanced past the copied data. */
- Characters in FROM are grouped into units of `sizeof GLYPH' chars;
- any extra chars at the end of FROM are ignored. */
+GLYPH *
+copy_rope (t, s, from, face)
+ register GLYPH *t; /* Copy to here. */
+ register GLYPH *s; /* Starting point. */
+ Lisp_Object from; /* Data to copy; known to be a vector. */
+ int face; /* Face to apply to glyphs which don't specify one. */
+{
+ register int n = XVECTOR (from)->size;
+ register Lisp_Object *f = XVECTOR (from)->contents;
+
+ while (n--)
+ {
+ if (t >= s) *t = MAKE_GLYPH (GLYPH_CHAR (*f),
+ (GLYPH_FACE (*f)
+ ? GLYPH_FACE (*f)
+ : face));
+ ++t;
+ ++f;
+ }
+ return t;
+}
+
+/* Copy exactly LEN glyphs from FROM into data at T.
+ But don't alter words before S. */
GLYPH *
-copy_rope (t, s, from)
+copy_part_of_rope (t, s, from, len, face)
register GLYPH *t; /* Copy to here. */
register GLYPH *s; /* Starting point. */
- Lisp_Object from; /* Data to copy; known to be a string. */
+ Lisp_Object *from; /* Data to copy. */
+ int len;
+ int face; /* Face to apply to glyphs which don't specify one. */
{
- register int n = XSTRING (from)->size / sizeof (GLYPH);
- register GLYPH *f = (GLYPH *) XSTRING (from)->data;
+ int n = len;
+ register Lisp_Object *f = from;
while (n--)
{
- if (t >= s) *t = *f;
+ if (t >= s) *t = MAKE_GLYPH (GLYPH_CHAR (*f),
+ (GLYPH_FACE (*f)
+ ? GLYPH_FACE (*f)
+ : face));
++t;
++f;
}
TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
- Display on position VPOS on the screen. (origin 0).
+ Display on position VPOS on the frame. (origin 0).
Returns a STRUCT POSITION giving character to start next line with
and where to display it, including a zero or negative hpos.
register unsigned char *p;
GLYPH *endp;
register GLYPH *startp;
- register GLYPH *p1prev;
- SCREEN_PTR s = XSCREEN (w->screen);
+ register GLYPH *p1prev = 0;
+ FRAME_PTR f = XFRAME (w->frame);
int tab_width = XINT (current_buffer->tab_width);
- int ctl_arrow = !NULL (current_buffer->ctl_arrow);
- int width = XFASTINT (w->width) - 1
- - (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s));
+ int ctl_arrow = !NILP (current_buffer->ctl_arrow);
+ int width = window_internal_width (w) - 1;
struct position val;
int lastpos;
int invis;
int hscroll = XINT (w->hscroll);
int truncate = hscroll
|| (truncate_partial_width_windows
- && XFASTINT (w->width) < SCREEN_WIDTH (s))
- || !NULL (current_buffer->truncate_lines);
+ && XFASTINT (w->width) < FRAME_WIDTH (f))
+ || !NILP (current_buffer->truncate_lines);
+
+ /* 1 if we should highlight the region. */
+ int highlight_region
+ = !NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active);
+ int region_beg, region_end;
+
int selective
= XTYPE (current_buffer->selective_display) == Lisp_Int
? XINT (current_buffer->selective_display)
- : !NULL (current_buffer->selective_display) ? -1 : 0;
-#ifndef old
- int selective_e = selective && !NULL (current_buffer->selective_display_ellipses);
-#endif
- register struct screen_glyphs *desired_glyphs = SCREEN_DESIRED_GLYPHS (s);
+ : !NILP (current_buffer->selective_display) ? -1 : 0;
+ register struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (f);
register struct Lisp_Vector *dp = window_display_table (w);
+
+ Lisp_Object default_invis_vector[3];
+ /* Nonzero means display something where there are invisible lines.
+ The precise value is the number of glyphs to display. */
int selective_rlen
- = (selective && dp && XTYPE (DISP_INVIS_ROPE (dp)) == Lisp_String
- ? XSTRING (DISP_INVIS_ROPE (dp))->size / sizeof (GLYPH) : 0);
+ = (selective && dp && XTYPE (DISP_INVIS_VECTOR (dp)) == Lisp_Vector
+ ? XVECTOR (DISP_INVIS_VECTOR (dp))->size
+ : selective && !NILP (current_buffer->selective_display_ellipses)
+ ? 3 : 0);
+ /* This is the sequence of Lisp objects to display
+ when there are invisible lines. */
+ Lisp_Object *invis_vector_contents
+ = (dp && XTYPE (DISP_INVIS_VECTOR (dp)) == Lisp_Vector
+ ? XVECTOR (DISP_INVIS_VECTOR (dp))->contents
+ : default_invis_vector);
+
GLYPH truncator = (dp == 0 || XTYPE (DISP_TRUNC_GLYPH (dp)) != Lisp_Int
? '$' : XINT (DISP_TRUNC_GLYPH (dp)));
GLYPH continuer = (dp == 0 || XTYPE (DISP_CONTINUE_GLYPH (dp)) != Lisp_Int
? '\\' : XINT (DISP_CONTINUE_GLYPH (dp)));
+ /* The next buffer location at which the face should change, due
+ to overlays or text property changes. */
+ int next_face_change;
+
+ /* The face we're currently using. */
+ int current_face = 0;
+
+ XFASTINT (default_invis_vector[2]) = '.';
+ default_invis_vector[0] = default_invis_vector[1] = default_invis_vector[2];
+
hpos += XFASTINT (w->left);
- get_display_line (s, vpos, XFASTINT (w->left));
- if (tab_width <= 0 || tab_width > 20) tab_width = 8;
+ get_display_line (f, vpos, XFASTINT (w->left));
+ 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
+ /* Maybe highlight only in selected window. */
+ && (highlight_nonselected_windows
+ || w == XWINDOW (selected_window)))
+ {
+ region_beg = marker_position (current_buffer->mark);
+ if (PT < region_beg)
+ {
+ region_end = region_beg;
+ region_beg = PT;
+ }
+ else
+ region_end = PT;
+ w->region_showing = Qt;
+ }
+ else
+ region_beg = region_end = -1;
if (MINI_WINDOW_P (w) && start == 1
&& vpos == XFASTINT (w->top))
startp = desired_glyphs->glyphs[vpos] + XFASTINT (w->left);
endp = startp + width;
+ /* Arrange the overlays nicely for our purposes. Usually, we call
+ display_text_line on only one line at a time, in which case this
+ can't really hurt too much, or we call it on lines which appear
+ one after another in the buffer, in which case all calls to
+ recenter_overlay_lists but the first will be pretty cheap. */
+ recenter_overlay_lists (current_buffer, pos);
+
/* Loop generating characters.
Stop at end of buffer, before newline,
- or if reach or pass continuation column. */
-
+ if reach or pass continuation column,
+ or at face change. */
pause = pos;
+ next_face_change = pos;
while (p1 < endp)
{
p1prev = p1;
- if (pos == pause)
+ if (pos >= pause)
{
- if (pos == end)
+ /* Did we hit the end of the visible region of the buffer?
+ Stop here. */
+ if (pos >= end)
break;
+
+ /* Did we reach point? Record the cursor location. */
if (pos == point && cursor_vpos < 0)
{
cursor_vpos = vpos;
cursor_hpos = p1 - startp;
}
+#ifdef HAVE_X_WINDOWS
+ /* 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_X_P (f))
+ current_face = compute_char_face (f, w, pos,
+ region_beg, region_end,
+ &next_face_change);
+#endif
+
pause = end;
+
+ if (pos < next_face_change && next_face_change < pause)
+ pause = next_face_change;
+
+ /* Wouldn't you hate to read the next line to someone over
+ the phone? */
if (pos < point && point < pause)
pause = point;
if (pos < GPT && GPT < pause)
}
c = *p++;
if (c >= 040 && c < 0177
- && (dp == 0 || XTYPE (DISP_CHAR_ROPE (dp, c)) != Lisp_String))
+ && (dp == 0 || XTYPE (DISP_CHAR_VECTOR (dp, c)) != Lisp_Vector))
{
if (p1 >= startp)
- *p1 = c;
+ *p1 = MAKE_GLYPH (c, current_face);
p1++;
}
else if (c == '\n')
p1 += selective_rlen;
if (p1 - startp > width)
p1 = endp;
- bcopy (XSTRING (DISP_INVIS_ROPE (dp))->data, p1prev,
- (p1 - p1prev) * sizeof (GLYPH));
+ copy_part_of_rope (p1prev, p1prev, invis_vector_contents,
+ (p1 - p1prev), current_face);
}
+#if 1
+ /* Draw the face of the newline character as extending all the
+ way to the end of the frame line. */
+ if (current_face)
+ while (p1 < endp)
+ *p1++ = MAKE_GLYPH (' ', current_face);
+#endif
break;
}
else if (c == '\t')
do
{
if (p1 >= startp && p1 < endp)
- *p1 = SPACEGLYPH;
+ *p1 = MAKE_GLYPH (' ', current_face);
p1++;
}
while ((p1 - startp + taboffset + hscroll - (hscroll > 0))
p1 += selective_rlen;
if (p1 - startp > width)
p1 = endp;
- bcopy (XSTRING (DISP_INVIS_ROPE (dp))->data, p1prev,
- (p1 - p1prev) * sizeof (GLYPH));
+ copy_part_of_rope (p1prev, p1prev, invis_vector_contents,
+ (p1 - p1prev), current_face);
}
+#if 1
+ /* Draw the face of the newline character as extending all the
+ way to the end of the frame line. */
+ if (current_face)
+ while (p1 < endp)
+ *p1++ = MAKE_GLYPH (' ', current_face);
+#endif
break;
}
- else if (dp != 0 && XTYPE (DISP_CHAR_ROPE (dp, c)) == Lisp_String)
+ else if (dp != 0 && XTYPE (DISP_CHAR_VECTOR (dp, c)) == Lisp_Vector)
{
- p1 = copy_rope (p1, startp, DISP_CHAR_ROPE (dp, c));
+ p1 = copy_rope (p1, startp, DISP_CHAR_VECTOR (dp, c), current_face);
}
else if (c < 0200 && ctl_arrow)
{
if (p1 >= startp)
- *p1 = (dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int
- ? XINT (DISP_CTRL_GLYPH (dp)) : '^');
+ *p1 = MAKE_GLYPH ((dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int
+ ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
+ current_face);
p1++;
if (p1 >= startp && p1 < endp)
- *p1 = c ^ 0100;
+ *p1 = MAKE_GLYPH (c ^ 0100, current_face);
p1++;
}
else
{
if (p1 >= startp)
- *p1 = (dp && XTYPE (DISP_ESCAPE_GLYPH (dp)) == Lisp_Int
- ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\');
+ *p1 = MAKE_GLYPH ((dp && XTYPE (DISP_ESCAPE_GLYPH (dp)) == Lisp_Int
+ ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
+ current_face);
p1++;
if (p1 >= startp && p1 < endp)
- *p1 = (c >> 6) + '0';
+ *p1 = MAKE_GLYPH ((c >> 6) + '0', current_face);
p1++;
if (p1 >= startp && p1 < endp)
- *p1 = (7 & (c >> 3)) + '0';
+ *p1 = MAKE_GLYPH ((7 & (c >> 3)) + '0', current_face);
p1++;
if (p1 >= startp && p1 < endp)
- *p1 = (7 & c) + '0';
+ *p1 = MAKE_GLYPH ((7 & c) + '0', current_face);
p1++;
}
+
pos++;
}
/* by backing up over it */
if (p1 > endp)
{
- /* Start the next line with that same character */
- pos--;
- /* but at a negative hpos, to skip the columns output on this line. */
- val.hpos += p1prev - endp;
+ /* Don't back up if we never actually displayed any text.
+ 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;
+ }
+
/* Keep in this line everything up to the continuation column. */
p1 = endp;
}
}
/* If point is at eol or in invisible text at eol,
- record its screen location now. */
+ record its frame location now. */
if (start <= point && point <= lastpos && cursor_vpos < 0)
{
if (cursor_hpos < 0) cursor_hpos = 0;
if (cursor_hpos > width) cursor_hpos = width;
cursor_hpos += XFASTINT (w->left);
- if (w == XWINDOW (SCREEN_SELECTED_WINDOW (s)))
+ if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)))
{
- SCREEN_CURSOR_Y (s) = cursor_vpos;
- SCREEN_CURSOR_X (s) = cursor_hpos;
+ FRAME_CURSOR_Y (f) = cursor_vpos;
+ FRAME_CURSOR_X (f) = cursor_hpos;
if (w == XWINDOW (selected_window))
{
p1 = startp + 1;
}
- if (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s))
+ if (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f))
{
endp++;
if (p1 < startp) p1 = startp;
while (p1 < endp) *p1++ = SPACEGLYPH;
- *p1++ = '|';
+
+ /* Don't draw vertical bars if we're using scroll bars. They're
+ covered up by the scroll bars, and it's distracting to see
+ them when the scroll bar windows are flickering around to be
+ reconfigured. */
+ *p1++ = (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+ ? ' ' : '|');
}
desired_glyphs->used[vpos] = max (desired_glyphs->used[vpos],
p1 - desired_glyphs->glyphs[vpos]);
int i;
int len = XSTRING (Voverlay_arrow_string)->size;
- if (len > XFASTINT (w->width) - 1)
- len = XFASTINT (w->width) - 1;
+ if (len > width)
+ len = width;
for (i = 0; i < len; i++)
startp[i] = p[i];
if (desired_glyphs->used[vpos] <
return &val_display_text_line;
}
\f
+/* Redisplay the menu bar in the frame for window W. */
+
+static void
+display_menu_bar (w)
+ struct window *w;
+{
+ Lisp_Object items, tail;
+ register int vpos = 0;
+ register FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
+ int maxendcol = FRAME_WIDTH (f);
+ int hpos = 0;
+
+ if (FRAME_MENU_BAR_LINES (f) <= 0)
+ return;
+
+ get_display_line (f, vpos, 0);
+
+ /* If the user has switched buffers or windows, we need to
+ recompute to reflect the new bindings. But we'll
+ recompute when update_mode_lines is set too; that means
+ that people can use force-mode-line-update to request
+ that the menu bar be recomputed. The adverse effect on
+ the rest of the redisplay algorithm is about the same as
+ windows_or_buffers_changed anyway. */
+ if (windows_or_buffers_changed
+ || update_mode_lines
+ || (XFASTINT (w->last_modified) < MODIFF
+ && (XFASTINT (w->last_modified)
+ <= XBUFFER (w->buffer)->save_modified)))
+ {
+ struct buffer *prev = current_buffer;
+ current_buffer = XBUFFER (w->buffer);
+ FRAME_MENU_BAR_ITEMS (f) = menu_bar_items ();
+ current_buffer = prev;
+ }
+
+ for (tail = FRAME_MENU_BAR_ITEMS (f); CONSP (tail); tail = XCONS (tail)->cdr)
+ {
+ Lisp_Object string;
+
+ string = XCONS (XCONS (XCONS (tail)->car)->cdr)->car;
+
+ /* Record in each item its hpos. */
+ XFASTINT (XCONS (XCONS (XCONS (tail)->car)->cdr)->cdr) = hpos;
+
+ if (hpos < maxendcol)
+ hpos = display_string (XWINDOW (FRAME_ROOT_WINDOW (f)), vpos,
+ XSTRING (string)->data,
+ hpos, 0, hpos, maxendcol);
+ /* Put a gap of 3 spaces between items. */
+ if (hpos < maxendcol)
+ {
+ int hpos1 = hpos + 3;
+ hpos = display_string (w, vpos, "", hpos, 0,
+ min (hpos1, maxendcol), maxendcol);
+ }
+ }
+
+ FRAME_DESIRED_GLYPHS (f)->bufp[vpos] = 0;
+ FRAME_DESIRED_GLYPHS (f)->highlight[vpos] = mode_line_inverse_video;
+
+ /* Fill out the line with spaces. */
+ if (maxendcol > hpos)
+ hpos = display_string (w, vpos, "", hpos, 0, maxendcol, -1);
+}
+\f
/* Display the mode line for window w */
static void
register int vpos = XFASTINT (w->height) + XFASTINT (w->top) - 1;
register int left = XFASTINT (w->left);
register int right = XFASTINT (w->width) + left;
- register SCREEN_PTR s = XSCREEN (WINDOW_SCREEN (w));
+ register FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
+
+ line_number_displayed = 0;
- get_display_line (s, vpos, left);
+ get_display_line (f, vpos, left);
display_mode_element (w, vpos, left, 0, right, right,
current_buffer->mode_line_format);
- SCREEN_DESIRED_GLYPHS (s)->bufp[vpos] = 0;
+ FRAME_DESIRED_GLYPHS (f)->bufp[vpos] = 0;
/* Make the mode line inverse video if the entire line
is made of mode lines.
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) == SCREEN_WIDTH (s)
- || XFASTINT (XWINDOW (w->parent)->width) == SCREEN_WIDTH (s))
- s->desired_glyphs->highlight[vpos] = mode_line_inverse_video;
+ 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;
#ifdef HAVE_X_WINDOWS
/* I'm trying this out because I saw Unimpress use it, but it's
- possible that this may mess adversely with some window managers. jla */
-
- if (SCREEN_IS_X (s)
- && ! SCREEN_MINIBUF_ONLY_P (s)
- && w == XWINDOW (s->selected_window)
- && (NULL (Fstring_equal (XBUFFER (w->buffer)->name, s->name))))
- x_set_name (s, XBUFFER (w->buffer)->name, Qnil);
+ possible that this may mess adversely with some window managers. -jla
+
+ Wouldn't it be nice to use something like mode-line-format to
+ describe frame titles? -JimB */
+
+ /* Change the title of the frame to the name of the buffer displayed
+ in the currently selected window. Don't do this for minibuffer frames,
+ and don't do it when there's only one non-minibuffer frame. */
+ if (FRAME_X_P (f)
+ && ! FRAME_MINIBUF_ONLY_P (f)
+ && w == XWINDOW (f->selected_window))
+ x_implicitly_set_name (f, (EQ (Fnext_frame (WINDOW_FRAME (w), Qnil),
+ WINDOW_FRAME (w))
+ ? Qnil
+ : XBUFFER (w->buffer)->name),
+ Qnil);
#endif
}
VPOS is the position of the mode line being displayed.
- HPOS is the position (absolute on screen) where this element's text
+ HPOS is the position (absolute on frame) where this element's text
should start. The output is truncated automatically at the right
edge of window W.
{
register Lisp_Object tem;
tem = Fboundp (elt);
- if (!NULL (tem))
+ if (!NILP (tem))
{
tem = Fsymbol_value (elt);
/* If value is a string, output that string literally:
goto invalid;
/* elt is now the cdr, and we know it is a cons cell.
Use its car if CAR has a non-nil value. */
- if (!NULL (tem))
+ if (!NILP (tem))
{
tem = Fsymbol_value (car);
- if (!NULL (tem))
+ if (!NILP (tem))
{ elt = XCONS (elt)->car; goto tail_recurse; }
}
/* Symbol's value is nil (or symbol is unbound)
Get the cddr of the original list
and if possible find the caddr and use that. */
elt = XCONS (elt)->cdr;
- if (NULL (elt))
+ if (NILP (elt))
break;
else if (XTYPE (elt) != Lisp_Cons)
goto invalid;
/* Return a string for the output of a mode line %-spec for window W,
generated by character C and width MAXWIDTH. */
+static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
+
static char *
decode_mode_spec (w, c, maxwidth)
struct window *w;
register int maxwidth;
{
Lisp_Object obj = Qnil;
- SCREEN_PTR scr = XSCREEN (WINDOW_SCREEN (w));
- char *decode_mode_spec_buf = (char *) SCREEN_TEMP_GLYPHS (scr)->total_contents;
+ FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
+ char *decode_mode_spec_buf = (char *) FRAME_TEMP_GLYPHS (f)->total_contents;
- if (maxwidth > SCREEN_WIDTH (scr))
- maxwidth = SCREEN_WIDTH (scr);
+ if (maxwidth > FRAME_WIDTH (f))
+ maxwidth = FRAME_WIDTH (f);
switch (c)
{
case 'f':
obj = current_buffer->filename;
#if 0
- if (NULL (obj))
+ if (NILP (obj))
return "[none]";
else if (XTYPE (obj) == Lisp_String && XSTRING (obj)->size > maxwidth)
{
#endif
break;
+ case 'l':
+ {
+ int startpos = marker_position (w->start);
+ int line, linepos, topline;
+ int nlines, junk;
+ Lisp_Object tem;
+ int height = XFASTINT (w->height);
+
+ /* If we decided that this buffer isn't suitable for line numbers,
+ don't forget that too fast. */
+ if (EQ (w->base_line_pos, w->buffer))
+ return "??";
+
+ /* If the buffer is very big, don't waste time. */
+ if (ZV - BEGV > line_number_display_limit)
+ {
+ w->base_line_pos = Qnil;
+ w->base_line_number = Qnil;
+ return "??";
+ }
+
+ if (!NILP (w->base_line_number)
+ && !NILP (w->base_line_pos)
+ && XFASTINT (w->base_line_pos) <= marker_position (w->start))
+ {
+ line = XFASTINT (w->base_line_number);
+ linepos = XFASTINT (w->base_line_pos);
+ }
+ else
+ {
+ line = 1;
+ linepos = BEGV;
+ }
+
+ /* Count lines from base line to window start position. */
+ nlines = display_count_lines (linepos, startpos, startpos, &junk);
+
+ topline = nlines + line;
+
+ /* Determine a new base line, if the old one is too close
+ or too far away, or if we did not have one.
+ "Too close" means it's plausible a scroll-down would
+ go back past it. */
+ if (startpos == BEGV)
+ {
+ XFASTINT (w->base_line_number) = topline;
+ XFASTINT (w->base_line_pos) = BEGV;
+ }
+ else if (nlines < height + 25 || nlines > height * 3 + 50
+ || linepos == BEGV)
+ {
+ int limit = BEGV;
+ int position;
+ int distance = (height * 2 + 30) * 200;
+
+ if (startpos - distance > limit)
+ limit = startpos - distance;
+
+ nlines = display_count_lines (startpos, limit,
+ -(height * 2 + 30),
+ &position);
+ /* If we couldn't find the lines we wanted within
+ 200 chars per line,
+ give up on line numbers for this window. */
+ if (position == startpos - distance)
+ {
+ w->base_line_pos = w->buffer;
+ w->base_line_number = Qnil;
+ return "??";
+ }
+
+ XFASTINT (w->base_line_number) = topline - nlines;
+ XFASTINT (w->base_line_pos) = position;
+ }
+
+ /* Now count lines from the start pos to point. */
+ nlines = display_count_lines (startpos, PT, PT, &junk);
+
+ /* Record that we did display the line number. */
+ line_number_displayed = 1;
+
+ /* Make the string to show. */
+ sprintf (decode_mode_spec_buf, "%d", topline + nlines);
+ return decode_mode_spec_buf;
+ }
+ break;
+
case 'm':
obj = current_buffer->mode_name;
break;
break;
case '*':
- if (!NULL (current_buffer->read_only))
+ if (!NILP (current_buffer->read_only))
return "%";
if (MODIFF > current_buffer->save_modified)
return "*";
case 's':
/* status of process */
-#ifdef subprocesses
obj = Fget_buffer_process (Fcurrent_buffer ());
- if (NULL (obj))
+ if (NILP (obj))
return "no process";
obj = Fsymbol_name (Fprocess_status (obj));
break;
-#else
- return "no processes";
-#endif /* subprocesses */
case 'p':
{
case '-':
{
- static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
register char *p;
register int i;
else
return "";
}
+
+/* Count up to N lines starting from FROM.
+ But don't go beyond LIMIT.
+ Return the number of lines thus found (always positive).
+ Store the position after what was found into *POS_PTR. */
+
+static int
+display_count_lines (from, limit, n, pos_ptr)
+ int from, limit, n;
+ int *pos_ptr;
+{
+ int oldbegv = BEGV;
+ int oldzv = ZV;
+ int shortage = 0;
+
+ if (limit < from)
+ BEGV = limit;
+ else
+ ZV = limit;
+
+ *pos_ptr = scan_buffer ('\n', from, n, &shortage);
+
+ ZV = oldzv;
+ BEGV = oldbegv;
+
+ if (n < 0)
+ /* When scanning backwards, scan_buffer stops *after* the last newline
+ it finds, but does count it. Compensate for that. */
+ return - n - shortage - (*pos_ptr != limit);
+ return n - shortage;
+}
\f
/* Display STRING on one line of window W, starting at HPOS.
Display at position VPOS. Caller should have done get_display_line.
+ If VPOS == -1, display it as the current frame's title.
TRUNCATE is GLYPH to display at end if truncated. Zero for none.
MINCOL is the first column ok to end at. (Pad with spaces to this col.)
MAXCOL is the last column ok to end at. Truncate here.
-1 for MINCOL or MAXCOL means no explicit minimum or maximum.
- Both count from the left edge of the screen, as does HPOS.
+ Both count from the left edge of the frame, as does HPOS.
The right edge of W is an implicit maximum.
If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
register int c;
register GLYPH *p1;
int hscroll = XINT (w->hscroll);
- int tab_width = XINT (current_buffer->tab_width);
+ int tab_width = XINT (XBUFFER (w->buffer)->tab_width);
register GLYPH *start;
register GLYPH *end;
- struct screen_glyphs *desired_glyphs = SCREEN_DESIRED_GLYPHS (XSCREEN (w->screen));
+ FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
+ struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (f);
GLYPH *p1start = desired_glyphs->glyphs[vpos] + hpos;
int window_width = XFASTINT (w->width);
&& XVECTOR (Vstandard_display_table)->size == DISP_TABLE_SIZE)
dp = XVECTOR (Vstandard_display_table);
- if (tab_width <= 0 || tab_width > 20) tab_width = 8;
+ if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
p1 = p1start;
start = desired_glyphs->glyphs[vpos] + XFASTINT (w->left);
end = start + window_width - (truncate != 0);
- if ((window_width + XFASTINT (w->left))
- != SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (w))))
- *end-- = '|';
+ if ((window_width + XFASTINT (w->left)) != FRAME_WIDTH (f))
+ {
+ if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+ {
+ int i;
+
+ for (i = 0; i < VERTICAL_SCROLL_BAR_WIDTH; i++)
+ *end-- = ' ';
+ }
+ else
+ *end-- = '|';
+ }
if (maxcol >= 0 && end - desired_glyphs->glyphs[vpos] > maxcol)
end = desired_glyphs->glyphs[vpos] + maxcol;
c = *string++;
if (!c) break;
if (c >= 040 && c < 0177
- && (dp == 0 || XTYPE (DISP_CHAR_ROPE (dp, c)) != Lisp_String))
+ && (dp == 0 || XTYPE (DISP_CHAR_VECTOR (dp, c)) != Lisp_Vector))
{
if (p1 >= start)
*p1 = c;
}
while ((p1 - start + hscroll - (hscroll > 0)) % tab_width);
}
- else if (dp != 0 && XTYPE (DISP_CHAR_ROPE (dp, c)) == Lisp_String)
- p1 = copy_rope (p1, start, DISP_CHAR_ROPE (dp, c));
- else if (c < 0200 && buffer_defaults.ctl_arrow)
+ else if (dp != 0 && XTYPE (DISP_CHAR_VECTOR (dp, c)) == Lisp_Vector)
+ p1 = copy_rope (p1, start, DISP_CHAR_VECTOR (dp, c), 0);
+ else if (c < 0200 && ! NILP (buffer_defaults.ctl_arrow))
{
if (p1 >= start)
*p1 = (dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int
last_arrow_string = Qnil;
DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string,
- "String displayed by mode-line-format's \"%m\" specifiation.");
+ "String (or mode line construct) included (normally) in `mode-line-format'.");
Vglobal_mode_string = Qnil;
DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position,
DEFVAR_INT ("scroll-step", &scroll_step,
"*The number of lines to try scrolling a window by when point moves out.\n\
-If that fails to bring point back on screen, point is centered instead.\n\
-If this is zero, point is always centered after it moves off screen.");
+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 ("debug-end-pos", &debug_end_pos, "Don't ask");
DEFVAR_BOOL ("truncate-partial-width-windows",
&truncate_partial_width_windows,
- "*Non-nil means truncate lines in all windows less than full screen wide.");
+ "*Non-nil means truncate lines in all windows less than full frame wide.");
truncate_partial_width_windows = 1;
DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video,
"*Non-nil means use inverse video for the mode line.");
mode_line_inverse_video = 1;
-#ifndef MULTI_SCREEN
- defsubr (&Sredraw_display);
-#endif /* MULTI_SCREEN */
+ DEFVAR_INT ("line-number-display-limit", &line_number_display_limit,
+ "*Maximum buffer size for which line number should be displayed.");
+ line_number_display_limit = 1000000;
+
+ DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows,
+ "*Non-nil means highlight region even in nonselected windows.");
+ highlight_nonselected_windows = 1;
}
/* initialize the window system */
this_line_bufpos = 0;
mini_w = XWINDOW (minibuf_window);
- root_window = mini_w->prev;
+ root_window = FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w)));
echo_area_glyphs = 0;
previous_echo_glyphs = 0;
if (!noninteractive)
{
- SCREEN_PTR s = XSCREEN (WINDOW_SCREEN (XWINDOW (root_window)));
+ FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (root_window)));
XFASTINT (XWINDOW (root_window)->top) = 0;
- set_window_height (root_window, SCREEN_HEIGHT (s) - 1, 0);
- XFASTINT (mini_w->top) = SCREEN_HEIGHT (s) - 1;
+ set_window_height (root_window, FRAME_HEIGHT (f) - 1, 0);
+ XFASTINT (mini_w->top) = FRAME_HEIGHT (f) - 1;
set_window_height (minibuf_window, 1, 0);
- XFASTINT (XWINDOW (root_window)->width) = SCREEN_WIDTH (s);
- XFASTINT (mini_w->width) = SCREEN_WIDTH (s);
+ XFASTINT (XWINDOW (root_window)->width) = FRAME_WIDTH (f);
+ XFASTINT (mini_w->width) = FRAME_WIDTH (f);
}
}
HCoop / bpt / emacs.git / blobdiff