/* Updating of data structures for redisplay.
- Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
+ Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 1997
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
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 "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 "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"
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 (); */
+ if (FRAME_MSDOS_P (f))
+ set_terminal_modes ();
clear_frame ();
clear_frame_records (f);
update_end (f);
Fredraw_frame (frame);
}
-#else
-
-DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
- /* Don't confuse make-docfile by having two doc strings for this function.
- make-docfile does not pay attention to #if, for good reason! */
- 0)
- (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 width = FRAME_WINDOW_WIDTH (frame);
register 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);
}
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);
- if (! FRAME_TERMCAP_P (frame) || frame == selected_frame)
+ if (FRAME_WINDOW_P (frame) || frame == selected_frame)
SET_FRAME_GARBAGED (frame);
}
\f
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);
}
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);
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++)
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;
/* 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);
int pause;
int preempt_count = baud_rate / 2400 + 1;
extern input_pending;
-#ifdef HAVE_X_WINDOWS
+#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;
if (!pause)
{
if ((cursor_in_echo_area
- && FRAME_HAS_MINIBUF_P (f)
- && EQ (FRAME_MINIBUF_WINDOW (f), minibuf_window))
- /* 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)
- && echo_area_glyphs != 0))
+ /* 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))
+ if (col >= FRAME_WINDOW_WIDTH (f))
{
col = 0;
if (row < FRAME_HEIGHT (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),
+ max (min (FRAME_CURSOR_X (f),
+ FRAME_WINDOW_WIDTH (f) - 1), 0));
}
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 */
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
/* 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. */
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)
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. */
int newheight, newwidth, pretend;
{
Lisp_Object tail, frame;
- if (FRAME_TERMCAP_P (f))
+
+ if (! FRAME_WINDOW_P (f))
{
- /* When using termcap, all frames use the same screen,
- so a change in size affects all termcap frames. */
+ /* 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_TERMCAP_P (XFRAME (frame)))
+ if (! FRAME_WINDOW_P (XFRAME (frame)))
change_frame_size_1 (XFRAME (frame), newheight, newwidth,
pretend, delay);
}
register FRAME_PTR frame;
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_WINDOW_WIDTH (frame))
+ FRAME_CURSOR_X (frame) = FRAME_WINDOW_WIDTH (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);
+ CHECK_STRING (string, 0);
+ fwrite (XSTRING (string)->data, 1, XSTRING (string)->size, stdout);
fflush (stdout);
if (termscript)
{
- fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, termscript);
+ fwrite (XSTRING (string)->data, 1, XSTRING (string)->size, termscript);
fflush (termscript);
}
return Qnil;
else
sec += usec / 1000000, usec %= 1000000;
- if (sec <= 0)
+ if (sec < 0 || (sec == 0 && usec == 0))
return Qnil;
{
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
- return sit_for (sec, usec, 0, NILP (nodisp));
+ return sit_for (sec, usec, 0, NILP (nodisp), NILP (nodisp));
}
\f
char *terminal_type;
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);
\f
syms_of_display ()
{
-#ifdef MULTI_FRAME
defsubr (&Sredraw_frame);
-#endif
defsubr (&Sredraw_display);
defsubr (&Sframe_or_buffer_changed_p);
defsubr (&Sopen_termscript);
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\
HCoop / bpt / emacs.git / blobdiff