/* Display generation from window structure and buffer text.
- Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1988, 1992 Free Software Foundation, Inc.
This file is part of GNU Emacs.
/*#include <ctype.h>*/
#undef NULL
#include "lisp.h"
-#include "screen.h"
+#include "frame.h"
#include "window.h"
#include "termchar.h"
#include "dispextern.h"
#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,
+/* 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. */
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;
-}
-
-#endif /* not MULTI_SCREEN */
-\f
-char *message_buf;
-
-/* 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");
+ fprintf (stderr, "%s\n", m);
fflush (stderr);
}
- else if (INTERACTIVE)
+ /* 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 && FRAME_MESSAGE_BUF (selected_frame))
{
-#ifdef NO_ARG_ARRAY
- int a[3];
- a[0] = a1;
- a[1] = a2;
- a[2] = a3;
+#ifdef MULTI_FRAME
+ Lisp_Object minibuf_frame;
+
+ choose_minibuf_frame ();
+ minibuf_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
+ if (FRAME_VISIBLE_P (selected_frame)
+ && ! FRAME_VISIBLE_P (XFRAME (minibuf_frame)))
+ Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window)));
+#endif
- 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 */
+ if (m)
+ echo_area_glyphs = m;
+ else
+ echo_area_glyphs = previous_echo_glyphs = 0;
- echo_area_glyphs = SCREEN_MESSAGE_BUF (selected_screen);
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 (!NULL (Vwindow_system) && SCREEN_IS_TERMCAP (selected_screen))
- return;
-
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);
+ fprintf (stderr, "\n");
+ fflush (stderr);
+ }
}
- else if (INTERACTIVE)
+ /* 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 && FRAME_MESSAGE_BUF (selected_frame))
{
- echo_area_glyphs = m;
- do_pending_window_change ();
- echo_area_display ();
- update_screen (XSCREEN (XWINDOW (minibuf_window)->screen), 1, 1);
- do_pending_window_change ();
+ if (m)
+ {
+ {
+#ifdef NO_ARG_ARRAY
+ int a[3];
+ a[0] = a1;
+ a[1] = a2;
+ a[2] = a3;
+
+ doprnt (FRAME_MESSAGE_BUF (selected_frame),
+ FRAME_WIDTH (selected_frame), m, 0, 3, a);
+#else
+ doprnt (FRAME_MESSAGE_BUF (selected_frame),
+ FRAME_WIDTH (selected_frame), m, 0, 3, &a1);
+#endif /* NO_ARG_ARRAY */
+ }
+
+ message1 (FRAME_MESSAGE_BUF (selected_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_SCREEN
- choose_minibuf_screen ();
- s = XSCREEN (XWINDOW (minibuf_window)->screen);
+#ifdef MULTI_FRAME
+ choose_minibuf_frame ();
+ f = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
- if (!s->visible)
+ if (! FRAME_VISIBLE_P (f))
return;
#endif
- if (screen_garbaged)
+ if (frame_garbaged)
{
Fredraw_display ();
- screen_garbaged = 0;
+ 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. */
+ /* Notice any pending interrupt request to change frame size. */
do_pending_window_change ();
- if (screen_garbaged)
+ if (frame_garbaged)
{
Fredraw_display ();
- screen_garbaged = 0;
+ frame_garbaged = 0;
}
+ /* Normally the message* functions will have already displayed and
+ 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)
{
echo_area_display ();
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;
-#ifdef MULTI_SCREEN
- all_windows |= (XTYPE (Vglobal_minibuffer_screen) == Lisp_Screen
- && selected_screen != XSCREEN (Vglobal_minibuffer_screen));
-#endif /* MULTI_SCREEN */
/* 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;
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;
}
point, 2, - (1 << (SHORTBITS - 1)),
XFASTINT (w->width) - 1
- (XFASTINT (w->width) + XFASTINT (w->left)
- != SCREEN_WIDTH (selected_screen)),
- XINT (w->hscroll), 0);
+ != FRAME_WIDTH (selected_frame)),
+ 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
+#ifdef MULTI_FRAME
Lisp_Object tail;
/* Recompute # windows showing selected buffer.
- This will be increment each time such a window is displayed. */
+ 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 (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)
- {
-
- /* Clear the echo area on screens where the minibuffer isn't. */
- if (s != XSCREEN (XWINDOW (minibuf_window)->screen)
- /* But only screens that have minibuffers. */
- && s->has_minibuffer)
- {
- int vpos = XFASTINT (XWINDOW (s->minibuffer_window)->top);
- register struct screen_glyphs *line;
-
- get_display_line (s, vpos, 0);
- display_string (XWINDOW (s->minibuffer_window), vpos, "",
- 0, 0, 0, s->width);
- }
-
- /* Redraw its windows. */
- redisplay_windows (SCREEN_ROOT_WINDOW (s));
- }
+ f = XFRAME (XCONS (tail)->car);
+ if (f->visible)
+ /* Redraw its windows. */
+ redisplay_windows (FRAME_ROOT_WINDOW (f));
}
#else
- redisplay_windows (SCREEN_ROOT_WINDOW (s));
-#endif /* not MULTI_SCREEN */
+ redisplay_windows (FRAME_ROOT_WINDOW (f));
+#endif /* not MULTI_FRAME */
}
- 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 (f->visible)
{
- pause |= update_screen (s, 0, 0, SCREEN_SCROLL_BOTTOM_VPOS (s));
+ 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 */
- if (SCREEN_VISIBLE_P (selected_screen))
- pause = update_screen (selected_screen, 0, 0);
+#endif /* MULTI_FRAME */
+ {
+ if (FRAME_VISIBLE_P (selected_frame))
+ pause = update_frame (selected_frame, 0, 0);
+#ifdef MULTI_FRAME
+ /* We may have called echo_area_display at the top of this
+ 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. */
+ {
+ FRAME_PTR mini_frame =
+ XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
+
+ 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))
+ if (!NILP (w->buffer))
XFASTINT (w->last_modified)
= !flag ? 0
: XBUFFER (w->buffer) == current_buffer
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 (w->frame);
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))));
+ != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w))));
register int startp;
register int hscroll = XINT (w->hscroll);
struct position pos;
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 (MINI_WINDOW_P (w))
+ {
+ if (w == XWINDOW (minibuf_window))
+ {
+ if (echo_area_glyphs)
+ /* We've already displayed the echo area glyphs, if any. */
+ return;
+ }
+ else
+ {
+ /* This is a minibuffer, but it's not the currently active one, so
+ clear it. */
+ int vpos = XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top);
+ int i;
+
+ for (i = 0; i < height; i++)
+ {
+ get_display_line (f, vpos + i, 0);
+ display_string (w, vpos + i, "", 0, 0, 0, width);
+ }
+
+ return;
+ }
+ }
if (update_mode_lines)
w->update_mode_line = Qt;
/* Otherwise set up data on this window; select its buffer and point value */
- height = window_internal_height (w);
-
- if (MINI_WINDOW_P (w)
- && (echo_area_glyphs
- /* Don't display minibuffers except minibuf_window. */
- || w != XWINDOW (minibuf_window)))
- return;
-
current_buffer = XBUFFER (w->buffer);
opoint = point;
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);
}
}
/* If window-start is screwed up, choose a new one. */
-
if (XMARKER (w->start)->buffer != current_buffer)
goto recenter;
startp = marker_position (w->start);
- /* Handle case where place to start displaying has been specified */
-
- if (!NULL (w->force_start))
+ /* Handle case where place to start displaying has been specified,
+ unless the specified location is outside the visible range. */
+ if (!NILP (w->force_start))
{
w->update_mode_line = Qt;
w->force_start = Qnil;
XFASTINT (w->last_modified) = 0;
+ if (startp < BEGV) startp = BEGV;
+ if (startp > ZV) startp = ZV;
try_window (window, startp);
if (cursor_vpos < 0)
{
- (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))
&& !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'))
{
&& ! 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)
&& 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.
}
else if (startp >= BEGV && startp <= ZV
/* Avoid starting display at end of buffer! */
- && (startp <= ZV || startp == BEGV
+ && (startp < ZV || startp == BEGV
|| (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;
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)
+ || (!just_this_one && width < FRAME_WIDTH (f) - 1))
&& height != XFASTINT (w->height))
display_mode_line (w);
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);
+ FRAME_PTR f = XFRAME (w->frame);
int width = XFASTINT (w->width) - 1
- - (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s));
+ - (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f));
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));
+ - (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f));
int hscroll = XINT (w->hscroll);
int lmargin = hscroll > 0 ? 1 - hscroll : 0;
register int vpos;
/* Find position before which nothing is changed. */
bp = *compute_motion (start, 0, lmargin,
- beg_unchanged + 1, 10000, 10000, width, hscroll,
+ beg_unchanged + 1, height + 1, 0, width, hscroll,
pos_tab_offset (w, start));
if (bp.vpos >= height)
- return point < bp.bufpos && !bp.contin;
+ {
+ if (point < bp.bufpos && !bp.contin)
+ {
+ /* 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,
+ Z, height, 0,
+ width, hscroll, pos_tab_offset (w, start));
+ XFASTINT (w->window_end_vpos) = height;
+ XFASTINT (w->window_end_pos) = Z - bp.bufpos;
+ return 1;
+ }
+ return 0;
+ }
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)
{
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.
GLYPH *endp;
register GLYPH *startp;
register GLYPH *p1prev;
- SCREEN_PTR s = XSCREEN (w->screen);
+ FRAME_PTR f = XFRAME (w->frame);
int tab_width = XINT (current_buffer->tab_width);
- int ctl_arrow = !NULL (current_buffer->ctl_arrow);
+ int ctl_arrow = !NILP (current_buffer->ctl_arrow);
int width = XFASTINT (w->width) - 1
- - (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s));
+ - (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f));
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);
int selective
= XTYPE (current_buffer->selective_display) == Lisp_Int
? XINT (current_buffer->selective_display)
- : !NULL (current_buffer->selective_display) ? -1 : 0;
+ : !NILP (current_buffer->selective_display) ? -1 : 0;
#ifndef old
- int selective_e = selective && !NULL (current_buffer->selective_display_ellipses);
+ int selective_e = selective && !NILP (current_buffer->selective_display_ellipses);
#endif
- register struct screen_glyphs *desired_glyphs = SCREEN_DESIRED_GLYPHS (s);
+ register struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (f);
register struct Lisp_Vector *dp = window_display_table (w);
int selective_rlen
= (selective && dp && XTYPE (DISP_INVIS_ROPE (dp)) == Lisp_String
? '\\' : XINT (DISP_CONTINUE_GLYPH (dp)));
hpos += XFASTINT (w->left);
- get_display_line (s, vpos, XFASTINT (w->left));
+ get_display_line (f, vpos, XFASTINT (w->left));
if (tab_width <= 0 || tab_width > 20) tab_width = 8;
if (MINI_WINDOW_P (w) && start == 1
while ((p1 - startp + taboffset + hscroll - (hscroll > 0))
% tab_width);
}
- else if (c == Ctl('M') && selective == -1)
+ else if (c == Ctl ('M') && selective == -1)
{
pos = find_next_newline (pos, 1);
if (FETCH_CHAR (pos - 1) == '\n')
*p1 = (dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int
? XINT (DISP_CTRL_GLYPH (dp)) : '^');
p1++;
- if (p1 >= startp)
+ if (p1 >= startp && p1 < endp)
*p1 = c ^ 0100;
p1++;
}
*p1 = (dp && XTYPE (DISP_ESCAPE_GLYPH (dp)) == Lisp_Int
? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\');
p1++;
- if (p1 >= startp)
+ if (p1 >= startp && p1 < endp)
*p1 = (c >> 6) + '0';
p1++;
- if (p1 >= startp)
+ if (p1 >= startp && p1 < endp)
*p1 = (7 & (c >> 3)) + '0';
p1++;
- if (p1 >= startp)
+ if (p1 >= startp && p1 < endp)
*p1 = (7 & c) + '0';
p1++;
}
}
/* 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;
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));
- 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 fuck adversely with some window managers. jla */
-
- if (SCREEN_IS_X (s)
- && (XTYPE (Vglobal_minibuffer_screen) != Lisp_Screen
- || s != XSCREEN (Vglobal_minibuffer_screen))
- && 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)
{
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;
\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.
int tab_width = XINT (current_buffer->tab_width);
register GLYPH *start;
register GLYPH *end;
- struct screen_glyphs *desired_glyphs = SCREEN_DESIRED_GLYPHS (XSCREEN (w->screen));
+ struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (XFRAME (w->frame));
GLYPH *p1start = desired_glyphs->glyphs[vpos] + hpos;
int window_width = XFASTINT (w->width);
end = start + window_width - (truncate != 0);
if ((window_width + XFASTINT (w->left))
- != SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (w))))
+ != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w))))
*end-- = '|';
if (maxcol >= 0 && end - desired_glyphs->glyphs[vpos] > maxcol)
}
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 (c < 0200 && ! NILP (buffer_defaults.ctl_arrow))
{
if (p1 >= start)
*p1 = (dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int
? XINT (DISP_CTRL_GLYPH (dp)) : '^');
p1++;
- if (p1 >= start)
+ if (p1 >= start && p1 < end)
*p1 = c ^ 0100;
p1++;
}
*p1 = (dp && XTYPE (DISP_ESCAPE_GLYPH (dp)) == Lisp_Int
? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\');
p1++;
- if (p1 >= start)
+ if (p1 >= start && p1 < end)
*p1 = (c >> 6) + '0';
p1++;
- if (p1 >= start)
+ if (p1 >= start && p1 < end)
*p1 = (7 & (c >> 3)) + '0';
p1++;
- if (p1 >= start)
+ if (p1 >= start && p1 < end)
*p1 = (7 & c) + '0';
p1++;
}
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 */
}
/* 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);
}
}