/* Updating of data structures for redisplay.
- Copyright (C) 1985, 86, 87, 88, 93, 94 Free Software Foundation, Inc.
+ Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 1998
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <signal.h>
#include <stdio.h>
#include <ctype.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
#include "lisp.h"
#include "termchar.h"
#include "termopts.h"
#include "termhooks.h"
-#include "cm.h"
+/* cm.h must come after dispextern.h on Windows. */
#include "dispextern.h"
+#include "cm.h"
#include "buffer.h"
+#include "charset.h"
#include "frame.h"
#include "window.h"
#include "commands.h"
#include "disptab.h"
#include "indent.h"
#include "intervals.h"
+#include "blockinput.h"
+#include "process.h"
+#include "keyboard.h"
-#include "systty.h"
+/* I don't know why DEC Alpha OSF1 fail to compile this file if we
+ include the following file. */
+/* #include "systty.h" */
+#include "syssignal.h"
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#endif /* HAVE_X_WINDOWS */
+#ifdef HAVE_NTGUI
+#include "w32term.h"
+#endif /* HAVE_NTGUI */
+
/* Include systime.h after xterm.h to avoid double inclusion of time.h. */
#include "systime.h"
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
+#define minmax(floor, val, ceil) \
+ ((val) < (floor) ? (floor) : (val) > (ceil) ? (ceil) : (val))
/* Get number of chars of output now in the buffer of a stdio stream.
This ought to be built in in stdio, but it isn't.
#endif
#endif
+static void change_frame_size_1 ();
+
/* Nonzero upon entry to redisplay means do not assume anything about
current contents of actual terminal frame; clear and redraw it. */
positive means at end of text in echo area;
negative means at beginning of line. */
int cursor_in_echo_area;
+
+Lisp_Object Qdisplay_table;
\f
/* The currently selected frame.
In a single-frame version, this variable always holds the address of
the address of the_only_frame. */
FRAME_PTR last_nonminibuf_frame;
-/* In a single-frame version, the information that would otherwise
- exist inside frame objects lives in the following structure instead.
-
- NOTE: the_only_frame is not checked for garbage collection; don't
- store collectible objects in any of its fields!
-
- You're not/The only frame in town/... */
-
-#ifndef MULTI_FRAME
-struct frame the_only_frame;
-#endif
-
/* This is a vector, made larger whenever it isn't large enough,
which is used inside `update_frame' to hold the old contents
of the FRAME_PHYS_LINES of the frame being updated. */
struct cm Wcm; /* Structure for info on cursor positioning */
-extern short ospeed; /* Output speed (from sg_ospeed) */
-
int delayed_size_change; /* 1 means SIGWINCH happened when not safe. */
\f
-#ifdef MULTI_FRAME
-
DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
"Clear frame FRAME and output again what is supposed to appear on it.")
(frame)
CHECK_LIVE_FRAME (frame, 0);
f = XFRAME (frame);
- update_begin (f);
- /* set_terminal_modes (); */
- clear_frame ();
- clear_frame_records (f);
- update_end (f);
- fflush (stdout);
+
+ /* Erase the frame and its glyph records--if it has any records.
+ It may have none, in the case of the terminal frame
+ that initially exists but is never used
+ when Emacs is using a window system. */
+ if (FRAME_CURRENT_GLYPHS (f) != 0)
+ {
+ update_begin (f);
+ if (FRAME_MSDOS_P (f))
+ set_terminal_modes ();
+ clear_frame ();
+ clear_frame_records (f);
+ update_end (f);
+ fflush (stdout);
+ }
+
windows_or_buffers_changed++;
/* Mark all windows as INaccurate,
so that every window will have its redisplay done. */
return Qnil;
}
+void
redraw_frame (f)
FRAME_PTR f;
{
Fredraw_frame (frame);
}
-#else
-
-DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
- "Clear frame FRAME and output again what is supposed to appear on it.")
- (frame)
- Lisp_Object frame;
-{
- update_begin (0);
- set_terminal_modes ();
- clear_frame ();
- update_end (0);
- fflush (stdout);
- clear_frame_records (0);
- windows_or_buffers_changed++;
- /* Mark all windows as INaccurate,
- so that every window will have its redisplay done. */
- mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
- return Qnil;
-}
-
-#endif
-
DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
"Clear and redisplay all visible frames.")
()
int empty;
{
register int i;
- register width = FRAME_WIDTH (frame);
- register height = FRAME_HEIGHT (frame);
+ register int width = FRAME_WINDOW_WIDTH (frame);
+ register int height = FRAME_HEIGHT (frame);
register struct frame_glyphs *new
= (struct frame_glyphs *) xmalloc (sizeof (struct frame_glyphs));
bzero (new->enable, height * sizeof (char));
new->bufp = (int *) xmalloc (height * sizeof (int));
-#ifdef HAVE_X_WINDOWS
- if (FRAME_X_P (frame))
+#ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (frame))
{
new->top_left_x = (short *) xmalloc (height * sizeof (short));
new->top_left_y = (short *) xmalloc (height * sizeof (short));
new->pix_height = (short *) xmalloc (height * sizeof (short));
new->max_ascent = (short *) xmalloc (height * sizeof (short));
}
-#endif
+#endif /* HAVE_WINDOW_SYSTEM */
if (empty)
{
bzero (new->total_contents, total_glyphs);
new->total_charstarts = (int *) xmalloc (total_charstarts);
- bzero (new->total_charstarts, total_glyphs);
+ bzero (new->total_charstarts, total_charstarts);
}
else
{
if (glyphs->charstarts)
xfree (glyphs->charstarts);
-#ifdef HAVE_X_WINDOWS
- if (FRAME_X_P (frame))
+#ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (frame))
{
xfree (glyphs->top_left_x);
xfree (glyphs->top_left_y);
xfree (glyphs->pix_height);
xfree (glyphs->max_ascent);
}
-#endif
+#endif /* HAVE_WINDOW_SYSTEM */
xfree (glyphs);
}
-static void
+void
remake_frame_glyphs (frame)
FRAME_PTR frame;
{
FRAME_MESSAGE_BUF (frame)
= (char *) xrealloc (FRAME_MESSAGE_BUF (frame),
- FRAME_WIDTH (frame) + 1);
+ FRAME_MESSAGE_BUF_SIZE (frame) + 1);
if (echo_area_glyphs == old_message_buf)
echo_area_glyphs = FRAME_MESSAGE_BUF (frame);
}
else
FRAME_MESSAGE_BUF (frame)
- = (char *) xmalloc (FRAME_WIDTH (frame) + 1);
+ = (char *) xmalloc (FRAME_MESSAGE_BUF_SIZE (frame) + 1);
FRAME_CURRENT_GLYPHS (frame) = make_frame_glyphs (frame, 0);
FRAME_DESIRED_GLYPHS (frame) = make_frame_glyphs (frame, 0);
FRAME_TEMP_GLYPHS (frame) = make_frame_glyphs (frame, 1);
- SET_FRAME_GARBAGED (frame);
+ if (FRAME_WINDOW_P (frame) || frame == selected_frame)
+ SET_FRAME_GARBAGED (frame);
}
\f
/* Return the hash code of contents of line VPOS in frame-matrix M. */
/* cancel_line eliminates any request to display a line at position `vpos' */
+void
cancel_line (vpos, frame)
int vpos;
register FRAME_PTR frame;
FRAME_DESIRED_GLYPHS (frame)->enable[vpos] = 0;
}
+void
clear_frame_records (frame)
register FRAME_PTR frame;
{
bzero (FRAME_CURRENT_GLYPHS (frame)->enable, FRAME_HEIGHT (frame));
}
+/* Clear out all display lines for a coming redisplay. */
+
+void
+init_desired_glyphs (frame)
+ register FRAME_PTR frame;
+{
+ register struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (frame);
+ int vpos;
+ int height = FRAME_HEIGHT (frame);
+
+ for (vpos = 0; vpos < height; vpos++)
+ desired_glyphs->enable[vpos] = 0;
+}
+
/* Prepare to display on line VPOS starting at HPOS within it. */
void
if (vpos < 0)
abort ();
- if ((desired_glyphs->enable[vpos]) && desired_glyphs->used[vpos] > hpos)
- abort ();
-
if (! desired_glyphs->enable[vpos])
{
desired_glyphs->used[vpos] = 0;
register struct frame_glyphs *current_frame
= FRAME_CURRENT_GLYPHS (frame);
int pos_adjust;
- int width = FRAME_WIDTH (frame);
+ int width = FRAME_WINDOW_WIDTH (frame);
if (!line_ins_del_ok)
return 0;
current_frame->bufp + from + amount,
(end - from) * sizeof current_frame->bufp[0]);
-#ifdef HAVE_X_WINDOWS
- if (FRAME_X_P (frame))
+#ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (frame))
{
safe_bcopy (current_frame->top_left_x + from,
current_frame->top_left_x + from + amount,
current_frame->max_ascent + from + amount,
(end - from) * sizeof current_frame->max_ascent[0]);
}
-#endif /* HAVE_X_WINDOWS */
+#endif /* HAVE_WINDOW_SYSTEM */
update_end (frame);
}
current_frame->bufp + from + amount,
(end - from) * sizeof current_frame->bufp[0]);
-#ifdef HAVE_X_WINDOWS
- if (FRAME_X_P (frame))
+#ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (frame))
{
safe_bcopy (current_frame->top_left_x + from,
current_frame->top_left_x + from + amount,
current_frame->max_ascent + from + amount,
(end - from) * sizeof current_frame->max_ascent[0]);
}
-#endif /* HAVE_X_WINDOWS */
+#endif /* HAVE_WINDOW_SYSTEM */
update_end (frame);
}
into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
so that update_frame will not change those columns. */
+void
preserve_other_columns (w)
struct window *w;
{
register int vpos;
register struct frame_glyphs *current_frame, *desired_frame;
register FRAME_PTR frame = XFRAME (w->frame);
- int start = XFASTINT (w->left);
- int end = XFASTINT (w->left) + XFASTINT (w->width);
+ int start = WINDOW_LEFT_MARGIN (w);
+ int end = WINDOW_RIGHT_EDGE (w);
int bot = XFASTINT (w->top) + XFASTINT (w->height);
current_frame = FRAME_CURRENT_GLYPHS (frame);
register int vpos, fin;
register struct frame_glyphs *l1, *l2;
register FRAME_PTR frame = XFRAME (w->frame);
- int start = XFASTINT (w->left);
- int end = XFASTINT (w->left) + XFASTINT (w->width);
+ int start = WINDOW_LEFT_MARGIN (w);
+ int end = WINDOW_RIGHT_EDGE (w);
int bot = XFASTINT (w->top) + XFASTINT (w->height);
for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
int vpos;
int adjust;
{
- int left = XFASTINT (w->left);
+ int left = WINDOW_LEFT_MARGIN (w);
int top = XFASTINT (w->top);
int right = left + window_internal_width (w);
int bottom = top + window_internal_height (w);
for internal consistency. We cannot check that they are "right";
we can only look for something nonsensical. */
+void
verify_charstarts (w)
struct window *w;
{
int i;
int top = XFASTINT (w->top);
int bottom = top + window_internal_height (w);
- int left = XFASTINT (w->left);
+ int left = WINDOW_LEFT_MARGIN (w);
int right = left + window_internal_width (w);
int next_line;
int truncate = (XINT (w->hscroll)
|| (truncate_partial_width_windows
- && (XFASTINT (w->width) < FRAME_WIDTH (f)))
+ && !WINDOW_FULL_WIDTH_P (w))
|| !NILP (XBUFFER (w->buffer)->truncate_lines));
for (i = top; i < bottom; i++)
cancel the columns of that window, so that when the window is
displayed over again get_display_line will not complain. */
+void
cancel_my_columns (w)
struct window *w;
{
register int vpos;
register struct frame_glyphs *desired_glyphs
= FRAME_DESIRED_GLYPHS (XFRAME (w->frame));
- register int start = XFASTINT (w->left);
+ register int start = WINDOW_LEFT_MARGIN (w);
register int bot = XFASTINT (w->top) + XFASTINT (w->height);
for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
int vpos = FRAME_CURSOR_Y (frame);
/* Give up if about to continue line. */
- if (hpos >= XFASTINT (w->left) + window_internal_width (w) - 1
+ if (hpos >= WINDOW_LEFT_MARGIN (w) + window_internal_width (w) - 1
/* Avoid losing if cursor is in invisible text off left margin */
- || (XINT (w->hscroll) && hpos == XFASTINT (w->left))
+ || (XINT (w->hscroll) && hpos == WINDOW_LEFT_MARGIN (w))
/* Give up if cursor outside window (in minibuf, probably) */
|| cursor_in_echo_area
At the moment we only lose at end of line or end of buffer
and only with faces that have some background */
/* Instead of wasting time, give up if character has any text properties */
- || ! NILP (Ftext_properties_at (make_number (point - 1), Qnil))
+ || ! NILP (Ftext_properties_at (make_number (PT - 1), Qnil))
#endif
/* Give up if w is minibuffer and a message is being displayed there */
#ifdef HAVE_FACES
int dummy;
- if (FRAME_X_P (frame))
- face = compute_char_face (frame, w, point - 1, -1, -1, &dummy, point, 0);
+ if (FRAME_WINDOW_P (frame) || FRAME_MSDOS_P (frame))
+ face = compute_char_face (frame, w, PT - 1, -1, -1, &dummy, PT, 0);
#endif
current_frame->glyphs[vpos][hpos] = MAKE_GLYPH (frame, g, face);
- current_frame->charstarts[vpos][hpos] = point - 1;
+ current_frame->charstarts[vpos][hpos] = PT - 1;
/* Record the entry for after the newly inserted character. */
- current_frame->charstarts[vpos][hpos + 1] = point;
+ current_frame->charstarts[vpos][hpos + 1] = PT;
adjust_window_charstarts (w, vpos, 1);
}
unchanged_modified = MODIFF;
beg_unchanged = GPT - BEG;
- XSETFASTINT (w->last_point, point);
- XSETFASTINT (w->last_point_x, hpos);
+ XSETFASTINT (w->last_point, PT);
+ XSETFASTINT (w->last_point_x, hpos + 1);
XSETFASTINT (w->last_modified, MODIFF);
+ XSETFASTINT (w->last_overlay_modified, OVERLAY_MODIFF);
reassert_line_highlight (0, vpos);
write_glyphs (¤t_frame->glyphs[vpos][hpos], 1);
int hpos = FRAME_CURSOR_X (frame);
/* Give up if in truncated text at end of line. */
- if (hpos >= XFASTINT (w->left) + window_internal_width (w) - 1)
+ /* This check is not redundant. */
+ if (hpos >= WINDOW_LEFT_MARGIN (w) + window_internal_width (w) - 1)
+ return 0;
+
+ /* Give up if the buffer's direction is reversed (i.e. right-to-left). */
+ if (!NILP (XBUFFER(w->buffer)->direction_reversed))
return 0;
/* Avoid losing if cursor is in invisible text off left margin
or about to go off either side of window. */
- if ((FRAME_CURSOR_X (frame) == XFASTINT (w->left)
+ if ((FRAME_CURSOR_X (frame) == WINDOW_LEFT_MARGIN (w)
&& (XINT (w->hscroll) || n < 0))
|| (n > 0
- && (FRAME_CURSOR_X (frame) + 1 >= window_internal_width (w) - 1))
+ && (FRAME_CURSOR_X (frame) + 1
+ >= XFASTINT (w->left) + window_internal_width (w) - 1))
+ /* BUG FIX: Added "XFASTINT (w->left)". Without this,
+ direct_output_forward_char() always fails on "the right"
+ window. */
|| cursor_in_echo_area)
return 0;
-
+
/* Can't use direct output if highlighting a region. */
if (!NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active))
return 0;
+ /* Can't use direct output at an overlay boundary; it might have
+ before-string or after-string properties. */
+ if (overlay_touches_p (PT) || overlay_touches_p (PT - n))
+ return 0;
+
#ifdef USE_TEXT_PROPERTIES
/* Don't use direct output next to an invisible character
since we might need to do something special. */
- XSETFASTINT (position, point);
+ XSETFASTINT (position, PT);
if (XFASTINT (position) < ZV
&& ! NILP (Fget_char_property (position,
Qinvisible,
selected_window)))
return 0;
- XSETFASTINT (position, point - 1);
+ XSETFASTINT (position, PT - 1);
if (XFASTINT (position) >= BEGV
&& ! NILP (Fget_char_property (position,
Qinvisible,
FRAME_CURSOR_X (frame) += n;
XSETFASTINT (w->last_point_x, FRAME_CURSOR_X (frame));
- XSETFASTINT (w->last_point, point);
+ XSETFASTINT (w->last_point, PT);
cursor_to (FRAME_CURSOR_Y (frame), FRAME_CURSOR_X (frame));
fflush (stdout);
register int i;
int pause;
int preempt_count = baud_rate / 2400 + 1;
- extern input_pending;
-#ifdef HAVE_X_WINDOWS
+ extern int input_pending;
+#ifdef HAVE_WINDOW_SYSTEM
register int downto, leftmost;
#endif
if (desired_frame->enable[FRAME_HEIGHT (f) - 1])
update_line (f, FRAME_HEIGHT (f) - 1);
-#ifdef HAVE_X_WINDOWS
- if (FRAME_X_P (f))
+#ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
{
- leftmost = downto = f->display.x->internal_border_width;
+ leftmost = downto = FRAME_INTERNAL_BORDER_WIDTH (f);
if (desired_frame->enable[0])
{
current_frame->top_left_x[FRAME_HEIGHT (f) - 1] = leftmost;
current_frame->top_left_y[FRAME_HEIGHT (f) - 1]
- = PIXEL_HEIGHT (f) - f->display.x->internal_border_width
+ = PIXEL_HEIGHT (f) - FRAME_INTERNAL_BORDER_WIDTH (f)
- current_frame->pix_height[FRAME_HEIGHT (f) - 1];
current_frame->top_left_x[0] = leftmost;
current_frame->top_left_y[0] = downto;
}
}
-#endif /* HAVE_X_WINDOWS */
+#endif /* HAVE_WINDOW_SYSTEM */
/* Now update the rest of the lines. */
for (i = 0; i < FRAME_HEIGHT (f) - 1 && (force || !input_pending); i++)
sleep (outq / baud_rate);
}
}
- if ((i - 1) % preempt_count == 0)
- detect_input_pending ();
}
+ if ((i - 1) % preempt_count == 0)
+ detect_input_pending ();
+
update_line (f, i);
-#ifdef HAVE_X_WINDOWS
- if (FRAME_X_P (f))
+#ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
{
current_frame->top_left_y[i] = downto;
current_frame->top_left_x[i] = leftmost;
}
-#endif /* HAVE_X_WINDOWS */
+#endif /* HAVE_WINDOW_SYSTEM */
}
-#ifdef HAVE_X_WINDOWS
- if (FRAME_X_P (f))
+#ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
downto += current_frame->pix_height[i];
-#endif
+#endif /* HAVE_WINDOW_SYSTEM */
}
pause = (i < FRAME_HEIGHT (f) - 1) ? i : 0;
/* Now just clean up termcap drivers and set cursor, etc. */
if (!pause)
{
- if (cursor_in_echo_area
- && FRAME_HAS_MINIBUF_P (f))
+ if ((cursor_in_echo_area
+ /* If we are showing a message instead of the minibuffer,
+ show the cursor for the message instead of for the
+ (now hidden) minibuffer contents. */
+ || (EQ (minibuf_window, selected_window)
+ && EQ (minibuf_window, echo_area_window)
+ && echo_area_glyphs != 0))
+ /* These cases apply only to the frame that contains
+ the active minibuffer window. */
+ && FRAME_HAS_MINIBUF_P (f)
+ && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
{
int top = XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top);
int row, col;
}
while (row > top && col == 0);
- if (col >= FRAME_WIDTH (f))
+ /* Make sure COL is not out of range. */
+ if (col >= FRAME_CURSOR_X_LIMIT (f))
{
- col = 0;
+ /* If we have another row, advance cursor into it. */
if (row < FRAME_HEIGHT (f) - 1)
- row++;
+ {
+ col = FRAME_LEFT_SCROLL_BAR_WIDTH (f);
+ row++;
+ }
+ /* Otherwise move it back in range. */
+ else
+ col = FRAME_CURSOR_X_LIMIT (f) - 1;
}
}
cursor_to (row, col);
}
else
- cursor_to (FRAME_CURSOR_Y (f), max (min (FRAME_CURSOR_X (f),
- FRAME_WIDTH (f) - 1), 0));
+ cursor_to (FRAME_CURSOR_Y (f),
+ minmax (0, FRAME_CURSOR_X (f),
+ FRAME_CURSOR_X_LIMIT (f) - 1));
}
update_end (f);
void
quit_error_check ()
{
+#if 0
if (FRAME_DESIRED_GLYPHS (selected_frame) == 0)
return;
if (FRAME_DESIRED_GLYPHS (selected_frame)->enable[0])
abort ();
if (FRAME_DESIRED_GLYPHS (selected_frame)->enable[FRAME_HEIGHT (selected_frame) - 1])
abort ();
+#endif
}
\f
/* Decide what insert/delete line to do, and do it */
extern void scrolling_1 ();
+int
scrolling (frame)
FRAME_PTR frame;
{
return 0;
old_hash[i] = line_hash_code (current_frame, i);
if (! desired_frame->enable[i])
- new_hash[i] = old_hash[i];
+ {
+ /* This line cannot be redrawn, so don't let scrolling mess it. */
+ new_hash[i] = old_hash[i];
+#define INFINITY 1000000 /* Taken from scroll.c */
+ draw_cost[i] = INFINITY;
+ }
else
- new_hash[i] = line_hash_code (desired_frame, i);
+ {
+ new_hash[i] = line_hash_code (desired_frame, i);
+ draw_cost[i] = line_draw_cost (desired_frame, i);
+ }
if (old_hash[i] != new_hash[i])
{
}
else if (i == unchanged_at_top)
unchanged_at_top++;
- draw_cost[i] = line_draw_cost (desired_frame, i);
old_draw_cost[i] = line_draw_cost (current_frame, i);
}
int col, line;
{
int hscroll = XINT (window->hscroll);
- int window_left = XFASTINT (window->left);
+ int window_left = WINDOW_LEFT_MARGIN (window);
/* The actual width of the window is window->width less one for the
DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
current_buffer = XBUFFER (window->buffer);
+ /* We can't get a correct result in this case,
+ but at least prevent compute_motion from crashing. */
+ if (startp < BEGV)
+ startp = BEGV;
+
/* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
(window->frame))->bufp to avoid scanning from the very top of
the window, but it isn't maintained correctly, and I'm not even
sure I will keep it. */
posn = compute_motion (startp, 0,
- (window == XWINDOW (minibuf_window) && startp == 1
- ? minibuf_prompt_width : 0)
- + (hscroll ? 1 - hscroll : 0),
+ ((window == XWINDOW (minibuf_window) && startp == BEG
+ ? minibuf_prompt_width : 0)
+ + (hscroll ? 1 - hscroll : 0)),
+ 0,
ZV, line, col,
window_width, hscroll, 0, window);
/* Char insertion/deletion cost vector, from term.c */
extern int *char_ins_del_vector;
-#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
+#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
static void
update_line (frame, vpos)
int *temp1;
int tem;
int osp, nsp, begmatch, endmatch, olen, nlen;
- int save;
+ GLYPH save;
register struct frame_glyphs *current_frame
= FRAME_CURRENT_GLYPHS (frame);
register struct frame_glyphs *desired_frame
if (! current_frame->highlight[vpos])
{
if (!must_write_spaces)
- while (obody[olen - 1] == SPACEGLYPH && olen > 0)
+ while (olen > 0 && obody[olen - 1] == SPACEGLYPH)
olen--;
}
else
spaces all the way to the frame edge
so that the reverse video extends all the way across. */
- while (olen < FRAME_WIDTH (frame) - 1)
+ while (olen < FRAME_WINDOW_WIDTH (frame) - 1)
obody[olen++] = SPACEGLYPH;
}
}
current_frame->highlight[vpos] = desired_frame->highlight[vpos];
current_frame->bufp[vpos] = desired_frame->bufp[vpos];
-#ifdef HAVE_X_WINDOWS
- if (FRAME_X_P (frame))
+#ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (frame))
{
current_frame->pix_width[vpos]
= current_frame->used[vpos]
- * FONT_WIDTH (frame->display.x->font);
+ * FONT_WIDTH (FRAME_FONT (frame));
current_frame->pix_height[vpos]
- = frame->display.x->line_height;
+ = FRAME_LINE_HEIGHT (frame);
}
-#endif /* HAVE_X_WINDOWS */
+#endif /* HAVE_WINDOW_SYSTEM */
if (!desired_frame->enable[vpos])
{
all the way to the frame edge
so that the reverse video extends all the way across. */
- while (nlen < FRAME_WIDTH (frame) - 1)
+ while (nlen < FRAME_WINDOW_WIDTH (frame) - 1)
nbody[nlen++] = SPACEGLYPH;
}
if (i >= olen || nbody[i] != obody[i]) /* A non-matching char. */
{
cursor_to (vpos, i);
- for (j = 1; (i + j < nlen &&
- (i + j >= olen || nbody[i+j] != obody[i+j]));
+ for (j = 1;
+ (i + j < nlen
+ && (i + j >= olen || nbody[i + j] != obody[i + j]
+ || (nbody[i + j] & GLYPH_MASK_PADDING)));
j++);
/* Output this run of non-matching chars. */
olen = nlen - (nsp - osp);
}
cursor_to (vpos, osp);
- insert_glyphs ((char *)0, nsp - osp);
+ insert_glyphs ((GLYPH *) 0, nsp - osp);
}
olen += nsp - osp;
there is no need to do clear-to-eol at the end.
(and it would not be safe, since cursor is not
going to be "at the margin" after the text is done) */
- if (nlen == FRAME_WIDTH (frame))
+ if (nlen == FRAME_WINDOW_WIDTH (frame))
olen = 0;
write_glyphs (nbody + nsp + begmatch, nlen - tem);
it will lose one way or another (depending on AutoWrap)
to clear to end of line after outputting all the text.
So pause with one character to go and clear the line then. */
- if (nlen == FRAME_WIDTH (frame) && fast_clear_end_of_line && olen > nlen)
+ if (nlen == FRAME_WINDOW_WIDTH (frame) && fast_clear_end_of_line && olen > nlen)
{
/* endmatch must be zero, and tem must equal nsp + begmatch */
write_glyphs (nbody + tem, nlen - tem - 1);
}
else if (nlen > olen)
{
- write_glyphs (nbody + nsp + begmatch, olen - tem);
- insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
+ /* Here, we used to have the following simple code:
+ ----------------------------------------
+ write_glyphs (nbody + nsp + begmatch, olen - tem);
+ insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
+ ----------------------------------------
+ but it doesn't work if nbody[nsp + begmatch + olen - tem]
+ is a padding glyph. */
+ int out = olen - tem; /* Columns to be overwritten originally. */
+ int del;
+
+ /* Calculate columns we can actually overwrite. */
+ while (nbody[nsp + begmatch + out] & GLYPH_MASK_PADDING) out--;
+ write_glyphs (nbody + nsp + begmatch, out);
+ /* If we left columns to be overwritten. we must delete them. */
+ del = olen - tem - out;
+ if (del > 0) delete_glyphs (del);
+ /* At last, we insert columns not yet written out. */
+ insert_glyphs (nbody + nsp + begmatch + out, nlen - olen + del);
olen = nlen;
}
else if (olen > nlen)
current_frame->charstarts[vpos] = temp1;
}
\f
-/* A vector of size >= NFRAMES + 3 * NBUFFERS + 1, containing the session's
- frames, buffers, buffer-read-only flags, and buffer-modified-flags,
- and a trailing sentinel (so we don't need to add length checks). */
+/* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
+ session's frames, frame names, buffers, buffer-read-only flags, and
+ buffer-modified-flags, and a trailing sentinel (so we don't need to
+ add length checks). */
static Lisp_Object frame_and_buffer_state;
DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p,
Sframe_or_buffer_changed_p, 0, 0, 0,
"Return non-nil if the frame and buffer state appears to have changed.\n\
The state variable is an internal vector containing all frames and buffers,\n\
+aside from buffers whose names start with space,\n\
along with the buffers' read-only and modified flags, which allows a fast\n\
check to see whether the menu bars might need to be recomputed.\n\
If this function returns non-nil, it updates the internal vector to reflect\n\
Lisp_Object tail, frame, buf;
Lisp_Object *vecp;
int n;
+
vecp = XVECTOR (frame_and_buffer_state)->contents;
FOR_EACH_FRAME (tail, frame)
- if (!EQ (*vecp++, frame))
- goto changed;
+ {
+ if (!EQ (*vecp++, frame))
+ goto changed;
+ if (!EQ (*vecp++, XFRAME (frame)->name))
+ goto changed;
+ }
/* Check that the buffer info matches.
No need to test for the end of the vector
because the last element of the vector is lambda
for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
{
buf = XCONS (XCONS (tail)->car)->cdr;
+ /* Ignore buffers that aren't included in buffer lists. */
+ if (XSTRING (XBUFFER (buf)->name)->data[0] == ' ')
+ continue;
if (!EQ (*vecp++, buf))
goto changed;
if (!EQ (*vecp++, XBUFFER (buf)->read_only))
goto changed;
}
/* Detect deletion of a buffer at the end of the list. */
- if (*vecp == Qlambda)
+ if (EQ (*vecp, Qlambda))
return Qnil;
changed:
/* Start with 1 so there is room for at least one lambda at the end. */
n = 1;
FOR_EACH_FRAME (tail, frame)
- n++;
+ n += 2;
for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
n += 3;
/* Reallocate the vector if it's grown, or if it's shrunk a lot. */
if (n > XVECTOR (frame_and_buffer_state)->size
- || n < XVECTOR (frame_and_buffer_state)->size / 2)
- frame_and_buffer_state = Fmake_vector (make_number (n), Qlambda);
+ || n + 20 < XVECTOR (frame_and_buffer_state)->size / 2)
+ /* Add 20 extra so we grow it less often. */
+ frame_and_buffer_state = Fmake_vector (make_number (n + 20), Qlambda);
vecp = XVECTOR (frame_and_buffer_state)->contents;
FOR_EACH_FRAME (tail, frame)
- *vecp++ = frame;
+ {
+ *vecp++ = frame;
+ *vecp++ = XFRAME (frame)->name;
+ }
for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
{
buf = XCONS (XCONS (tail)->car)->cdr;
+ /* Ignore buffers that aren't included in buffer lists. */
+ if (XSTRING (XBUFFER (buf)->name)->data[0] == ' ')
+ continue;
*vecp++ = buf;
*vecp++ = XBUFFER (buf)->read_only;
*vecp++ = Fbuffer_modified_p (buf);
}
- /* If we left any slack in the vector, fill it up now. */
- for (; n < XVECTOR (frame_and_buffer_state)->size; ++n)
+ /* Fill up the vector with lambdas (always at least one). */
+ *vecp++ = Qlambda;
+ while (vecp - XVECTOR (frame_and_buffer_state)->contents
+ < XVECTOR (frame_and_buffer_state)->size)
*vecp++ = Qlambda;
+ /* Make sure we didn't overflow the vector. */
+ if (vecp - XVECTOR (frame_and_buffer_state)->contents
+ > XVECTOR (frame_and_buffer_state)->size)
+ abort ();
return Qt;
}
\f
#ifdef SIGWINCH
SIGTYPE
-window_change_signal ()
+window_change_signal (signalnum) /* If we don't have an argument, */
+ int signalnum; /* some compilers complain in signal calls. */
{
int width, height;
extern int errno;
/* Do any change in frame size that was requested by a signal. */
+void
do_pending_window_change ()
{
/* If window_change_signal should have run before, run it now. */
redisplay. Since this tries to resize windows, we can't call it
from a signal handler. */
-change_frame_size (frame, newheight, newwidth, pretend, delay)
+void
+change_frame_size (f, newheight, newwidth, pretend, delay)
+ register FRAME_PTR f;
+ int newheight, newwidth, pretend, delay;
+{
+ Lisp_Object tail, frame;
+
+ if (! FRAME_WINDOW_P (f))
+ {
+ /* When using termcap, or on MS-DOS, all frames use
+ the same screen, so a change in size affects all frames. */
+ FOR_EACH_FRAME (tail, frame)
+ if (! FRAME_WINDOW_P (XFRAME (frame)))
+ change_frame_size_1 (XFRAME (frame), newheight, newwidth,
+ pretend, delay);
+ }
+ else
+ change_frame_size_1 (f, newheight, newwidth, pretend, delay);
+}
+
+static void
+change_frame_size_1 (frame, newheight, newwidth, pretend, delay)
register FRAME_PTR frame;
- int newheight, newwidth, pretend;
+ int newheight, newwidth, pretend, delay;
{
+ int new_frame_window_width;
+ unsigned int total_glyphs;
+ int count = specpdl_ptr - specpdl;
+
/* If we can't deal with the change now, queue it for later. */
if (delay)
{
FRAME_NEW_WIDTH (frame) = 0;
/* If an argument is zero, set it to the current value. */
- newheight || (newheight = FRAME_HEIGHT (frame));
- newwidth || (newwidth = FRAME_WIDTH (frame));
+ if (newheight == 0)
+ newheight = FRAME_HEIGHT (frame);
+ if (newwidth == 0)
+ newwidth = FRAME_WIDTH (frame);
+ new_frame_window_width = FRAME_WINDOW_WIDTH_ARG (frame, newwidth);
+
+ total_glyphs = newheight * (newwidth + 2) * sizeof (GLYPH);
+
+ /* If these sizes are so big they cause overflow,
+ just ignore the change. It's not clear what better we could do. */
+ if (total_glyphs / sizeof (GLYPH) / newheight != newwidth + 2)
+ return;
/* Round up to the smallest acceptable size. */
check_frame_size (frame, &newheight, &newwidth);
/* If we're not changing the frame size, quit now. */
if (newheight == FRAME_HEIGHT (frame)
- && newwidth == FRAME_WIDTH (frame))
+ && new_frame_window_width == FRAME_WINDOW_WIDTH (frame))
return;
+ BLOCK_INPUT;
+
+#ifdef MSDOS
+ /* We only can set screen dimensions to certain values supported
+ by our video hardware. Try to find the smallest size greater
+ or equal to the requested dimensions. */
+ dos_set_window_size (&newheight, &newwidth);
+#endif
+
if (newheight != FRAME_HEIGHT (frame))
{
if (FRAME_HAS_MINIBUF_P (frame)
#endif
}
- if (newwidth != FRAME_WIDTH (frame))
+ if (new_frame_window_width != FRAME_WINDOW_WIDTH (frame))
{
- set_window_width (FRAME_ROOT_WINDOW (frame), newwidth, 0);
+ set_window_width (FRAME_ROOT_WINDOW (frame), new_frame_window_width, 0);
if (FRAME_HAS_MINIBUF_P (frame))
- set_window_width (FRAME_MINIBUF_WINDOW (frame), newwidth, 0);
+ set_window_width (FRAME_MINIBUF_WINDOW (frame), new_frame_window_width, 0);
if (FRAME_TERMCAP_P (frame) && !pretend)
FrameCols = newwidth;
}
FRAME_HEIGHT (frame) = newheight;
- FRAME_WIDTH (frame) = newwidth;
+ SET_FRAME_WIDTH (frame, newwidth);
- if (FRAME_CURSOR_X (frame) >= FRAME_WIDTH (frame))
- FRAME_CURSOR_X (frame) = FRAME_WIDTH (frame) - 1;
+ if (FRAME_CURSOR_X (frame) >= FRAME_CURSOR_X_LIMIT (frame))
+ FRAME_CURSOR_X (frame) = FRAME_CURSOR_X_LIMIT (frame) - 1;
if (FRAME_CURSOR_Y (frame) >= FRAME_HEIGHT (frame))
FRAME_CURSOR_Y (frame) = FRAME_HEIGHT (frame) - 1;
remake_frame_glyphs (frame);
calculate_costs (frame);
+
+ UNBLOCK_INPUT;
+
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
+ /* This isn't quite a no-op: it runs window-configuration-change-hook. */
+ Fset_window_buffer (FRAME_SELECTED_WINDOW (frame),
+ XWINDOW (FRAME_SELECTED_WINDOW (frame))->buffer);
+
+ unbind_to (count, Qnil);
}
\f
DEFUN ("send-string-to-terminal", Fsend_string_to_terminal,
Ssend_string_to_terminal, 1, 1, 0,
"Send STRING to the terminal without alteration.\n\
Control characters in STRING will have terminal-dependent effects.")
- (str)
- Lisp_Object str;
+ (string)
+ Lisp_Object string;
{
- CHECK_STRING (str, 0);
- fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, stdout);
+ /* ??? Perhaps we should do something special for multibyte strings here. */
+ CHECK_STRING (string, 0);
+ fwrite (XSTRING (string)->data, 1, STRING_BYTES (XSTRING (string)), stdout);
fflush (stdout);
if (termscript)
{
- fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, termscript);
+ fwrite (XSTRING (string)->data, 1, STRING_BYTES (XSTRING (string)),
+ termscript);
fflush (termscript);
}
return Qnil;
return Qnil;
}
+void
bitch_at_user ()
{
if (noninteractive)
else
sec += usec / 1000000, usec %= 1000000;
- if (sec <= 0)
+ if (sec < 0 || (sec == 0 && usec == 0))
return Qnil;
{
it does the redisplay.
It's also much like Fsit_for, except that it can be used for
- waiting for input as well. One differnce is that sit_for
- does not call prepare_menu_bars; Fsit_for does call that. */
+ waiting for input as well. */
Lisp_Object
-sit_for (sec, usec, reading, display)
- int sec, usec, reading, display;
+sit_for (sec, usec, reading, display, initial_display)
+ int sec, usec, reading, display, initial_display;
{
Lisp_Object read_kbd;
- if (detect_input_pending ())
+ swallow_events (display);
+
+ if (detect_input_pending_run_timers (display))
return Qnil;
- if (display)
+ if (initial_display)
redisplay_preserve_echo_area ();
if (sec == 0 && usec == 0)
XSETINT (read_kbd, reading ? -1 : 1);
wait_reading_process_input (sec, usec, read_kbd, display);
-
- /* wait_reading_process_input should always be available now; it is
- simulated in a simple way on systems that don't support
- subprocesses. */
-#if 0
- /* No wait_reading_process_input available. */
- immediate_quit = 1;
- QUIT;
-
- waitchannels = 1;
-#ifdef VMS
- input_wait_timeout (XINT (arg));
-#else /* not VMS */
-#ifndef HAVE_TIMEVAL
- timeout_sec = sec;
- select (1, &waitchannels, 0, 0, &timeout_sec);
-#else /* HAVE_TIMEVAL */
- timeout.tv_sec = sec;
- timeout.tv_usec = usec;
- select (1, &waitchannels, 0, 0, &timeout);
-#endif /* HAVE_TIMEVAL */
-#endif /* not VMS */
-
- immediate_quit = 0;
-#endif
-
return detect_input_pending () ? Qnil : Qt;
}
additional wait period, in milliseconds; this may be useful if your\n\
Emacs was built without floating point support.\n\
\(Not all operating systems support waiting for a fraction of a second.)\n\
-Optional third arg non-nil means don't redisplay, just wait for input.\n\
+Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
Redisplay is preempted as always if input arrives, and does not happen\n\
if input is available before it starts.\n\
Value is t if waited the full time with no input arriving.")
error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE);
#endif
- if (NILP (nodisp))
- prepare_menu_bars ();
- return sit_for (sec, usec, 0, NILP (nodisp));
+ return sit_for (sec, usec, 0, NILP (nodisp), NILP (nodisp));
}
\f
char *terminal_type;
/* Then invoke its decoding routine to set up variables
in the terminal package */
+void
init_display ()
{
#ifdef HAVE_X_WINDOWS
terminal is so dumb that emacs gives up before and doesn't bother
using the window system.
- If the DISPLAY environment variable is set, try to use X, and die
- with an error message if that doesn't work. */
+ If the DISPLAY environment variable is set and nonempty,
+ try to use X, and die with an error message if that doesn't work. */
#ifdef HAVE_X_WINDOWS
if (! display_arg)
{
+ char *display;
#ifdef VMS
- display_arg = (getenv ("DECW$DISPLAY") != 0);
+ display = getenv ("DECW$DISPLAY");
#else
- display_arg = (getenv ("DISPLAY") != 0);
+ display = getenv ("DISPLAY");
#endif
+
+ display_arg = (display != 0 && *display != 0);
}
- if (!inhibit_window_system && display_arg)
+ if (!inhibit_window_system && display_arg
+#ifndef CANNOT_DUMP
+ && initialized
+#endif
+ )
{
Vwindow_system = intern ("x");
#ifdef HAVE_X11
Vwindow_system_version = make_number (11);
#else
Vwindow_system_version = make_number (10);
+#endif
+#if defined (LINUX) && defined (HAVE_LIBNCURSES)
+ /* In some versions of ncurses,
+ tputs crashes if we have not called tgetent.
+ So call tgetent. */
+ { char b[2044]; tgetent (b, "xterm");}
#endif
return;
}
#endif /* HAVE_X_WINDOWS */
+#ifdef HAVE_NTGUI
+ if (!inhibit_window_system)
+ {
+ Vwindow_system = intern ("w32");
+ Vwindow_system_version = make_number (1);
+ return;
+ }
+#endif /* HAVE_NTGUI */
+
/* If no window system has been specified, try to use the terminal. */
if (! isatty (0))
{
- fprintf (stderr, "emacs: standard input is not a tty\n");
+ fatal ("standard input is not a tty");
exit (1);
}
term_init (terminal_type);
+ {
+ int width = FRAME_WINDOW_WIDTH (selected_frame);
+ int height = FRAME_HEIGHT (selected_frame);
+
+ unsigned int total_glyphs = height * (width + 2) * sizeof (GLYPH);
+
+ /* If these sizes are so big they cause overflow,
+ just ignore the change. It's not clear what better we could do. */
+ if (total_glyphs / sizeof (GLYPH) / height != width + 2)
+ fatal ("screen size %dx%d too big", width, height);
+ }
+
remake_frame_glyphs (selected_frame);
calculate_costs (selected_frame);
#endif /* SIGWINCH */
}
\f
+void
syms_of_display ()
{
-#ifdef MULTI_FRAME
defsubr (&Sredraw_frame);
-#endif
defsubr (&Sredraw_display);
defsubr (&Sframe_or_buffer_changed_p);
defsubr (&Sopen_termscript);
defsubr (&Ssleep_for);
defsubr (&Ssend_string_to_terminal);
- frame_and_buffer_state = Fmake_vector (make_number (1), Qlambda);
+ frame_and_buffer_state = Fmake_vector (make_number (20), Qlambda);
staticpro (&frame_and_buffer_state);
+ Qdisplay_table = intern ("display-table");
+ staticpro (&Qdisplay_table);
+
DEFVAR_INT ("baud-rate", &baud_rate,
"*The output baud rate of the terminal.\n\
On most systems, changing this value will affect the amount of padding\n\