/* Updating of data structures for redisplay.
- Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
- 1997, 1998, 1999, 2000, 2001, 2002, 2003,
- 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 1985-1988, 1993-1995, 1997-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <stdio.h>
#include <ctype.h>
#include <setjmp.h>
-
-#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#endif
#include "lisp.h"
#include "termchar.h"
static void update_frame_line (struct frame *, int);
static struct dim allocate_matrices_for_frame_redisplay
(Lisp_Object, int, int, int, int *);
+static int required_matrix_height (struct window *);
+static int required_matrix_width (struct window *);
static void allocate_matrices_for_window_redisplay (struct window *);
static int realloc_glyph_pool (struct glyph_pool *, struct dim);
static void adjust_frame_glyphs (struct frame *);
static int update_window (struct window *, int);
static int update_frame_1 (struct frame *, int, int);
static void set_window_cursor_after_update (struct window *);
-static int row_equal_p (struct window *, struct glyph_row *,
- struct glyph_row *, int);
static void adjust_frame_glyphs_for_window_redisplay (struct frame *);
static void adjust_frame_glyphs_for_frame_redisplay (struct frame *);
-static void reverse_rows (struct glyph_matrix *, int, int);
-static int margin_glyphs_to_reserve (struct window *, int, Lisp_Object);
-static void sync_window_with_frame_matrix_rows (struct window *);
-struct window *frame_row_to_window (struct window *, int);
\f
-/* Non-zero means don't pause redisplay for pending input. (This is
- for debugging and for a future implementation of EDT-like
- scrolling. */
-
-int redisplay_dont_pause;
-
/* Define PERIODIC_PREEMPTION_CHECKING to 1, if micro-second timers
are supported, so we can check for input during redisplay at
regular intervals. */
#if PERIODIC_PREEMPTION_CHECKING
-/* If a number (float), check for user input every N seconds. */
-
-Lisp_Object Vredisplay_preemption_period;
-
/* Redisplay preemption timers. */
static EMACS_TIME preemption_period;
int display_completed;
-/* Lisp variable visible-bell; enables use of screen-flash instead of
- audible bell. */
-
-int visible_bell;
-
-/* Invert the color of the whole frame, at a low level. */
-
-int inverse_video;
-
-/* Line speed of the terminal. */
-
-EMACS_INT baud_rate;
-
-/* Either nil or a symbol naming the window system under which Emacs
- creates the first frame. */
-
-Lisp_Object Vinitial_window_system;
-
-/* Version number of X windows: 10, 11 or nil. */
-
-Lisp_Object Vwindow_system_version;
-
-/* Vector of glyph definitions. Indexed by glyph number, the contents
- are a string which is how to output the glyph.
-
- If Vglyph_table is nil, a glyph is output by using its low 8 bits
- as a character code.
-
- This is an obsolete feature that is no longer used. The variable
- is retained for compatibility. */
-
-Lisp_Object Vglyph_table;
-
-/* Display table to use for vectors that don't specify their own. */
-
-Lisp_Object Vstandard_display_table;
-
-/* Nonzero means reading single-character input with prompt so put
- cursor on mini-buffer after the prompt. Positive means at end of
- text in echo area; negative means at beginning of line. */
-
-int cursor_in_echo_area;
-
Lisp_Object Qdisplay_table, Qredisplay_dont_pause;
\f
has been interrupted for pending input. */
static void
-add_window_display_history (w, msg, paused_p)
- struct window *w;
- char *msg;
- int paused_p;
+add_window_display_history (struct window *w, char *msg, int paused_p)
{
char *buf;
w,
((BUFFERP (w->buffer)
&& STRINGP (XBUFFER (w->buffer)->name))
- ? (char *) SDATA (XBUFFER (w->buffer)->name)
+ ? SSDATA (XBUFFER (w->buffer)->name)
: "???"),
paused_p ? " ***paused***" : "");
strcat (buf, msg);
pending input. */
static void
-add_frame_display_history (f, paused_p)
- struct frame *f;
- int paused_p;
+add_frame_display_history (struct frame *f, int paused_p)
{
char *buf;
}
-DEFUN ("dump-redisplay-history", Fdump_redisplay_history,
+DEFUE ("dump-redisplay-history", Fdump_redisplay_history,
Sdump_redisplay_history, 0, 0, "",
doc: /* Dump redisplay history to stderr. */)
(void)
/* Copy glyph row structure FROM to glyph row structure TO, except
that glyph pointers in the structures are left unchanged. */
-INLINE void
+static INLINE void
copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
{
struct glyph *pointers[1 + LAST_AREA];
}
-/* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
- TO and FROM are left unchanged. Glyph contents are copied from the
- glyph memory of FROM to the glyph memory of TO. Increment buffer
- positions in row TO by DELTA/ DELTA_BYTES. */
-
-void
-copy_glyph_row_contents (struct glyph_row *to, struct glyph_row *from,
- EMACS_INT delta, EMACS_INT delta_bytes)
-{
- int area;
-
- /* This is like a structure assignment TO = FROM, except that
- glyph pointers in the rows are left unchanged. */
- copy_row_except_pointers (to, from);
-
- /* Copy glyphs from FROM to TO. */
- for (area = 0; area < LAST_AREA; ++area)
- if (from->used[area])
- memcpy (to->glyphs[area], from->glyphs[area],
- from->used[area] * sizeof (struct glyph));
-
- /* Increment buffer positions in TO by DELTA. */
- increment_row_positions (to, delta, delta_bytes);
-}
-
-
/* Assign glyph row FROM to glyph row TO. This works like a structure
assignment TO = FROM, except that glyph pointers are not copied but
exchanged between TO and FROM. Pointers must be exchanged to avoid
#if GLYPH_DEBUG
static int
-glyph_row_slice_p (window_row, frame_row)
- struct glyph_row *window_row, *frame_row;
+glyph_row_slice_p (struct glyph_row *window_row, struct glyph_row *frame_row)
{
struct glyph *window_glyph_start = window_row->glyphs[0];
struct glyph *frame_glyph_start = frame_row->glyphs[0];
in WINDOW_MATRIX is found satisfying the condition. */
static struct glyph_row *
-find_glyph_row_slice (window_matrix, frame_matrix, row)
- struct glyph_matrix *window_matrix, *frame_matrix;
- int row;
+find_glyph_row_slice (struct glyph_matrix *window_matrix,
+ struct glyph_matrix *frame_matrix, int row)
{
int i;
/* Return a hash code for glyph row ROW. */
-int
+static int
line_hash_code (struct glyph_row *row)
{
int hash = 0;
/* Test two glyph rows A and B for equality. Value is non-zero if A
- and B have equal contents. W is the window to which the glyphs
- rows A and B belong. It is needed here to test for partial row
- visibility. MOUSE_FACE_P non-zero means compare the mouse_face_p
- flags of A and B, too. */
+ and B have equal contents. MOUSE_FACE_P non-zero means compare the
+ mouse_face_p flags of A and B, too. */
static INLINE int
-row_equal_p (struct window *w, struct glyph_row *a, struct glyph_row *b, int mouse_face_p)
+row_equal_p (struct glyph_row *a, struct glyph_row *b, int mouse_face_p)
{
if (a == b)
return 1;
*/
void
-flush_stdout ()
+flush_stdout (void)
{
fflush (stdout);
}
MATRIX. */
void
-check_matrix_pointer_lossage (matrix)
- struct glyph_matrix *matrix;
+check_matrix_pointer_lossage (struct glyph_matrix *matrix)
{
int i, j;
/* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
struct glyph_row *
-matrix_row (matrix, row)
- struct glyph_matrix *matrix;
- int row;
+matrix_row (struct glyph_matrix *matrix, int row)
{
xassert (matrix && matrix->rows);
xassert (row >= 0 && row < matrix->nrows);
window W. */
static void
-check_matrix_invariants (w)
- struct window *w;
+check_matrix_invariants (struct window *w)
{
struct glyph_matrix *matrix = w->current_matrix;
int yb = window_text_bottom_y (w);
/* Return the required height of glyph matrices for window W. */
-int
+static int
required_matrix_height (struct window *w)
{
#ifdef HAVE_WINDOW_SYSTEM
/* Return the required width of glyph matrices for window W. */
-int
+static int
required_matrix_width (struct window *w)
{
#ifdef HAVE_WINDOW_SYSTEM
static void
adjust_frame_glyphs_for_window_redisplay (struct frame *f)
{
- struct window *w;
-
xassert (FRAME_WINDOW_P (f) && FRAME_LIVE_P (f));
/* Allocate/reallocate window matrices. */
#if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
{
/* Allocate a dummy window if not already done. */
+ struct window *w;
if (NILP (f->menu_bar_window))
{
f->menu_bar_window = make_window ();
#endif /* HAVE_X_WINDOWS */
#ifndef USE_GTK
- /* Allocate/ reallocate matrices of the tool bar window. If we
- don't have a tool bar window yet, make one. */
- if (NILP (f->tool_bar_window))
- {
- f->tool_bar_window = make_window ();
+ {
+ /* Allocate/ reallocate matrices of the tool bar window. If we
+ don't have a tool bar window yet, make one. */
+ struct window *w;
+ if (NILP (f->tool_bar_window))
+ {
+ f->tool_bar_window = make_window ();
+ w = XWINDOW (f->tool_bar_window);
+ XSETFRAME (w->frame, f);
+ w->pseudo_window_p = 1;
+ }
+ else
w = XWINDOW (f->tool_bar_window);
- XSETFRAME (w->frame, f);
- w->pseudo_window_p = 1;
- }
- else
- w = XWINDOW (f->tool_bar_window);
- XSETFASTINT (w->top_line, FRAME_MENU_BAR_LINES (f));
- XSETFASTINT (w->left_col, 0);
- XSETFASTINT (w->total_lines, FRAME_TOOL_BAR_LINES (f));
- XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f));
- allocate_matrices_for_window_redisplay (w);
+ XSETFASTINT (w->top_line, FRAME_MENU_BAR_LINES (f));
+ XSETFASTINT (w->left_col, 0);
+ XSETFASTINT (w->total_lines, FRAME_TOOL_BAR_LINES (f));
+ XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f));
+ allocate_matrices_for_window_redisplay (w);
+ }
#endif
}
/* Return the window in the window tree rooted in W containing frame
row ROW. Value is null if none is found. */
-struct window *
+static struct window *
frame_row_to_window (struct window *w, int row)
{
struct window *found = NULL;
glyph pointers. */
void
-check_window_matrix_pointers (w)
- struct window *w;
+check_window_matrix_pointers (struct window *w)
{
while (w)
{
corresponding frame row. If it isn't, abort. */
static void
-check_matrix_pointers (window_matrix, frame_matrix)
- struct glyph_matrix *window_matrix, *frame_matrix;
+check_matrix_pointers (struct glyph_matrix *window_matrix,
+ struct glyph_matrix *frame_matrix)
{
/* Row number in WINDOW_MATRIX. */
int i = 0;
vertical position relative to W's frame. */
static int
-window_to_frame_vpos (w, vpos)
- struct window *w;
- int vpos;
+window_to_frame_vpos (struct window *w, int vpos)
{
struct frame *f = XFRAME (w->frame);
a horizontal position relative to W's frame. */
static int
-window_to_frame_hpos (w, hpos)
- struct window *w;
- int hpos;
+window_to_frame_hpos (struct window *w, int hpos)
{
xassert (!FRAME_WINDOW_P (XFRAME (w->frame)));
hpos += WINDOW_LEFT_EDGE_COL (w);
Redrawing Frames
**********************************************************************/
-DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
+DEFUE ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
doc: /* Clear frame FRAME and output again what is supposed to appear on it. */)
(Lisp_Object frame)
{
#endif
}
+#if PERIODIC_PREEMPTION_CHECKING
do_pause:
+#endif
/* Reset flags indicating that a window should be updated. */
set_window_update_flags (root_window, 0);
#endif /* HAVE_WINDOW_SYSTEM */
-#ifdef GLYPH_DEBUG
+#if defined GLYPH_DEBUG && 0
/* Check that no row in the current matrix of window W is enabled
which is below what's displayed in the window. */
-void
+static void
check_current_matrix_flags (struct window *w)
{
int last_seen_p = 0;
struct glyph_row *row, *end;
struct glyph_row *mode_line_row;
struct glyph_row *header_line_row;
- int yb, changed_p = 0, mouse_face_overwritten_p = 0, n_updated;
+ int yb, changed_p = 0, mouse_face_overwritten_p = 0;
+#if ! PERIODIC_PREEMPTION_CHECKING
+ int n_updated = 0;
+#endif
rif->update_window_begin_hook (w);
yb = window_text_bottom_y (w);
}
/* Update the rest of the lines. */
- for (n_updated = 0; row < end && (force_p || !input_pending); ++row)
+ for (; row < end && (force_p || !input_pending); ++row)
if (row->enabled_p)
{
int vpos = MATRIX_ROW_VPOS (row, desired_matrix);
{
/* Otherwise clear to the end of the old row. Everything
after that position should be clear already. */
- int x;
+ int xlim;
if (i >= desired_row->used[TEXT_AREA])
rif->cursor_to (vpos, i, desired_row->y,
: (w->phys_cursor.hpos >= desired_row->used[TEXT_AREA])))
{
w->phys_cursor_on_p = 0;
- x = -1;
+ xlim = -1;
}
else
- x = current_row->pixel_width;
- rif->clear_end_of_line (x);
+ xlim = current_row->pixel_width;
+ rif->clear_end_of_line (xlim);
changed_p = 1;
}
}
static struct run **runs;
-/* Add glyph row ROW to the scrolling hash table during the scrolling
- of window W. */
+/* Add glyph row ROW to the scrolling hash table. */
static INLINE struct row_entry *
-add_row_entry (struct window *w, struct glyph_row *row)
+add_row_entry (struct glyph_row *row)
{
struct row_entry *entry;
int i = row->hash % row_table_size;
entry = row_table[i];
- while (entry && !row_equal_p (w, entry->row, row, 1))
+ while (entry && !row_equal_p (entry->row, row, 1))
entry = entry->next;
if (entry == NULL)
&& c->y == d->y
&& MATRIX_ROW_BOTTOM_Y (c) <= yb
&& MATRIX_ROW_BOTTOM_Y (d) <= yb
- && row_equal_p (w, c, d, 1))
+ && row_equal_p (c, d, 1))
{
assign_row (c, d);
d->enabled_p = 0;
&& (MATRIX_ROW (current_matrix, i - 1)->y
== MATRIX_ROW (desired_matrix, j - 1)->y)
&& !MATRIX_ROW (desired_matrix, j - 1)->redraw_fringe_bitmaps_p
- && row_equal_p (w,
- MATRIX_ROW (desired_matrix, i - 1),
+ && row_equal_p (MATRIX_ROW (desired_matrix, i - 1),
MATRIX_ROW (current_matrix, j - 1), 1))
--i, --j;
last_new = i;
{
if (MATRIX_ROW (current_matrix, i)->enabled_p)
{
- entry = add_row_entry (w, MATRIX_ROW (current_matrix, i));
+ entry = add_row_entry (MATRIX_ROW (current_matrix, i));
old_lines[i] = entry;
++entry->old_uses;
}
for (i = first_new; i < last_new; ++i)
{
xassert (MATRIX_ROW_ENABLED_P (desired_matrix, i));
- entry = add_row_entry (w, MATRIX_ROW (desired_matrix, i));
+ entry = add_row_entry (MATRIX_ROW (desired_matrix, i));
++entry->new_uses;
entry->new_line_number = i;
new_lines[i] = entry;
&& old_lines[i]->old_uses == 1
&& old_lines[i]->new_uses == 1)
{
- int j, k;
+ int p, q;
int new_line = old_lines[i]->new_line_number;
struct run *run = run_pool + run_idx++;
run->height = MATRIX_ROW (current_matrix, i)->height;
/* Extend backward. */
- j = i - 1;
- k = new_line - 1;
- while (j > first_old
- && k > first_new
- && old_lines[j] == new_lines[k])
+ p = i - 1;
+ q = new_line - 1;
+ while (p > first_old
+ && q > first_new
+ && old_lines[p] == new_lines[q])
{
- int h = MATRIX_ROW (current_matrix, j)->height;
+ int h = MATRIX_ROW (current_matrix, p)->height;
--run->current_vpos;
--run->desired_vpos;
++run->nrows;
run->height += h;
run->desired_y -= h;
run->current_y -= h;
- --j, --k;
+ --p, --q;
}
/* Extend forward. */
- j = i + 1;
- k = new_line + 1;
- while (j < last_old
- && k < last_new
- && old_lines[j] == new_lines[k])
+ p = i + 1;
+ q = new_line + 1;
+ while (p < last_old
+ && q < last_new
+ && old_lines[p] == new_lines[q])
{
- int h = MATRIX_ROW (current_matrix, j)->height;
+ int h = MATRIX_ROW (current_matrix, p)->height;
++run->nrows;
run->height += h;
- ++j, ++k;
+ ++p, ++q;
}
/* Insert run into list of all runs. Order runs by copied
be copied because they are already in place. This is done
because we can avoid calling update_window_line in this
case. */
- for (j = 0; j < nruns && runs[j]->height > run->height; ++j)
+ for (p = 0; p < nruns && runs[p]->height > run->height; ++p)
;
- for (k = nruns; k > j; --k)
- runs[k] = runs[k - 1];
- runs[j] = run;
+ for (q = nruns; q > p; --q)
+ runs[q] = runs[q - 1];
+ runs[p] = run;
++nruns;
i += run->nrows;
struct glyph_matrix *current_matrix = f->current_matrix;
struct glyph_matrix *desired_matrix = f->desired_matrix;
int i;
- int pause;
+ int pause_p;
int preempt_count = baud_rate / 2400 + 1;
xassert (current_matrix && desired_matrix);
#if !PERIODIC_PREEMPTION_CHECKING
if (!force_p && detect_input_pending_ignore_squeezables ())
{
- pause = 1;
+ pause_p = 1;
goto do_pause;
}
#endif
}
}
- pause = (i < FRAME_LINES (f) - 1) ? i : 0;
+ pause_p = (i < FRAME_LINES (f) - 1) ? i : 0;
/* Now just clean up termcap drivers and set cursor, etc. */
- if (!pause)
+ if (!pause_p)
{
if ((cursor_in_echo_area
/* If we are showing a message instead of the mini-buffer,
}
}
+#if !PERIODIC_PREEMPTION_CHECKING
do_pause:
+#endif
clear_desired_matrices (f);
- return pause;
+ return pause_p;
}
#ifdef SIGWINCH
-SIGTYPE
+static void
window_change_signal (int signalnum) /* If we don't have an argument, */
/* some compilers complain in signal calls. */
{
if (! NILP (file))
{
file = Fexpand_file_name (file, Qnil);
- tty->termscript = fopen (SDATA (file), "w");
+ tty->termscript = fopen (SSDATA (file), "w");
if (tty->termscript == 0)
report_file_error ("Opening termscript", Fcons (file, Qnil));
}
}
-DEFUN ("ding", Fding, Sding, 0, 1, 0,
+DEFUE ("ding", Fding, Sding, 0, 1, 0,
doc: /* Beep, or flash the screen.
Also, unless an argument is given,
terminate any keyboard macro currently executing. */)
Sleeping, Waiting
***********************************************************************/
-DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 2, 0,
+DEFUE ("sleep-for", Fsleep_for, Ssleep_for, 1, 2, 0,
doc: /* Pause, without updating display, for SECONDS seconds.
SECONDS may be a floating-point value, meaning that you can wait for a
fraction of a second. Optional second arg MILLISECONDS specifies an
}
-DEFUN ("redisplay", Fredisplay, Sredisplay, 0, 1, 0,
+DEFUE ("redisplay", Fredisplay, Sredisplay, 0, 1, 0,
doc: /* Perform redisplay if no input is available.
If optional arg FORCE is non-nil or `redisplay-dont-pause' is non-nil,
perform a full redisplay even if input is available.
{
buf = XCDR (XCAR (tail));
/* Ignore buffers that aren't included in buffer lists. */
- if (SREF (XBUFFER (buf)->name, 0) == ' ')
+ if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ')
continue;
if (vecp == end)
goto changed;
goto changed;
if (vecp == end)
goto changed;
- if (!EQ (*vecp++, XBUFFER (buf)->read_only))
+ if (!EQ (*vecp++, BVAR (XBUFFER (buf), read_only)))
goto changed;
if (vecp == end)
goto changed;
{
buf = XCDR (XCAR (tail));
/* Ignore buffers that aren't included in buffer lists. */
- if (SREF (XBUFFER (buf)->name, 0) == ' ')
+ if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ')
continue;
*vecp++ = buf;
- *vecp++ = XBUFFER (buf)->read_only;
+ *vecp++ = BVAR (XBUFFER (buf), read_only);
*vecp++ = Fbuffer_modified_p (buf);
}
/* Fill up the vector with lambdas (always at least one). */
Qredisplay_dont_pause = intern_c_string ("redisplay-dont-pause");
staticpro (&Qredisplay_dont_pause);
- DEFVAR_INT ("baud-rate", &baud_rate,
+ DEFVAR_INT ("baud-rate", baud_rate,
doc: /* *The output baud rate of the terminal.
On most systems, changing this value will affect the amount of padding
and the other strategic decisions made during redisplay. */);
- DEFVAR_BOOL ("inverse-video", &inverse_video,
+ DEFVAR_BOOL ("inverse-video", inverse_video,
doc: /* *Non-nil means invert the entire frame display.
This means everything is in inverse video which otherwise would not be. */);
- DEFVAR_BOOL ("visible-bell", &visible_bell,
+ DEFVAR_BOOL ("visible-bell", visible_bell,
doc: /* *Non-nil means try to flash the frame to represent a bell.
See also `ring-bell-function'. */);
- DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter,
+ DEFVAR_BOOL ("no-redraw-on-reenter", no_redraw_on_reenter,
doc: /* *Non-nil means no need to redraw entire frame after suspending.
A non-nil value is useful if the terminal can automatically preserve
Emacs's frame display when you reenter Emacs.
It is up to you to set this variable if your terminal can do that. */);
- DEFVAR_LISP ("initial-window-system", &Vinitial_window_system,
+ DEFVAR_LISP ("initial-window-system", Vinitial_window_system,
doc: /* Name of the window system that Emacs uses for the first frame.
The value is a symbol:
nil for a termcap frame (a character-only terminal),
use `display-graphic-p' or any of the other `display-*-p'
predicates which report frame's specific UI-related capabilities. */);
- DEFVAR_LISP ("window-system-version", &Vwindow_system_version,
+ DEFVAR_LISP ("window-system-version", Vwindow_system_version,
doc: /* The version number of the window system in use.
For X windows, this is 11. */);
- DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area,
+ DEFVAR_BOOL ("cursor-in-echo-area", cursor_in_echo_area,
doc: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
- DEFVAR_LISP ("glyph-table", &Vglyph_table,
+ DEFVAR_LISP ("glyph-table", Vglyph_table,
doc: /* Table defining how to output a glyph code to the frame.
If not nil, this is a vector indexed by glyph code to define the glyph.
Each element can be:
while outputting it. */);
Vglyph_table = Qnil;
- DEFVAR_LISP ("standard-display-table", &Vstandard_display_table,
+ DEFVAR_LISP ("standard-display-table", Vstandard_display_table,
doc: /* Display table to use for buffers that specify none.
See `buffer-display-table' for more information. */);
Vstandard_display_table = Qnil;
- DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause,
+ DEFVAR_BOOL ("redisplay-dont-pause", redisplay_dont_pause,
doc: /* *Non-nil means update isn't paused when input is detected. */);
redisplay_dont_pause = 0;
#if PERIODIC_PREEMPTION_CHECKING
- DEFVAR_LISP ("redisplay-preemption-period", &Vredisplay_preemption_period,
+ DEFVAR_LISP ("redisplay-preemption-period", Vredisplay_preemption_period,
doc: /* *The period in seconds between checking for input during redisplay.
If input is detected, redisplay is pre-empted, and the input is processed.
If nil, never pre-empt redisplay. */);
Vwindow_system_version = Qnil;
}
}
-
-/* arch-tag: 8d812b1f-04a2-4195-a9c4-381f8457a413
- (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff