/* Updating of data structures for redisplay.
- Copyright (C) 1985,86,87,88,93,94,95,97,98,1999,2000,01,02,03,04
- Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003,
+ 2004, 2005 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, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include <config.h>
#include <signal.h>
int width = XFASTINT (w->total_cols);
double d = max (0, XFLOATINT (margin));
d = min (width / 2 - 1, d);
- n = (int) ((double) total_glyphs / width * d) * w->ncols_scale_factor;
+ n = (int) ((double) total_glyphs / width * d);
}
else
n = 0;
MATRIX_ROW_END_CHARPOS (row) += delta;
MATRIX_ROW_END_BYTEPOS (row) += delta_bytes;
+ if (!row->enabled_p)
+ return;
+
/* Increment positions in glyphs. */
for (area = 0; area < LAST_AREA; ++area)
for (i = 0; i < row->used[area]; ++i)
|| a->left_fringe_face_id != b->left_fringe_face_id
|| a->right_fringe_bitmap != b->right_fringe_bitmap
|| a->right_fringe_face_id != b->right_fringe_face_id
- || a->overlay_arrow_p != b->overlay_arrow_p
+ || a->overlay_arrow_bitmap != b->overlay_arrow_bitmap
|| a->exact_window_width_line_p != b->exact_window_width_line_p
|| a->overlapped_p != b->overlapped_p
|| (MATRIX_ROW_CONTINUATION_LINE_P (a)
if (!WINDOW_RIGHTMOST_P (w))
{
struct Lisp_Char_Table *dp = window_display_table (w);
- right_border_glyph = (dp && INTEGERP (DISP_BORDER_GLYPH (dp))
- ? XINT (DISP_BORDER_GLYPH (dp))
- : '|');
+
+ right_border_glyph
+ = ((dp && INTEGERP (DISP_BORDER_GLYPH (dp)))
+ ? spec_glyph_lookup_face (w, XINT (DISP_BORDER_GLYPH (dp)))
+ : '|');
+
+ if (FAST_GLYPH_FACE (right_border_glyph) <= 0)
+ right_border_glyph
+ = FAST_MAKE_GLYPH (right_border_glyph, VERTICAL_BORDER_FACE_ID);
}
}
else
SET_CHAR_GLYPH_FROM_GLYPH (*border, right_border_glyph);
}
+#if GLYPH_DEBUG
/* Window row window_y must be a slice of frame row
frame_y. */
xassert (glyph_row_slice_p (window_row, frame_row));
/* If rows are in sync, we don't have to copy glyphs because
frame and window share glyphs. */
-#if GLYPH_DEBUG
strcpy (w->current_matrix->method, w->desired_matrix->method);
add_window_display_history (w, w->current_matrix->method, 0);
#endif
}
}
+/* Given a user-specified glyph, possibly including a Lisp-level face
+ ID, return a glyph that has a realized face ID.
+ This is used for glyphs displayed specially and not part of the text;
+ for instance, vertical separators, truncation markers, etc. */
+
+GLYPH
+spec_glyph_lookup_face (w, glyph)
+ struct window *w;
+ GLYPH glyph;
+{
+ int lface_id = FAST_GLYPH_FACE (glyph);
+ /* Convert the glyph's specified face to a realized (cache) face. */
+ if (lface_id > 0)
+ {
+ int face_id = merge_faces (XFRAME (w->frame),
+ Qt, lface_id, DEFAULT_FACE_ID);
+ glyph
+ = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (glyph), face_id);
+ }
+ return glyph;
+}
/* Add spaces to a glyph row ROW in a window matrix.
struct glyph_matrix *m2;
int m2_from;
- w2 = frame_row_to_window (root, frame_to);
- m2 = w2->current_matrix;
- m2_from = frame_from - m2->matrix_y;
- copy_row_except_pointers (m->rows + window_to,
- m2->rows + m2_from);
-
- /* If frame line is empty, window line is empty, too. */
- if (!retained_p[copy_from[i]])
- m->rows[window_to].enabled_p = 0;
+ w2 = frame_row_to_window (root, frame_from);
+ /* ttn@surf.glug.org: when enabling menu bar using `emacs
+ -nw', FROM_FRAME sometimes has no associated window.
+ This check avoids a segfault if W2 is null. */
+ if (w2)
+ {
+ m2 = w2->current_matrix;
+ m2_from = frame_from - m2->matrix_y;
+ copy_row_except_pointers (m->rows + window_to,
+ m2->rows + m2_from);
+
+ /* If frame line is empty, window line is empty, too. */
+ if (!retained_p[copy_from[i]])
+ m->rows[window_to].enabled_p = 0;
+ }
sync_p = 1;
}
else if (from_inside_window_p)
struct window *w;
int hpos;
{
- struct frame *f = XFRAME (w->frame);
-
- xassert (!FRAME_WINDOW_P (f));
+ xassert (!FRAME_WINDOW_P (XFRAME (w->frame)));
hpos += WINDOW_LEFT_EDGE_COL (w);
return hpos;
}
}
}
+#ifdef HAVE_WINDOW_SYSTEM
/* Redraw lines from the current matrix of window W that are
overlapped by other rows. YB is bottom-most y-position in W. */
if (row->overlapping_p && i > 0 && bottom_y < yb)
{
- if (row->used[LEFT_MARGIN_AREA])
- rif->fix_overlapping_area (w, row, LEFT_MARGIN_AREA);
-
- if (row->used[TEXT_AREA])
- rif->fix_overlapping_area (w, row, TEXT_AREA);
-
- if (row->used[RIGHT_MARGIN_AREA])
- rif->fix_overlapping_area (w, row, RIGHT_MARGIN_AREA);
-
- /* Record in neighbour rows that ROW overwrites part of their
- display. */
- if (row->phys_ascent > row->ascent && i > 0)
- MATRIX_ROW (w->current_matrix, i - 1)->overlapped_p = 1;
- if ((row->phys_height - row->phys_ascent
- > row->height - row->ascent)
- && bottom_y < yb)
- MATRIX_ROW (w->current_matrix, i + 1)->overlapped_p = 1;
+ int overlaps = 0;
+
+ if (MATRIX_ROW_OVERLAPS_PRED_P (row)
+ && !MATRIX_ROW (w->current_matrix, i - 1)->overlapped_p)
+ overlaps |= OVERLAPS_PRED;
+ if (MATRIX_ROW_OVERLAPS_SUCC_P (row)
+ && !MATRIX_ROW (w->current_matrix, i + 1)->overlapped_p)
+ overlaps |= OVERLAPS_SUCC;
+
+ if (overlaps)
+ {
+ if (row->used[LEFT_MARGIN_AREA])
+ rif->fix_overlapping_area (w, row, LEFT_MARGIN_AREA, overlaps);
+
+ if (row->used[TEXT_AREA])
+ rif->fix_overlapping_area (w, row, TEXT_AREA, overlaps);
+
+ if (row->used[RIGHT_MARGIN_AREA])
+ rif->fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, overlaps);
+
+ /* Record in neighbour rows that ROW overwrites part of
+ their display. */
+ if (overlaps & OVERLAPS_PRED)
+ MATRIX_ROW (w->current_matrix, i - 1)->overlapped_p = 1;
+ if (overlaps & OVERLAPS_SUCC)
+ MATRIX_ROW (w->current_matrix, i + 1)->overlapped_p = 1;
+ }
}
if (bottom_y >= yb)
}
}
+#endif /* HAVE_WINDOW_SYSTEM */
+
#ifdef GLYPH_DEBUG
extern int input_pending;
extern Lisp_Object do_mouse_tracking;
#if GLYPH_DEBUG
- struct frame *f = XFRAME (WINDOW_FRAME (w));
-#endif
-
/* Check that W's frame doesn't have glyph matrices. */
- xassert (FRAME_WINDOW_P (f));
+ xassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w))));
xassert (updating_frame != NULL);
+#endif
/* Check pending input the first time so that we can quickly return. */
if (redisplay_dont_pause)
force_p = 1;
else
- detect_input_pending ();
+ detect_input_pending_ignore_squeezables ();
/* If forced to complete the update, or if no input is pending, do
the update. */
scrolling large windows with repeated scroll-up
commands will too quickly pause redisplay. */
if (!force_p && ++n_updated % preempt_count == 0)
- detect_input_pending ();
+ detect_input_pending_ignore_squeezables ();
changed_p |= update_window_line (w, vpos,
&mouse_face_overwritten_p);
/* Fix the appearance of overlapping/overlapped rows. */
if (!paused_p && !w->pseudo_window_p)
{
+#ifdef HAVE_WINDOW_SYSTEM
if (changed_p && rif->fix_overlapping_area)
{
redraw_overlapped_rows (w, yb);
redraw_overlapping_rows (w, yb);
}
+#endif
/* Make cursor visible at cursor position of W. */
set_window_cursor_after_update (w);
|| desired_row->y != current_row->y
|| desired_row->visible_height != current_row->visible_height
|| desired_row->cursor_in_fringe_p != current_row->cursor_in_fringe_p
- || desired_row->overlay_arrow_p != current_row->overlay_arrow_p
+ || desired_row->overlay_arrow_bitmap != current_row->overlay_arrow_bitmap
|| current_row->redraw_fringe_bitmaps_p
|| desired_row->mode_line_p != current_row->mode_line_p
|| desired_row->exact_window_width_line_p != current_row->exact_window_width_line_p
|| to->right_fringe_bitmap != from->right_fringe_bitmap
|| to->left_fringe_face_id != from->left_fringe_face_id
|| to->right_fringe_face_id != from->right_fringe_face_id
- || to->overlay_arrow_p != from->overlay_arrow_p))
+ || to->overlay_arrow_bitmap != from->overlay_arrow_bitmap))
from->redraw_fringe_bitmaps_p = 1;
assign_row (to, from);
to->enabled_p = 1, from->enabled_p = 0;
if (redisplay_dont_pause)
force_p = 1;
- else if (!force_p && detect_input_pending ())
+ else if (!force_p && detect_input_pending_ignore_squeezables ())
{
pause = 1;
goto do_pause;
}
if ((i - 1) % preempt_count == 0)
- detect_input_pending ();
+ detect_input_pending_ignore_squeezables ();
update_frame_line (f, i);
}
}
#endif
- row = MATRIX_ROW (w->current_matrix, it.vpos);
- if (row->enabled_p)
+ if (it.vpos < w->current_matrix->nrows
+ && (row = MATRIX_ROW (w->current_matrix, it.vpos),
+ row->enabled_p))
{
if (it.hpos < row->used[TEXT_AREA])
{
it's the one we were looking for. */
glyph = row->glyphs[TEXT_AREA];
end = glyph + row->used[TEXT_AREA];
- for (x0 = *x; glyph < end && x0 > glyph->pixel_width; ++glyph)
+ for (x0 = *x; glyph < end && x0 >= glyph->pixel_width; ++glyph)
x0 -= glyph->pixel_width;
*x = glyph - row->glyphs[TEXT_AREA];
if (glyph < end)
glyph = row->glyphs[area];
end = glyph + row->used[area];
- for (x0 = *x - x0; glyph < end && x0 > glyph->pixel_width; ++glyph)
+ for (x0 = *x - x0; glyph < end && x0 >= glyph->pixel_width; ++glyph)
x0 -= glyph->pixel_width;
*x = glyph - row->glyphs[area];
if (glyph < end)
#endif
int old_errno = errno;
+ signal (SIGWINCH, window_change_signal);
+ SIGNAL_THREAD_CHECK (signalnum);
+
get_frame_size (&width, &height);
/* The frame size change obviously applies to a termcap-controlled
}
}
- signal (SIGWINCH, window_change_signal);
errno = old_errno;
}
#endif /* SIGWINCH */
#ifndef EMACS_HAS_USECS
if (sec == 0 && usec != 0)
- error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE);
+ error ("Millisecond `sleep-for' not supported on %s", SYSTEM_TYPE);
#endif
/* Assure that 0 <= usec < 1000000. */
{
swallow_events (display);
- if (detect_input_pending_run_timers (display) || !NILP (Vexecuting_macro))
+ if (detect_input_pending_run_timers (display) || !NILP (Vexecuting_kbd_macro))
return Qnil;
if (initial_display)
#ifndef EMACS_HAS_USECS
if (usec != 0 && sec == 0)
- error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE);
+ error ("Millisecond `sit-for' not supported on %s", SYSTEM_TYPE);
#endif
return sit_for (sec, usec, 0, NILP (nodisp), NILP (nodisp));
/* 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). */
+ buffer-modified-flags. */
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,
+ Sframe_or_buffer_changed_p, 0, 1, 0,
doc: /* Return non-nil if the frame and buffer state appears to have changed.
-The state variable is an internal vector containing all frames and buffers,
+VARIABLE is a variable name whose value is either nil or a state vector
+that will be updated to contain all frames and buffers,
aside from buffers whose names start with space,
-along with the buffers' read-only and modified flags, which allows a fast
-check to see whether the menu bars might need to be recomputed.
+along with the buffers' read-only and modified flags. This allows a fast
+check to see whether buffer menus might need to be recomputed.
If this function returns non-nil, it updates the internal vector to reflect
-the current state. */)
- ()
+the current state.
+
+If VARIABLE is nil, an internal variable is used. Users should not
+pass nil for VARIABLE. */)
+ (variable)
+ Lisp_Object variable;
{
- Lisp_Object tail, frame, buf;
- Lisp_Object *vecp;
+ Lisp_Object state, tail, frame, buf;
+ Lisp_Object *vecp, *end;
int n;
- vecp = XVECTOR (frame_and_buffer_state)->contents;
+ if (! NILP (variable))
+ {
+ CHECK_SYMBOL (variable);
+ state = Fsymbol_value (variable);
+ if (! VECTORP (state))
+ goto changed;
+ }
+ else
+ state = frame_and_buffer_state;
+
+ vecp = XVECTOR (state)->contents;
+ end = vecp + XVECTOR (state)->size;
+
FOR_EACH_FRAME (tail, frame)
{
+ if (vecp == end)
+ goto changed;
if (!EQ (*vecp++, frame))
goto changed;
+ if (vecp == end)
+ 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
- and that will always cause a mismatch. */
+ /* Check that the buffer info matches. */
for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
{
buf = XCDR (XCAR (tail));
/* Ignore buffers that aren't included in buffer lists. */
if (SREF (XBUFFER (buf)->name, 0) == ' ')
continue;
+ if (vecp == end)
+ goto changed;
if (!EQ (*vecp++, buf))
goto changed;
+ if (vecp == end)
+ goto changed;
if (!EQ (*vecp++, XBUFFER (buf)->read_only))
goto changed;
+ if (vecp == end)
+ goto changed;
if (!EQ (*vecp++, Fbuffer_modified_p (buf)))
goto changed;
}
+ if (vecp == end)
+ goto changed;
/* Detect deletion of a buffer at the end of the list. */
if (EQ (*vecp, Qlambda))
return Qnil;
+
+ /* Come here if we decide the data has changed. */
changed:
- /* Start with 1 so there is room for at least one lambda at the end. */
+ /* Count the size we will need.
+ Start with 1 so there is room for at least one lambda at the end. */
n = 1;
FOR_EACH_FRAME (tail, frame)
n += 2;
for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
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 + 20 < XVECTOR (frame_and_buffer_state)->size / 2)
+ /* Reallocate the vector if data has grown to need it,
+ or if it has shrunk a lot. */
+ if (! VECTORP (state)
+ || n > XVECTOR (state)->size
+ || n + 20 < XVECTOR (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;
+ {
+ state = Fmake_vector (make_number (n + 20), Qlambda);
+ if (! NILP (variable))
+ Fset (variable, state);
+ else
+ frame_and_buffer_state = state;
+ }
+
+ /* Record the new data in the (possibly reallocated) vector. */
+ vecp = XVECTOR (state)->contents;
FOR_EACH_FRAME (tail, frame)
{
*vecp++ = frame;
}
/* 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)
+ while (vecp - XVECTOR (state)->contents
+ < XVECTOR (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)
+ if (vecp - XVECTOR (state)->contents
+ > XVECTOR (state)->size)
abort ();
return Qt;
}