/* Display generation from window structure and buffer text.
-Copyright (C) 1985-1988, 1993-1995, 1997-2015 Free Software Foundation,
+Copyright (C) 1985-1988, 1993-1995, 1997-2016 Free Software Foundation,
Inc.
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "lisp.h"
#include "atimer.h"
+#include "composite.h"
#include "keyboard.h"
+#include "systime.h"
#include "frame.h"
#include "window.h"
#include "termchar.h"
#include "indent.h"
#include "commands.h"
#include "keymap.h"
-#include "macros.h"
#include "disptab.h"
#include "termhooks.h"
#include "termopts.h"
#include "intervals.h"
#include "coding.h"
-#include "process.h"
#include "region-cache.h"
#include "font.h"
#include "fontset.h"
#include "blockinput.h"
+#include "xwidget.h"
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
#endif /* HAVE_WINDOW_SYSTEM */
static bool message_enable_multibyte;
-/* Nonzero if we should redraw the mode lines on the next redisplay.
- If it has value REDISPLAY_SOME, then only redisplay the mode lines where
- the `redisplay' bit has been set. Otherwise, redisplay all mode lines
- (the number used is then only used to track down the cause for this
- full-redisplay). */
+/* At each redisplay cycle, we should refresh everything there is to refresh.
+ To do that efficiently, we use many optimizations that try to make sure we
+ don't waste too much time updating things that haven't changed.
+ The coarsest such optimization is that, in the most common cases, we only
+ look at the selected-window.
+
+ To know whether other windows should be considered for redisplay, we use the
+ variable windows_or_buffers_changed: as long as it is 0, it means that we
+ have not noticed anything that should require updating anything else than
+ the selected-window. If it is set to REDISPLAY_SOME, it means that since
+ last redisplay, some changes have been made which could impact other
+ windows. To know which ones need redisplay, every buffer, window, and frame
+ has a `redisplay' bit, which (if true) means that this object needs to be
+ redisplayed. If windows_or_buffers_changed is 0, we know there's no point
+ looking for those `redisplay' bits (actually, there might be some such bits
+ set, but then only on objects which aren't displayed anyway).
+
+ OTOH if it's non-zero we wil have to loop through all windows and then check
+ the `redisplay' bit of the corresponding window, frame, and buffer, in order
+ to decide whether that window needs attention or not. Note that we can't
+ just look at the frame's redisplay bit to decide that the whole frame can be
+ skipped, since even if the frame's redisplay bit is unset, some of its
+ windows's redisplay bits may be set.
+
+ Mostly for historical reasons, windows_or_buffers_changed can also take
+ other non-zero values. In that case, the precise value doesn't matter (it
+ encodes the cause of the setting but is only used for debugging purposes),
+ and what it means is that we shouldn't pay attention to any `redisplay' bits
+ and we should simply try and redisplay every window out there. */
-int update_mode_lines;
+int windows_or_buffers_changed;
-/* Nonzero if window sizes or contents other than selected-window have changed
- since last redisplay that finished.
- If it has value REDISPLAY_SOME, then only redisplay the windows where
- the `redisplay' bit has been set. Otherwise, redisplay all windows
- (the number used is then only used to track down the cause for this
- full-redisplay). */
+/* Nonzero if we should redraw the mode lines on the next redisplay.
+ Similarly to `windows_or_buffers_changed', If it has value REDISPLAY_SOME,
+ then only redisplay the mode lines in those buffers/windows/frames where the
+ `redisplay' bit has been set.
+ For any other value, redisplay all mode lines (the number used is then only
+ used to track down the cause for this full-redisplay).
+
+ Since the frame title uses the same %-constructs as the mode line
+ (except %c and %l), if this variable is non-zero, we also consider
+ redisplaying the title of each frame, see x_consider_frame_title.
+
+ The `redisplay' bits are the same as those used for
+ windows_or_buffers_changed, and setting windows_or_buffers_changed also
+ causes recomputation of the mode lines of all those windows. IOW this
+ variable only has an effect if windows_or_buffers_changed is zero, in which
+ case we should only need to redisplay the mode-line of those objects with
+ a `redisplay' bit set but not the window's text content (tho we may still
+ need to refresh the text content of the selected-window). */
-int windows_or_buffers_changed;
+int update_mode_lines;
/* True after display_mode_line if %l was used and it displayed a
line number. */
b->text->redisplay = true;
}
+void
+maybe_set_redisplay (Lisp_Object symbol)
+{
+ if (HASH_TABLE_P (Vredisplay__variables)
+ && hash_lookup (XHASH_TABLE (Vredisplay__variables), symbol, NULL) >= 0)
+ {
+ bset_update_mode_line (current_buffer);
+ current_buffer->prevent_redisplay_optimizations_p = true;
+ }
+}
+
#ifdef GLYPH_DEBUG
/* True means print traces of redisplay if compiled with
static void iterate_out_of_display_property (struct it *);
static void pop_it (struct it *);
static void redisplay_internal (void);
-static bool echo_area_display (bool);
+static void echo_area_display (bool);
static void redisplay_windows (Lisp_Object);
static void redisplay_window (Lisp_Object, bool);
static Lisp_Object redisplay_window_error (Lisp_Object);
static bool set_cursor_from_row (struct window *, struct glyph_row *,
struct glyph_matrix *, ptrdiff_t, ptrdiff_t,
int, int);
+static bool cursor_row_fully_visible_p (struct window *, bool, bool);
static bool update_menu_bar (struct frame *, bool, bool);
static bool try_window_reusing_current_matrix (struct window *);
static int try_window_id (struct window *);
static bool next_element_from_composition (struct it *);
static bool next_element_from_image (struct it *);
static bool next_element_from_stretch (struct it *);
+static bool next_element_from_xwidget (struct it *);
static void load_overlay_strings (struct it *, ptrdiff_t);
static bool get_next_display_element (struct it *);
static enum move_it_result
free realized faces now because they depend on face definitions
that might have changed. Don't free faces while there might be
desired matrices pending which reference these faces. */
- if (face_change && !inhibit_free_realized_faces)
+ if (!inhibit_free_realized_faces)
{
- face_change = false;
- free_all_realized_faces (Qnil);
+ if (face_change)
+ {
+ face_change = false;
+ free_all_realized_faces (Qnil);
+ }
+ else if (XFRAME (w->frame)->face_change)
+ {
+ XFRAME (w->frame)->face_change = 0;
+ free_all_realized_faces (w->frame);
+ }
}
/* Perhaps remap BASE_FACE_ID to a user-specified alternative. */
else
{
Lisp_Object fns, fn;
- struct gcpro gcpro1, gcpro2;
fns = Qnil;
- GCPRO2 (val, fns);
for (; CONSP (val); val = XCDR (val))
{
else
safe_call1 (fn, pos);
}
-
- UNGCPRO;
}
unbind_to (count, Qnil);
/* With bidi iteration, the character before the current
in the visual order cannot be found by simple
iteration, because "reverse" reordering is not
- supported. Instead, we need to use the move_it_*
- family of functions. */
+ supported. Instead, we need to start from the string
+ beginning and go all the way to the current string
+ position, remembering the previous position. */
/* Ignore face changes before the first visible
character on this display line. */
if (it->current_x <= it->first_visible_x)
return it->face_id;
SAVE_IT (it_copy, *it, it_copy_data);
- /* Implementation note: Since move_it_in_display_line
- works in the iterator geometry, and thinks the first
- character is always the leftmost, even in R2L lines,
- we don't need to distinguish between the R2L and L2R
- cases here. */
- move_it_in_display_line (&it_copy, SCHARS (it_copy.string),
- it_copy.current_x - 1, MOVE_TO_X);
- charpos = IT_STRING_CHARPOS (it_copy);
+ IT_STRING_CHARPOS (it_copy) = 0;
+ bidi_init_it (0, 0, FRAME_WINDOW_P (it_copy.f), &it_copy.bidi_it);
+
+ do
+ {
+ charpos = IT_STRING_CHARPOS (it_copy);
+ if (charpos >= SCHARS (it->string))
+ break;
+ bidi_move_to_visually_next (&it_copy.bidi_it);
+ }
+ while (IT_STRING_CHARPOS (it_copy) != IT_STRING_CHARPOS (*it));
+
RESTORE_IT (it, it, it_copy_data);
}
else
{
if (before_p)
{
+ int current_x;
+
/* With bidi iteration, the character before the current
in the visual order cannot be found by simple
iteration, because "reverse" reordering is not
supported. Instead, we need to use the move_it_*
- family of functions. */
+ family of functions, and move to the previous
+ character starting from the beginning of the visual
+ line. */
/* Ignore face changes before the first visible
character on this display line. */
if (it->current_x <= it->first_visible_x)
character is always the leftmost, even in R2L lines,
we don't need to distinguish between the R2L and L2R
cases here. */
- move_it_in_display_line (&it_copy, ZV,
- it_copy.current_x - 1, MOVE_TO_X);
+ current_x = it_copy.current_x;
+ move_it_vertically_backward (&it_copy, 0);
+ move_it_in_display_line (&it_copy, ZV, current_x - 1, MOVE_TO_X);
pos = it_copy.current.pos;
RESTORE_IT (it, it, it_copy_data);
}
it->current.dpvec_index = 0;
it->dpvec_face_id = -1;
- /* Remember the current face id in case glyphs specify faces.
- IT's face is restored in set_iterator_to_next.
- saved_face_id was set to preceding char's face in handle_stop. */
- if (it->saved_face_id < 0 || it->saved_face_id != it->face_id)
- it->saved_face_id = it->face_id = DEFAULT_FACE_ID;
+ /* Use IT->saved_face_id for the ellipsis, so that it has the same
+ face as the preceding text. IT->saved_face_id was set in
+ handle_stop to the face of the preceding character, and will be
+ different from IT->face_id only if the invisible text skipped in
+ handle_invisible_prop has some non-default face on its first
+ character. We thus ignore the face of the invisible text when we
+ display the ellipsis. IT's face is restored in set_iterator_to_next. */
+ if (it->saved_face_id >= 0)
+ it->face_id = it->saved_face_id;
/* If the ellipsis represents buffer text, it means we advanced in
the buffer, so we should no longer ignore overlay strings. */
if (CONSP (spec)
/* Simple specifications. */
&& !EQ (XCAR (spec), Qimage)
+#ifdef HAVE_XWIDGETS
+ && !EQ (XCAR (spec), Qxwidget)
+#endif
&& !EQ (XCAR (spec), Qspace)
&& !EQ (XCAR (spec), Qwhen)
&& !EQ (XCAR (spec), Qslice)
if (!NILP (form) && !EQ (form, Qt))
{
ptrdiff_t count = SPECPDL_INDEX ();
- struct gcpro gcpro1;
/* Bind `object' to the object having the `display' property, a
buffer or string. Bind `position' to the position in the
specbind (Qobject, object);
specbind (Qposition, make_number (CHARPOS (*position)));
specbind (Qbuffer_position, make_number (bufpos));
- GCPRO1 (form);
form = safe_eval (form);
- UNGCPRO;
unbind_to (count, Qnil);
}
|| ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
&& valid_image_p (value))
#endif /* not HAVE_WINDOW_SYSTEM */
- || (CONSP (value) && EQ (XCAR (value), Qspace)));
+ || (CONSP (value) && EQ (XCAR (value), Qspace))
+ || ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
+ && valid_xwidget_spec_p (value)));
if (valid_p && display_replaced == 0)
{
*position = it->position = start_pos;
retval = 1 + (it->area == TEXT_AREA);
}
+ else if (valid_xwidget_spec_p (value))
+ {
+ it->what = IT_XWIDGET;
+ it->method = GET_FROM_XWIDGET;
+ it->position = start_pos;
+ it->object = NILP (object) ? it->w->contents : object;
+ *position = start_pos;
+ it->xwidget = lookup_xwidget (value);
+ }
#ifdef HAVE_WINDOW_SYSTEM
else
{
case GET_FROM_STRETCH:
p->u.stretch.object = it->object;
break;
+ case GET_FROM_XWIDGET:
+ p->u.xwidget.object = it->object;
+ break;
+ case GET_FROM_BUFFER:
+ case GET_FROM_DISPLAY_VECTOR:
+ case GET_FROM_STRING:
+ case GET_FROM_C_STRING:
+ break;
+ default:
+ emacs_abort ();
}
p->position = position ? *position : it->position;
p->current = it->current;
it->object = p->u.image.object;
it->slice = p->u.image.slice;
break;
+ case GET_FROM_XWIDGET:
+ it->object = p->u.xwidget.object;
+ break;
case GET_FROM_STRETCH:
it->object = p->u.stretch.object;
break;
it->method = GET_FROM_BUFFER;
it->object = it->w->contents;
}
+ break;
+ case GET_FROM_C_STRING:
+ break;
+ default:
+ emacs_abort ();
}
it->end_charpos = p->end_charpos;
it->string_nchars = p->string_nchars;
next_element_from_string,
next_element_from_c_string,
next_element_from_image,
- next_element_from_stretch
+ next_element_from_stretch,
+ next_element_from_xwidget,
};
#define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
return face_id;
}
+/* Forget the `escape-glyph' and `glyphless-char' faces. This should
+ be called before redisplaying windows, and when the frame's face
+ cache is freed. */
+void
+forget_escape_and_glyphless_faces (void)
+{
+ last_escape_glyph_frame = NULL;
+ last_escape_glyph_face_id = (1 << FACE_ID_BITS);
+ last_glyphless_glyph_frame = NULL;
+ last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
+}
+
/* Load IT's display element fields with information about the next
display element from the current position of IT. Value is false if
end of buffer (or C string) is reached. */
buffer position is stored in the 'position'
member of the iteration stack slot below the
current one, see handle_single_display_spec. By
- contrast, it->current.pos was is not yet updated
+ contrast, it->current.pos was not yet updated
to point to that buffer position; that will
happen in pop_it, after we finish displaying the
current string. Note that we already checked
above that it->sp is positive, so subtracting one
from it is safe. */
if (it->from_disp_prop_p)
- pos = (it->stack + it->sp - 1)->position;
+ {
+ int stackp = it->sp - 1;
+
+ /* Find the stack level with data from buffer. */
+ while (stackp >= 0
+ && STRINGP ((it->stack + stackp)->string))
+ stackp--;
+ eassert (stackp >= 0);
+ pos = (it->stack + stackp)->position;
+ }
else
INC_TEXT_POS (pos, it->multibyte_p);
case GET_FROM_IMAGE:
case GET_FROM_STRETCH:
+ case GET_FROM_XWIDGET:
+
/* The position etc with which we have to proceed are on
the stack. The position may be at the end of a string,
if the `display' property takes up the whole string. */
return true;
}
+static bool
+next_element_from_xwidget (struct it *it)
+{
+ it->what = IT_XWIDGET;
+ return true;
+}
+
/* Fill iterator IT with next display element from a stretch glyph
property. IT->object is the value of the text property. Value is
void
vadd_to_log (char const *format, va_list ap)
{
- ptrdiff_t nargs = 1 + format_nargs (format);
+ ptrdiff_t form_nargs = format_nargs (format);
+ ptrdiff_t nargs = 1 + form_nargs;
Lisp_Object args[10];
eassert (nargs <= ARRAYELTS (args));
- args[0] = build_string (format);
+ AUTO_STRING (args0, format);
+ args[0] = args0;
for (ptrdiff_t i = 1; i <= nargs; i++)
args[i] = va_arg (ap, Lisp_Object);
Lisp_Object msg = Qnil;
- struct gcpro gcpro1, gcpro2;
- GCPRO2 (args, msg);
- gcpro1.nvars = nargs;
- msg = Fformat (nargs, args);
+ msg = Fformat_message (nargs, args);
ptrdiff_t len = SBYTES (msg) + 1;
USE_SAFE_ALLOCA;
message_dolog (buffer, len - 1, true, STRING_MULTIBYTE (msg));
SAFE_FREE ();
-
- UNGCPRO;
}
ptrdiff_t point_at_end = 0;
ptrdiff_t zv_at_end = 0;
Lisp_Object old_deactivate_mark;
- struct gcpro gcpro1;
old_deactivate_mark = Vdeactivate_mark;
oldbuf = current_buffer;
set_marker_restricted_both (oldbegv, Qnil, BEGV, BEGV_BYTE);
oldzv = message_dolog_marker3;
set_marker_restricted_both (oldzv, Qnil, ZV, ZV_BYTE);
- GCPRO1 (old_deactivate_mark);
if (PT == Z)
point_at_end = 1;
TEMP_SET_PT_BOTH (marker_position (oldpoint),
marker_byte_position (oldpoint));
- UNGCPRO;
unchain_marker (XMARKER (oldpoint));
unchain_marker (XMARKER (oldbegv));
unchain_marker (XMARKER (oldzv));
void
message3 (Lisp_Object m)
{
- struct gcpro gcpro1;
-
- GCPRO1 (m);
clear_message (true, true);
cancel_echoing ();
}
if (! inhibit_message)
message3_nolog (m);
- UNGCPRO;
}
+/* Log the message M to stderr. Log an empty line if M is not a string. */
+
+static void
+message_to_stderr (Lisp_Object m)
+{
+ if (noninteractive_need_newline)
+ {
+ noninteractive_need_newline = false;
+ fputc ('\n', stderr);
+ }
+ if (STRINGP (m))
+ {
+ Lisp_Object coding_system = Vlocale_coding_system;
+ Lisp_Object s;
+
+ if (!NILP (Vcoding_system_for_write))
+ coding_system = Vcoding_system_for_write;
+ if (!NILP (coding_system))
+ s = code_convert_string_norecord (m, coding_system, true);
+ else
+ s = m;
+
+ fwrite (SDATA (s), SBYTES (s), 1, stderr);
+ }
+ if (!cursor_in_echo_area)
+ fputc ('\n', stderr);
+ fflush (stderr);
+}
/* The non-logging version of message3.
This does not cancel echoing, because it is used for echoing.
struct frame *sf = SELECTED_FRAME ();
if (FRAME_INITIAL_P (sf))
- {
- if (noninteractive_need_newline)
- putc ('\n', stderr);
- noninteractive_need_newline = false;
- if (STRINGP (m))
- {
- Lisp_Object s = ENCODE_SYSTEM (m);
-
- fwrite (SDATA (s), SBYTES (s), 1, stderr);
- }
- if (!cursor_in_echo_area)
- fprintf (stderr, "\n");
- fflush (stderr);
- }
+ message_to_stderr (m);
/* Error messages get reported properly by cmd_error, so this must be just an
informative message; if the frame hasn't really been initialized yet, just
toss it. */
{
CHECK_STRING (string);
+ bool need_message;
if (noninteractive)
- {
- if (m)
- {
- /* ENCODE_SYSTEM below can GC and/or relocate the
- Lisp data, so make sure we don't use it here. */
- eassert (relocatable_string_data_p (m) != 1);
-
- if (noninteractive_need_newline)
- putc ('\n', stderr);
- noninteractive_need_newline = false;
- fprintf (stderr, m, SDATA (ENCODE_SYSTEM (string)));
- if (!cursor_in_echo_area)
- fprintf (stderr, "\n");
- fflush (stderr);
- }
- }
- else if (INTERACTIVE)
+ need_message = !!m;
+ else if (!INTERACTIVE)
+ need_message = false;
+ else
{
/* The frame whose minibuffer we're going to display the message on.
It may be larger than the selected frame, so we need
/* Error messages get reported properly by cmd_error, so this must be
just an informative message; if the frame hasn't really been
initialized yet, just toss it. */
- if (f->glyphs_initialized_p)
- {
- struct gcpro gcpro1, gcpro2;
-
- Lisp_Object fmt = build_string (m);
- Lisp_Object msg = string;
- GCPRO2 (fmt, msg);
+ need_message = f->glyphs_initialized_p;
+ }
- msg = CALLN (Fformat, fmt, msg);
+ if (need_message)
+ {
+ AUTO_STRING (fmt, m);
+ Lisp_Object msg = CALLN (Fformat_message, fmt, string);
+ if (noninteractive)
+ message_to_stderr (msg);
+ else
+ {
if (log)
message3 (msg);
else
message3_nolog (msg);
- UNGCPRO;
-
/* Print should start at the beginning of the message
buffer next time. */
message_buf_print = false;
reset the echo_area_buffer in question to nil at the end because
with_echo_area_buffer will sets it to an empty buffer. */
bool i = display_last_displayed_message_p;
+ /* According to the C99, C11 and C++11 standards, the integral value
+ of a "bool" is always 0 or 1, so this array access is safe here,
+ if oddly typed. */
no_message_p = NILP (echo_area_buffer[i]);
window_height_changed_p
Lisp_Object window;
struct text_pos start;
+ /* We are about to enter redisplay without going through
+ redisplay_internal, so we need to forget these faces by hand
+ here. */
+ forget_escape_and_glyphless_faces ();
+
/* Do this before displaying, so that we have a large enough glyph
matrix for the display. If we can't get enough space for the
whole text, display the last N lines. That works by setting w->start. */
if (frame_garbaged)
{
Lisp_Object tail, frame;
+ struct frame *sf = SELECTED_FRAME ();
FOR_EACH_FRAME (tail, frame)
{
if (FRAME_VISIBLE_P (f) && FRAME_GARBAGED_P (f))
{
- if (f->resized_p)
+ if (f->resized_p
+ /* It makes no sense to redraw a non-selected TTY
+ frame, since that will actually clear the
+ selected frame, and might leave the selected
+ frame with corrupted display, if it happens not
+ to be marked garbaged. */
+ && !(f != sf && (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))))
redraw_frame (f);
else
clear_current_matrices (f);
}
-/* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P,
- update selected_frame. Value is true if the mini-windows height
- has been changed. */
+/* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P, update
+ selected_frame. */
-static bool
+static void
echo_area_display (bool update_frame_p)
{
Lisp_Object mini_window;
/* Don't display if frame is invisible or not yet initialized. */
if (!FRAME_VISIBLE_P (f) || !f->glyphs_initialized_p)
- return false;
+ return;
#ifdef HAVE_WINDOW_SYSTEM
/* When Emacs starts, selected_frame may be the initial terminal
frame. If we let this through, a message would be displayed on
the terminal. */
if (FRAME_INITIAL_P (XFRAME (selected_frame)))
- return false;
+ return;
#endif /* HAVE_WINDOW_SYSTEM */
/* Redraw garbaged frames. */
pending input. */
ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qredisplay_dont_pause, Qt);
- windows_or_buffers_changed = 44;
+ fset_redisplay (f);
redisplay_internal ();
unbind_to (count, Qnil);
}
if (EQ (mini_window, selected_window))
CHARPOS (this_line_start_pos) = 0;
- return window_height_changed_p;
+ if (window_height_changed_p)
+ {
+ fset_redisplay (f);
+
+ /* If window configuration was changed, frames may have been
+ marked garbaged. Clear them or we will experience
+ surprises wrt scrolling.
+ FIXME: How/why/when? */
+ clear_garbaged_frames ();
+ }
}
/* True if W's buffer was changed but not saved. */
{
struct frame *f = XFRAME (frame);
- if (FRAME_WINDOW_P (f)
- || FRAME_MINIBUF_ONLY_P (f)
- || f->explicit_name)
+ if ((FRAME_WINDOW_P (f)
+ || FRAME_MINIBUF_ONLY_P (f)
+ || f->explicit_name)
+ && NILP (Fframe_parameter (frame, Qtooltip)))
{
/* Do we have more than one visible frame on this X display? */
Lisp_Object tail, other_frame, fmt;
{
bool all_windows = windows_or_buffers_changed || update_mode_lines;
bool some_windows = REDISPLAY_SOME_P ();
- struct gcpro gcpro1, gcpro2;
Lisp_Object tooltip_frame;
#ifdef HAVE_WINDOW_SYSTEM
/* Clear flag first in case we get an error below. */
FRAME_WINDOW_SIZES_CHANGED (f) = false;
functions = Vwindow_size_change_functions;
- GCPRO2 (tail, functions);
while (CONSP (functions))
{
call1 (XCAR (functions), frame);
functions = XCDR (functions);
}
- UNGCPRO;
}
- GCPRO1 (tail);
menu_bar_hooks_run = update_menu_bar (f, false, menu_bar_hooks_run);
#ifdef HAVE_WINDOW_SYSTEM
update_tool_bar (f, false);
#endif
- UNGCPRO;
}
unbind_to (count, Qnil);
ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object frame, new_tool_bar;
int new_n_tool_bar;
- struct gcpro gcpro1;
/* Set current_buffer to the buffer of the selected
window of the frame, so that we get the right local
specbind (Qoverriding_local_map, Qnil);
}
- GCPRO1 (new_tool_bar);
-
/* We must temporarily set the selected frame to this frame
before calling tool_bar_items, because the calculation of
the tool-bar keymap uses the selected frame (see
unblock_input ();
}
- UNGCPRO;
-
unbind_to (count, Qnil);
set_buffer_internal_1 (prev);
}
build_desired_tool_bar_string (struct frame *f)
{
int i, size, size_needed;
- struct gcpro gcpro1, gcpro2;
Lisp_Object image, plist;
image = plist = Qnil;
- GCPRO2 (image, plist);
/* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
Otherwise, make a new string. */
else
{
AUTO_LIST4 (props, Qdisplay, Qnil, Qmenu_item, Qnil);
- struct gcpro gcpro1;
- GCPRO1 (props);
Fremove_text_properties (make_number (0), make_number (size),
props, f->desired_tool_bar_string);
- UNGCPRO;
}
/* Put a `display' property on the string for the images to display,
image = Fcons (Qimage, plist);
AUTO_LIST4 (props, Qdisplay, image, Qmenu_item,
make_number (i * TOOL_BAR_ITEM_NSLOTS));
- struct gcpro gcpro1;
- GCPRO1 (props);
/* Let the last image hide all remaining spaces in the tool bar
string. The string can be longer than needed when we reuse a
end = i + 1;
Fadd_text_properties (make_number (i), make_number (end),
props, f->desired_tool_bar_string);
- UNGCPRO;
#undef PROP
}
-
- UNGCPRO;
}
static bool
redisplay_tool_bar (struct frame *f)
{
+ f->tool_bar_redisplayed = true;
#if defined (USE_GTK) || defined (HAVE_NS)
if (FRAME_EXTERNAL_TOOL_BAR (f))
beginning of a paragraph, before the first strong directional
character, can change the base direction of the paragraph (unless
the buffer specifies a fixed paragraph direction), which will
- require to redisplay the whole paragraph. It might be worthwhile
+ require redisplaying the whole paragraph. It might be worthwhile
to find the paragraph limits and widen the range of redisplayed
lines to that, but for now just give up this optimization. */
if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
sw = w;
pending = false;
- last_escape_glyph_frame = NULL;
- last_escape_glyph_face_id = (1 << FACE_ID_BITS);
- last_glyphless_glyph_frame = NULL;
- last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
+ forget_escape_and_glyphless_faces ();
+
+ inhibit_free_realized_faces = false;
/* If face_change, init_iterator will free all realized faces, which
includes the faces referenced from current matrices. So, we
/* If cursor type has been changed on the frame
other than selected, consider all frames. */
if (f != sf && f->cursor_type_changed)
- update_mode_lines = 31;
+ fset_redisplay (f);
}
clear_desired_matrices (f);
}
echo-area doesn't show through. */
&& !MINI_WINDOW_P (XWINDOW (selected_window))))
{
- bool window_height_changed_p = echo_area_display (false);
+ echo_area_display (false);
+
+ /* If echo_area_display resizes the mini-window, the redisplay and
+ window_sizes_changed flags of the selected frame are set, but
+ it's too late for the hooks in window-size-change-functions,
+ which have been examined already in prepare_menu_bars. So in
+ that case we call the hooks here only for the selected frame. */
+ if (sf->redisplay && FRAME_WINDOW_SIZES_CHANGED (sf))
+ {
+ Lisp_Object functions;
+ ptrdiff_t count1 = SPECPDL_INDEX ();
+
+ record_unwind_save_match_data ();
+
+ /* Clear flag first in case we get an error below. */
+ FRAME_WINDOW_SIZES_CHANGED (sf) = false;
+ functions = Vwindow_size_change_functions;
+
+ while (CONSP (functions))
+ {
+ if (!EQ (XCAR (functions), Qt))
+ call1 (XCAR (functions), selected_frame);
+ functions = XCDR (functions);
+ }
+
+ unbind_to (count1, Qnil);
+ }
if (message_cleared_p)
update_miniwindow_p = true;
the echo area. */
if (!display_last_displayed_message_p)
message_cleared_p = false;
-
- if (window_height_changed_p)
- {
- windows_or_buffers_changed = 50;
-
- /* If window configuration was changed, frames may have been
- marked garbaged. Clear them or we will experience
- surprises wrt scrolling. */
- clear_garbaged_frames ();
- }
}
else if (EQ (selected_window, minibuf_window)
&& (current_buffer->clip_changed || window_outdated (w))
&& resize_mini_window (w, false))
{
+ if (sf->redisplay)
+ {
+ Lisp_Object functions;
+ ptrdiff_t count1 = SPECPDL_INDEX ();
+
+ record_unwind_save_match_data ();
+
+ /* Clear flag first in case we get an error below. */
+ FRAME_WINDOW_SIZES_CHANGED (sf) = false;
+ functions = Vwindow_size_change_functions;
+
+ while (CONSP (functions))
+ {
+ if (!EQ (XCAR (functions), Qt))
+ call1 (XCAR (functions), selected_frame);
+ functions = XCDR (functions);
+ }
+
+ unbind_to (count1, Qnil);
+ }
+
/* Resized active mini-window to fit the size of what it is
showing if its contents might have changed. */
must_finish = true;
consider_all_windows_p = (update_mode_lines
|| windows_or_buffers_changed);
-#define AINC(a,i) \
- if (VECTORP (a) && i >= 0 && i < ASIZE (a) && INTEGERP (AREF (a, i))) \
- ASET (a, i, make_number (1 + XINT (AREF (a, i))))
+#define AINC(a,i) \
+ { \
+ Lisp_Object entry = Fgethash (make_number (i), a, make_number (0)); \
+ if (INTEGERP (entry)) \
+ Fputhash (make_number (i), make_number (1 + XINT (entry)), a); \
+ }
AINC (Vredisplay__all_windows_cause, windows_or_buffers_changed);
AINC (Vredisplay__mode_lines_cause, update_mode_lines);
&& FRAME_VISIBLE_P (XFRAME (w->frame))
&& !FRAME_OBSCURED_P (XFRAME (w->frame))
&& !XFRAME (w->frame)->cursor_type_changed
+ && !XFRAME (w->frame)->face_change
/* Make sure recorded data applies to current buffer, etc. */
&& this_line_buffer == current_buffer
&& match_p
eassert (this_line_vpos == it.vpos);
eassert (this_line_y == it.current_y);
set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
+ if (cursor_row_fully_visible_p (w, false, true))
+ {
#ifdef GLYPH_DEBUG
- *w->desired_matrix->method = 0;
- debug_method_add (w, "optimization 3");
+ *w->desired_matrix->method = 0;
+ debug_method_add (w, "optimization 3");
#endif
- goto update;
+ goto update;
+ }
+ else
+ goto cancel;
}
else
goto cancel;
#endif
/* Build desired matrices, and update the display. If
- consider_all_windows_p, do it for all windows on all frames.
+ consider_all_windows_p, do it for all windows on all frames that
+ require redisplay, as specified by their 'redisplay' flag.
Otherwise do it for selected_window, only. */
if (consider_all_windows_p)
continue;
retry_frame:
-
-#if defined (HAVE_WINDOW_SYSTEM) && !defined (USE_GTK) && !defined (HAVE_NS)
- /* Redisplay internal tool bar if this is the first time so we
- can adjust the frame height right now, if necessary. */
- if (!f->tool_bar_redisplayed_once)
- {
- if (redisplay_tool_bar (f))
- adjust_frame_glyphs (f);
- f->tool_bar_redisplayed_once = true;
- }
-#endif
-
if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
{
bool gcscrollbars
/* Only GC scrollbars when we redisplay the whole frame. */
= f->redisplay || !REDISPLAY_SOME_P ();
+ bool f_redisplay_flag = f->redisplay;
/* Mark all the scroll bars to be removed; we'll redeem
the ones we want when we redisplay their windows. */
if (gcscrollbars && FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
goto retry_frame;
}
+ /* If the frame's redisplay flag was not set before
+ we went about redisplaying its windows, but it is
+ set now, that means we employed some redisplay
+ optimizations inside redisplay_windows, and
+ bypassed producing some screen lines. But if
+ f->redisplay is now set, it might mean the old
+ faces are no longer valid (e.g., if redisplaying
+ some window called some Lisp which defined a new
+ face or redefined an existing face), so trying to
+ use them in update_frame will segfault.
+ Therefore, we must redisplay this frame. */
+ if (!f_redisplay_flag && f->redisplay)
+ goto retry_frame;
+
/* Prevent various kinds of signals during display
update. stdio is not robust about handling
signals, which can cause an apparent I/O error. */
/* Compare desired and current matrices, perform output. */
update:
- /* If fonts changed, display again. */
- if (sf->fonts_changed)
- goto retry;
+ /* If fonts changed, display again. Likewise if redisplay_window_1
+ above caused some change (e.g., a change in faces) that requires
+ considering the entire frame again. */
+ if (sf->fonts_changed || sf->redisplay)
+ {
+ if (sf->redisplay)
+ {
+ /* Set this to force a more thorough redisplay.
+ Otherwise, we might immediately loop back to the
+ above "else-if" clause (since all the conditions that
+ led here might still be true), and we will then
+ infloop, because the selected-frame's redisplay flag
+ is not (and cannot be) reset. */
+ windows_or_buffers_changed = 50;
+ }
+ goto retry;
+ }
+
+ /* Prevent freeing of realized faces, since desired matrices are
+ pending that reference the faces we computed and cached. */
+ inhibit_free_realized_faces = true;
/* Prevent various kinds of signals during display update.
stdio is not robust about handling signals,
&& REDISPLAY_SOME_P ()
&& !w->redisplay
&& !w->update_mode_line
+ && !f->face_change
&& !f->redisplay
&& !buffer->text->redisplay
&& BUF_PT (buffer) == w->last_point)
if (w->cursor.vpos < 0)
{
/* If point does not appear, try to move point so it does
- appear. The desired matrix has been built above, so we
- can use it here. */
- new_vpos = window_box_height (w) / 2;
+ appear. The desired matrix has been built above, so we
+ can use it here. First see if point is in invisible
+ text, and if so, move it to the first visible buffer
+ position past that. */
+ struct glyph_row *r = NULL;
+ Lisp_Object invprop =
+ get_char_property_and_overlay (make_number (PT), Qinvisible,
+ Qnil, NULL);
+
+ if (TEXT_PROP_MEANS_INVISIBLE (invprop) != 0)
+ {
+ ptrdiff_t alt_pt;
+ Lisp_Object invprop_end =
+ Fnext_single_char_property_change (make_number (PT), Qinvisible,
+ Qnil, Qnil);
+
+ if (NATNUMP (invprop_end))
+ alt_pt = XFASTINT (invprop_end);
+ else
+ alt_pt = ZV;
+ r = row_containing_pos (w, alt_pt, w->desired_matrix->rows,
+ NULL, 0);
+ }
+ if (r)
+ new_vpos = MATRIX_ROW_BOTTOM_Y (r);
+ else /* Give up and just move to the middle of the window. */
+ new_vpos = window_box_height (w) / 2;
}
if (!cursor_row_fully_visible_p (w, false, false))
startp = run_window_scroll_functions (window, it.current.pos);
/* Redisplay the window. */
+ bool use_desired_matrix = false;
if (!current_matrix_up_to_date_p
|| windows_or_buffers_changed
|| f->cursor_type_changed
|| MINI_WINDOW_P (w)
|| !(used_current_matrix_p
= try_window_reusing_current_matrix (w)))
- try_window (window, startp, 0);
+ use_desired_matrix = (try_window (window, startp, 0) == 1);
/* If new fonts have been loaded (due to fontsets), give up. We
have to start a new redisplay since we need to re-adjust glyph
and similar ones. */
if (w->cursor.vpos < 0)
{
+ /* Prefer the desired matrix to the current matrix, if possible,
+ in the fallback calculations below. This is because using
+ the current matrix might completely goof, e.g. if its first
+ row is after point. */
+ struct glyph_matrix *matrix =
+ use_desired_matrix ? w->desired_matrix : w->current_matrix;
/* First, try locating the proper glyph row for PT. */
struct glyph_row *row =
- row_containing_pos (w, PT, w->current_matrix->rows, NULL, 0);
+ row_containing_pos (w, PT, matrix->rows, NULL, 0);
/* Sometimes point is at the beginning of invisible text that is
before the 1st character displayed in the row. In that case,
alt_pos = XFASTINT (invis_end);
else
alt_pos = ZV;
- row = row_containing_pos (w, alt_pos, w->current_matrix->rows,
- NULL, 0);
+ row = row_containing_pos (w, alt_pos, matrix->rows, NULL, 0);
}
}
/* Finally, fall back on the first row of the window after the
displaying the cursor at all. */
if (!row)
{
- row = w->current_matrix->rows;
+ row = matrix->rows;
if (row->mode_line_p)
++row;
}
- set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
+ set_cursor_from_row (w, row, matrix, 0, 0, 0, 0);
}
if (!cursor_row_fully_visible_p (w, false, false))
if (scroll_conservatively > SCROLL_LIMIT)
{
int window_total_lines
- = WINDOW_TOTAL_LINES (w) * FRAME_LINE_HEIGHT (f) * frame_line_height;
+ = WINDOW_TOTAL_LINES (w) * FRAME_LINE_HEIGHT (f) / frame_line_height;
int margin =
scroll_margin > 0
? min (scroll_margin, window_total_lines / 4)
finish_menu_bars:
- /* When we reach a frame's selected window, redo the frame's menu bar. */
+ /* When we reach a frame's selected window, redo the frame's menu
+ bar and the frame's title. */
if (update_mode_line
&& EQ (FRAME_SELECTED_WINDOW (f), window))
{
ignore_mouse_drag_p = true;
#endif
}
+ x_consider_frame_title (w->frame);
#endif
}
while (true)
{
/* Give up if we have gone too far. */
- if (end && row >= end)
+ if ((end && row >= end) || !row->enabled_p)
return NULL;
/* This formerly returned if they were equal.
I think that both quantities are of a "last plus one" type;
beginning of a paragraph, before the first strong directional
character, can change the base direction of the paragraph (unless
the buffer specifies a fixed paragraph direction), which will
- require to redisplay the whole paragraph. It might be worthwhile
+ require redisplaying the whole paragraph. It might be worthwhile
to find the paragraph limits and widen the range of redisplayed
lines to that, but for now just give up this optimization and
redisplay from scratch. */
glyph->left_box_line_p,
glyph->right_box_line_p);
}
+ else if (glyph->type == XWIDGET_GLYPH)
+ {
+#ifndef HAVE_XWIDGETS
+ eassume (false);
+#else
+ fprintf (stderr,
+ " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
+ glyph - row->glyphs[TEXT_AREA],
+ 'X',
+ glyph->charpos,
+ (BUFFERP (glyph->object)
+ ? 'B'
+ : (STRINGP (glyph->object)
+ ? 'S'
+ : '-')),
+ glyph->pixel_width,
+ glyph->u.xwidget,
+ '.',
+ glyph->face_id,
+ glyph->left_box_line_p,
+ glyph->right_box_line_p);
+#endif
+ }
}
eassert (it->method == GET_FROM_BUFFER
|| it->method == GET_FROM_DISPLAY_VECTOR
- || it->method == GET_FROM_STRING);
+ || it->method == GET_FROM_STRING
+ || it->method == GET_FROM_IMAGE);
/* We need to save the current buffer/string position, so it will be
restored by pop_it, because iterate_out_of_display_property
Strong directional characters `L', `R', and `AL' can have their
intrinsic directionality overridden by directional override
-control characters RLO \(u+202e) and LRO \(u+202d). See the
+control characters RLO (u+202e) and LRO (u+202d). See the
function `get-char-code-property' for a way to inquire about
the `bidi-class' property of a character. */)
(Lisp_Object from, Lisp_Object to, Lisp_Object object)
prop = Qnil;
}
- if (INTEGERP (prop) || FLOATP (prop))
+ if (NUMBERP (prop))
{
int base_unit = (width_p
? FRAME_COLUMN_WIDTH (it->f)
return OK_PIXELS (width_p ? img->width : img->height);
}
+ if (FRAME_WINDOW_P (it->f) && valid_xwidget_spec_p (prop))
+ {
+ // TODO: Don't return dummy size.
+ return OK_PIXELS (100);
+ }
#endif
if (EQ (car, Qplus) || EQ (car, Qminus))
{
car = Qnil;
}
- if (INTEGERP (car) || FLOATP (car))
+ if (NUMBERP (car))
{
double fact;
pixels = XFLOATINT (car);
}
+#ifdef HAVE_XWIDGETS
+static void
+fill_xwidget_glyph_string (struct glyph_string *s)
+{
+ eassert (s->first_glyph->type == XWIDGET_GLYPH);
+ s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
+ s->font = s->face->font;
+ s->width = s->first_glyph->pixel_width;
+ s->ybase += s->first_glyph->voffset;
+ s->xwidget = s->first_glyph->u.xwidget;
+}
+#endif
/* Fill glyph string S from a sequence of stretch glyphs.
START is the index of the first glyph to consider,
} \
while (false)
+#ifndef HAVE_XWIDGETS
+# define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
+ eassume (false)
+#else
+# define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
+ do \
+ { \
+ s = alloca (sizeof *s); \
+ INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
+ fill_xwidget_glyph_string (s); \
+ append_glyph_string (&(HEAD), &(TAIL), s); \
+ ++(START); \
+ s->x = (X); \
+ } \
+ while (false)
+#endif
/* Add a glyph string for a sequence of character glyphs to the list
of strings between HEAD and TAIL. START is the index of the first
to allocate glyph strings (because draw_glyphs can be called
asynchronously). */
-#define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
+#define BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X) \
do \
{ \
HEAD = TAIL = NULL; \
case IMAGE_GLYPH: \
BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
HL, X, LAST_X); \
- break; \
- \
+ break;
+
+#define BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X) \
+ case XWIDGET_GLYPH: \
+ BUILD_XWIDGET_GLYPH_STRING (START, END, HEAD, TAIL, \
+ HL, X, LAST_X); \
+ break;
+
+#define BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X) \
case GLYPHLESS_GLYPH: \
BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL, \
HL, X, LAST_X); \
break; \
\
default: \
- emacs_abort (); \
+ emacs_abort (); \
} \
\
if (s) \
} while (false)
+#define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
+ BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X) \
+ BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X) \
+ BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)
+
+
/* Draw glyphs between START and END in AREA of ROW on window W,
starting at x-position X. X is relative to AREA in W. HL is a
face-override with the following meaning:
}
}
+static void
+produce_xwidget_glyph (struct it *it)
+{
+#ifdef HAVE_XWIDGETS
+ struct xwidget *xw;
+ int glyph_ascent, crop;
+ eassert (it->what == IT_XWIDGET);
+
+ struct face *face = FACE_FROM_ID (it->f, it->face_id);
+ eassert (face);
+ /* Make sure X resources of the face is loaded. */
+ prepare_face_for_display (it->f, face);
+
+ xw = it->xwidget;
+ it->ascent = it->phys_ascent = glyph_ascent = xw->height/2;
+ it->descent = xw->height/2;
+ it->phys_descent = it->descent;
+ it->pixel_width = xw->width;
+ /* It's quite possible for images to have an ascent greater than
+ their height, so don't get confused in that case. */
+ if (it->descent < 0)
+ it->descent = 0;
+
+ it->nglyphs = 1;
+
+ if (face->box != FACE_NO_BOX)
+ {
+ if (face->box_line_width > 0)
+ {
+ it->ascent += face->box_line_width;
+ it->descent += face->box_line_width;
+ }
+
+ if (it->start_of_box_run_p)
+ it->pixel_width += eabs (face->box_line_width);
+ it->pixel_width += eabs (face->box_line_width);
+ }
+
+ take_vertical_position_into_account (it);
+
+ /* Automatically crop wide image glyphs at right edge so we can
+ draw the cursor on same display row. */
+ crop = it->pixel_width - (it->last_visible_x - it->current_x);
+ if (crop > 0 && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
+ it->pixel_width -= crop;
+
+ if (it->glyph_row)
+ {
+ enum glyph_row_area area = it->area;
+ struct glyph *glyph
+ = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
+
+ if (it->glyph_row->reversed_p)
+ {
+ struct glyph *g;
+
+ /* Make room for the new glyph. */
+ for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
+ g[1] = *g;
+ glyph = it->glyph_row->glyphs[it->area];
+ }
+ if (glyph < it->glyph_row->glyphs[area + 1])
+ {
+ glyph->charpos = CHARPOS (it->position);
+ glyph->object = it->object;
+ glyph->pixel_width = it->pixel_width;
+ glyph->ascent = glyph_ascent;
+ glyph->descent = it->descent;
+ glyph->voffset = it->voffset;
+ glyph->type = XWIDGET_GLYPH;
+ glyph->avoid_cursor_p = it->avoid_cursor_p;
+ glyph->multibyte_p = it->multibyte_p;
+ if (it->glyph_row->reversed_p && area == TEXT_AREA)
+ {
+ /* In R2L rows, the left and the right box edges need to be
+ drawn in reverse direction. */
+ glyph->right_box_line_p = it->start_of_box_run_p;
+ glyph->left_box_line_p = it->end_of_box_run_p;
+ }
+ else
+ {
+ glyph->left_box_line_p = it->start_of_box_run_p;
+ glyph->right_box_line_p = it->end_of_box_run_p;
+ }
+ glyph->overlaps_vertically_p = 0;
+ glyph->padding_p = 0;
+ glyph->glyph_not_available_p = 0;
+ glyph->face_id = it->face_id;
+ glyph->u.xwidget = it->xwidget;
+ glyph->font_type = FONT_TYPE_UNKNOWN;
+ if (it->bidi_p)
+ {
+ glyph->resolved_level = it->bidi_it.resolved_level;
+ eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
+ glyph->bidi_type = it->bidi_it.type;
+ }
+ ++it->glyph_row->used[area];
+ }
+ else
+ IT_EXPAND_MATRIX_WIDTH (it, area);
+ }
+#endif
+}
/* Append a stretch glyph to IT->glyph_row. OBJECT is the source
of the glyph, WIDTH and HEIGHT are the width and height of the
zero_width_ok_p = true;
width = (int)tem;
}
-#ifdef HAVE_WINDOW_SYSTEM
- else if (FRAME_WINDOW_P (it->f)
- && (prop = Fplist_get (plist, QCrelative_width), NUMVAL (prop) > 0))
+ else if (prop = Fplist_get (plist, QCrelative_width), NUMVAL (prop) > 0)
{
/* Relative width `:relative-width FACTOR' specified and valid.
Compute the width of the characters having the `glyph'
it2.glyph_row = NULL;
it2.what = IT_CHARACTER;
- x_produce_glyphs (&it2);
+ PRODUCE_GLYPHS (&it2);
width = NUMVAL (prop) * it2.pixel_width;
}
-#endif /* HAVE_WINDOW_SYSTEM */
else if ((prop = Fplist_get (plist, QCalign_to), !NILP (prop))
&& calc_pixel_width_or_height (&tem, it, prop, font, true,
&align_to))
produce_image_glyph (it);
else if (it->what == IT_STRETCH)
produce_stretch_glyph (it);
+ else if (it->what == IT_XWIDGET)
+ produce_xwidget_glyph (it);
done:
/* Accumulate dimensions. Note: can't assume that it->descent > 0
/* Use normal cursor if not blinked off. */
if (!w->cursor_off_p)
{
+ if (glyph != NULL && glyph->type == XWIDGET_GLYPH)
+ return NO_CURSOR;
if (glyph != NULL && glyph->type == IMAGE_GLYPH)
{
if (cursor_type == FILLED_BOX_CURSOR)
Lisp_Object lr, lx0, ly0;
if (CONSP (circ)
&& CONSP (XCAR (circ))
- && (lr = XCDR (circ), INTEGERP (lr) || FLOATP (lr))
+ && (lr = XCDR (circ), NUMBERP (lr))
&& (lx0 = XCAR (XCAR (circ)), INTEGERP (lx0))
&& (ly0 = XCDR (XCAR (circ)), INTEGERP (ly0)))
{
This variable has the same structure as `mode-line-format', except that
the %c and %l constructs are ignored. It is used only on frames for
-which no explicit name has been set \(see `modify-frame-parameters'). */);
+which no explicit name has been set (see `modify-frame-parameters'). */);
DEFVAR_LISP ("icon-title-format", Vicon_title_format,
doc: /* Template for displaying the title bar of an iconified frame.
Vmessage_log_max = make_number (1000);
DEFVAR_LISP ("window-size-change-functions", Vwindow_size_change_functions,
- doc: /* Functions called before redisplay, if window sizes have changed.
+ doc: /* Functions called during redisplay, if window sizes have changed.
The value should be a list of functions that take one argument.
-Just before redisplay, for each frame, if any of its windows have changed
-size since the last redisplay, or have been split or deleted,
-all the functions in the list are called, with the frame as argument. */);
+During the first part of redisplay, for each frame, if any of its windows
+have changed size since the last redisplay, or have been split or deleted,
+all the functions in the list are called, with the frame as argument.
+If redisplay decides to resize the minibuffer window, it calls these
+functions on behalf of that as well. */);
Vwindow_size_change_functions = Qnil;
DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions,
window is autoselected only after the mouse has remained in that
window for the duration of the delay.
A negative number has a similar effect, but causes windows to be
-autoselected only after the mouse has stopped moving. \(Because of
+autoselected only after the mouse has stopped moving. (Because of
the way Emacs compares mouse events, you will occasionally wait twice
-that time before the window gets selected.\)
+that time before the window gets selected.)
Any other value means to autoselect window instantaneously when the
mouse pointer enters it.
DEFVAR_LISP ("redisplay--all-windows-cause", Vredisplay__all_windows_cause,
doc: /* */);
- Vredisplay__all_windows_cause
- = Fmake_vector (make_number (100), make_number (0));
+ Vredisplay__all_windows_cause = Fmake_hash_table (0, NULL);
DEFVAR_LISP ("redisplay--mode-lines-cause", Vredisplay__mode_lines_cause,
doc: /* */);
- Vredisplay__mode_lines_cause
- = Fmake_vector (make_number (100), make_number (0));
+ Vredisplay__mode_lines_cause = Fmake_hash_table (0, NULL);
+
+ DEFVAR_LISP ("redisplay--variables", Vredisplay__variables,
+ doc: /* A hash-table of variables changing which triggers a thorough redisplay. */);
+ Vredisplay__variables = Qnil;
}