/* #### probably temporary */
-int cache_adjustment;
+Fixnum cache_adjustment;
/* This holds a string representing the text corresponding to a single
modeline % spec. */
static int preemption_count;
/* Minimum pixel height of clipped bottom display line. */
-int vertical_clip;
+Fixnum vertical_clip;
/* Minimum visible pixel width of clipped glyphs at right margin. */
-int horizontal_clip;
+Fixnum horizontal_clip;
/* Nonzero means reading single-character input with prompt
so put cursor on minibuffer after the prompt. */
/* The number of lines scroll a window by when point leaves the window; if
it is <=0 then point is centered in the window */
-int scroll_step;
+Fixnum scroll_step;
/* Scroll up to this many lines, to bring point back on screen. */
-int scroll_conservatively;
+Fixnum scroll_conservatively;
/* Marker for where to display an arrow on top of the buffer text. */
Lisp_Object Voverlay_arrow_position;
Lisp_Object Qpre_redisplay_hook, Qpost_redisplay_hook;
#endif /* INHIBIT_REDISPLAY_HOOKS */
-static int last_display_warning_tick, display_warning_tick;
+static Fixnum last_display_warning_tick;
+static Fixnum display_warning_tick;
Lisp_Object Qdisplay_warning_buffer;
int inhibit_warning_display;
Lisp_Object Qtop_bottom;
-#define WINDOW_SCROLLED(w) \
-(w->hscroll > 0 || w->left_xoffset)
+#define WINDOW_SCROLLED(w) ((w)->hscroll > 0 || (w)->left_xoffset)
\f
/***************************************************************************/
for (pos = c_string; pos < end;)
{
+ Bufbyte *old_pos = pos;
+
data->ch = charptr_emchar (pos);
prop = add_emchar_rune (data);
}
INC_CHARPTR (pos);
assert (pos <= end);
+ /* #### Duplicate code from add_string_to_fstring_db_runes
+ should we do more?*/
+ data->bytepos += pos - old_pos;
}
return NULL;
else
findex = get_builtin_face_cache_index (w, face);
- instance = glyph_image_instance (gb->glyph, data->window,
+ instance = glyph_image_instance (gb->glyph, data->window,
ERROR_ME_NOT, 1);
if (TEXT_IMAGE_INSTANCEP (instance))
{
/* result_str is nil when we're building a frame or icon title. Otherwise,
we're building a modeline, so the offset starts at the modeline
- horizontal scrolling ammount */
+ horizontal scrolling amount */
if (! NILP (result_str))
offset = w->modeline_hscroll;
generate_fstring_runes (w, &data, 0, 0, -1, format_str, 0,
int truncate_win = b ? window_truncation_on (w) : 0;
int end_glyph_width = 0;
- /* we're going to ditch selective display for static text, its an
- FSF thing and invisble extents are the way to go
- here. Implementing it also relies on a number of buffer-specific
+ /* We're going to ditch selective display for static text, it's an
+ FSF thing and invisible extents are the way to go here.
+ Implementing it also relies on a number of buffer-specific
functions that we don't have the luxury of being able to use
here. */
goto done;
}
- /* #### What if we we're dealing with a display table? */
+ /* #### What if we're dealing with a display table? */
if (data.start_col)
data.start_col--;
&& !(MINI_WINDOW_P (w) && f->buffers_changed)
&& !f->frame_changed
&& !truncation_changed
- /* check whether start is really at the begining of a line GE */
+ /* check whether start is really at the beginning of a line GE */
&& (!w->start_at_line_beg || beginning_of_line_p (b, startp))
)
{
{
struct device *d = XDEVICE (f->device);
- if (preemption_check)
+ if (preemption_check
+ && !DEVICE_IMPL_FLAG (d, XDEVIMPF_DONT_PREEMPT_REDISPLAY))
{
/* The preemption check itself takes a lot of time,
so normally don't do it here. We do it if called
if (f->clear)
f->frame_changed = 1;
- /* Invalidate the subwindow cache. We use subwindows_changed here to
- cause subwindows to get instantiated. This is because
+ /* Invalidate the subwindow caches. We use subwindows_changed here
+ to cause subwindows to get instantiated. This is because
subwindows_state_changed is less strict - dealing with things
like the clicked state of button. We have to do this before
redisplaying the gutters as subwindows get unmapped in the
process.*/
+ if (f->frame_changed)
+ reset_frame_subwindow_instance_cache (f);
+
if (f->frame_changed || f->subwindows_changed)
{
/* we have to do this so the gutter gets regenerated. */
redisplay_device (struct device *d, int automatic)
{
Lisp_Object frame, frmcons;
- int preempted = 0;
int size_change_failed = 0;
struct frame *f;
- if (automatic
- && (MAYBE_INT_DEVMETH (d, device_implementation_flags, ())
- & XDEVIMPF_NO_AUTO_REDISPLAY))
+ if (automatic && DEVICE_IMPL_FLAG (d, XDEVIMPF_NO_AUTO_REDISPLAY))
return 0;
if (DEVICE_STREAM_P (d)) /* nothing to do */
return 0;
/* It is possible that redisplay has been called before the
- device is fully initialized. If so then continue with the
- next device. */
+ device is fully initialized, or that the console implementation
+ allows frameless devices. If so then continue with the next
+ device. */
if (NILP (DEVICE_SELECTED_FRAME (d)))
return 0;
- REDISPLAY_PREEMPTION_CHECK;
- if (preempted)
- return 1;
+ if (!DEVICE_IMPL_FLAG (d, XDEVIMPF_DONT_PREEMPT_REDISPLAY))
+ {
+ int preempted;
+ REDISPLAY_PREEMPTION_CHECK;
+ if (preempted)
+ return 1;
+ }
/* Always do the selected frame first. */
frame = DEVICE_SELECTED_FRAME (d);
{
if (CLASS_REDISPLAY_FLAGS_CHANGEDP(f))
{
- preempted = redisplay_frame (f, 0);
+ int preempted = redisplay_frame (f, 0);
+ if (preempted)
+ return 1;
}
- if (preempted)
- return 1;
-
/* If the frame redisplay did not get preempted, then this flag
should have gotten set to 0. It might be possible for that
not to happen if a size change event were to occur at an odd
{
if (CLASS_REDISPLAY_FLAGS_CHANGEDP (f))
{
- preempted = redisplay_frame (f, 0);
+ int preempted = redisplay_frame (f, 0);
+ if (preempted)
+ return 1;
}
- if (preempted)
- return 1;
-
if (f->size_change_pending)
size_change_failed = 1;
}
FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
{
struct frame *f = XFRAME (XCAR (frmcons));
+ /* #### urk! this does tons o' crap, such as creating lots of
+ structs, doing window system actions, etc. we DO NOT want to
+ be doing this -- marking should never change any state.
+ i think we can just delete this. --ben */
update_frame_window_mirror (f);
mark_window_mirror (f->root_mirror);
mark_gutters (f);
displayed. The end of the last line is also know as the window end
position.
- WARNING: It is possible that rediplay failed to layout any lines for the
+ WARNING: It is possible that redisplay failed to layout any lines for the
windows. Under normal circumstances this is rare. However it seems that it
does occur in the following situation: A mouse event has come in and we
need to compute its location in a window. That code (in
redisplay_frame (f, 1);
- /* If we don't reset the global redisplay flafs here, subsequent
+ /* If we don't reset the global redisplay flags here, subsequent
changes to the display will not get registered by redisplay
because it thinks it already has registered changes. If you
really knew what you were doing you could confuse redisplay by
}
#endif /* HAVE_X_WINDOWS */
+#ifdef HAVE_GTK
+ if (!strcmp (display_use, "gtk"))
+ {
+ Vwindow_system = Qgtk;
+ Vinitial_window_system = Qgtk;
+ return;
+ }
+#endif
+
#ifdef HAVE_MS_WINDOWS
if (!strcmp (display_use, "mswindows"))
{
DEFVAR_LISP_MAGIC ("overlay-arrow-string", &Voverlay_arrow_string /*
String or glyph to display as an arrow. See also `overlay-arrow-position'.
-(Note that despite the name of this variable, it can be set to a glyph as
+\(Note that despite the name of this variable, it can be set to a glyph as
well as a string.)
*/ ,
redisplay_variable_changed);
maybe a caret cursor, etc. */
DEFVAR_LISP ("bar-cursor", &Vbar_cursor /*
-Use vertical bar cursor if non-nil. If t width is 1 pixel, otherwise 2.
+*Use vertical bar cursor if non-nil. If t width is 1 pixel, otherwise 2.
*/ );
Vbar_cursor = Qnil;
offsetof (struct window, left_margin_width),
some_window_value_changed,
offsetof (struct frame, left_margin_width),
- margin_width_changed_in_frame);
+ margin_width_changed_in_frame, 0);
DEFVAR_SPECIFIER ("right-margin-width", &Vright_margin_width /*
*Width of right margin.
offsetof (struct window, right_margin_width),
some_window_value_changed,
offsetof (struct frame, right_margin_width),
- margin_width_changed_in_frame);
+ margin_width_changed_in_frame, 0);
DEFVAR_SPECIFIER ("minimum-line-ascent", &Vminimum_line_ascent /*
*Minimum ascent height of lines.
set_specifier_caching (Vminimum_line_ascent,
offsetof (struct window, minimum_line_ascent),
some_window_value_changed,
- 0, 0);
+ 0, 0, 0);
DEFVAR_SPECIFIER ("minimum-line-descent", &Vminimum_line_descent /*
*Minimum descent height of lines.
set_specifier_caching (Vminimum_line_descent,
offsetof (struct window, minimum_line_descent),
some_window_value_changed,
- 0, 0);
+ 0, 0, 0);
DEFVAR_SPECIFIER ("use-left-overflow", &Vuse_left_overflow /*
*Non-nil means use the left outside margin as extra whitespace when
set_specifier_caching (Vuse_left_overflow,
offsetof (struct window, use_left_overflow),
some_window_value_changed,
- 0, 0);
+ 0, 0, 0);
DEFVAR_SPECIFIER ("use-right-overflow", &Vuse_right_overflow /*
*Non-nil means use the right outside margin as extra whitespace when
set_specifier_caching (Vuse_right_overflow,
offsetof (struct window, use_right_overflow),
some_window_value_changed,
- 0, 0);
+ 0, 0, 0);
DEFVAR_SPECIFIER ("text-cursor-visible-p", &Vtext_cursor_visible_p /*
*Non-nil means the text cursor is visible (this is usually the case).
set_specifier_caching (Vtext_cursor_visible_p,
offsetof (struct window, text_cursor_visible_p),
text_cursor_visible_p_changed,
- 0, 0);
+ 0, 0, 0);
}
projects / chise / xemacs-chise.git.1 / blobdiff