Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
Lisp_Object Qredisplay_end_trigger_functions;
Lisp_Object Qinhibit_point_motion_hooks;
-Lisp_Object QCeval, Qwhen;
+Lisp_Object QCeval, Qwhen, QCfile;
Lisp_Object Qfontified;
/* Functions called to fontify regions of text. */
Lisp_Object Qspace, QCalign_to, QCrelative_width, QCrelative_height;
Lisp_Object Qleft_margin, Qright_margin, Qspace_width, Qheight, Qraise;
+Lisp_Object Qmargin;
/* Non-nil means highlight trailing whitespace. */
return HANDLED_NORMALLY;
space_or_image_found_p = 0;
- if (CONSP (prop) && CONSP (XCAR (prop)))
+ if (CONSP (prop)
+ && CONSP (XCAR (prop))
+ && !EQ (Qmargin, XCAR (XCAR (prop))))
{
+ /* A list of sub-properties. */
while (CONSP (prop))
{
if (handle_single_display_prop (it, XCAR (prop), object, position))
}
-/* Value is the position of the end of the `display' property stating
+/* Value is the position of the end of the `display' property starting
at START_POS in OBJECT. */
static struct text_pos
{
Lisp_Object end;
struct text_pos end_pos;
-
- /* Characters having this form of property are not displayed, so
- we have to find the end of the property. */
- end = Fnext_single_property_change (make_number (start_pos.charpos),
- Qdisplay, object, Qnil);
- if (NILP (end))
- {
- /* A nil value of `end' means there are no changes of the
- property to the end of the buffer or string. */
- if (it->current.overlay_string_index >= 0)
- end_pos.charpos = XSTRING (it->string)->size;
- else
- end_pos.charpos = it->end_charpos;
- }
- else
- end_pos.charpos = XFASTINT (end);
- if (STRINGP (it->string))
+ end = next_single_char_property_change (make_number (CHARPOS (start_pos)),
+ Qdisplay, object, Qnil);
+ CHARPOS (end_pos) = XFASTINT (end);
+ if (STRINGP (object))
compute_string_pos (&end_pos, start_pos, it->string);
else
- end_pos.bytepos = CHAR_TO_BYTE (end_pos.charpos);
+ BYTEPOS (end_pos) = CHAR_TO_BYTE (XFASTINT (end));
return end_pos;
}
}
else if (!it->string_from_display_prop_p)
{
- /* `(left-margin VALUE)' or `(right-margin VALUE)
- or `(nil VALUE)' or VALUE. */
+ /* `((margin left-margin) VALUE)' or `((margin right-margin)
+ VALUE) or `((margin nil) VALUE)' or VALUE. */
Lisp_Object location, value;
struct text_pos start_pos;
int valid_p;
text properties change there. */
it->stop_charpos = position->charpos;
- if (CONSP (prop)
- && !EQ (XCAR (prop), Qspace)
- && !EQ (XCAR (prop), Qimage))
+ location = Qunbound;
+ if (CONSP (prop) && CONSP (XCAR (prop)))
{
- location = XCAR (prop);
+ Lisp_Object tem;
+
value = XCDR (prop);
+ if (CONSP (value))
+ value = XCAR (value);
+
+ tem = XCAR (prop);
+ if (EQ (XCAR (tem), Qmargin)
+ && (tem = XCDR (tem),
+ tem = CONSP (tem) ? XCAR (tem) : Qnil,
+ (NILP (tem)
+ || EQ (tem, Qleft_margin)
+ || EQ (tem, Qright_margin))))
+ location = tem;
}
- else
+
+ if (EQ (location, Qunbound))
{
location = Qnil;
value = prop;
- when we stopped at a line end, i.e. a newline or a CR and selective
display is on. */
-enum move_it_result
+static enum move_it_result
move_it_in_display_line_to (it, to_charpos, to_x, op)
struct it *it;
int to_charpos, to_x, op;
invisible_found_p = 1;
else
{
- limit = Fnext_single_property_change (make_number (start_charpos),
- Qinvisible,
- Fcurrent_buffer (),
- make_number (end_charpos));
+ limit = next_single_char_property_change (make_number (start_charpos),
+ Qinvisible, Qnil,
+ make_number (end_charpos));
invisible_found_p = XFASTINT (limit) < end_charpos;
}
***********************************************************************/
+/* Add a message with format string FORMAT and arguments ARG1 and ARG2
+ to *Messages*. */
+
+void
+add_to_log (format, arg1, arg2)
+ char *format;
+ Lisp_Object arg1, arg2;
+{
+ Lisp_Object args[3];
+ Lisp_Object msg, fmt;
+ char *buffer;
+ int len;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+
+ fmt = msg = Qnil;
+ GCPRO4 (fmt, msg, arg1, arg2);
+
+ args[0] = fmt = build_string (format);
+ args[1] = arg1;
+ args[2] = arg2;
+ msg = Fformat (make_number (3), args);
+
+ len = STRING_BYTES (XSTRING (msg)) + 1;
+ buffer = (char *) alloca (len);
+ strcpy (buffer, XSTRING (msg)->data);
+
+ message_dolog (buffer, len, 1, 0);
+ UNGCPRO;
+}
+
+
/* Output a newline in the *Messages* buffer if "needs" one. */
void
char *m;
int len;
{
+ struct frame *sf = SELECTED_FRAME ();
message_enable_multibyte = multibyte;
if (noninteractive)
initialized yet. Error messages get reported properly by
cmd_error, so this must be just an informative message; toss it. */
else if (INTERACTIVE
- && selected_frame->glyphs_initialized_p
- && FRAME_MESSAGE_BUF (selected_frame))
+ && sf->glyphs_initialized_p
+ && FRAME_MESSAGE_BUF (sf))
{
Lisp_Object mini_window;
struct frame *f;
/* Get the frame containing the mini-buffer
that the selected frame is using. */
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
+ mini_window = FRAME_MINIBUF_WINDOW (sf);
f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
FRAME_SAMPLE_VISIBILITY (f);
- if (FRAME_VISIBLE_P (selected_frame)
+ if (FRAME_VISIBLE_P (sf)
&& ! FRAME_VISIBLE_P (f))
Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window)));
Lisp_Object m;
int nbytes, multibyte;
{
+ struct frame *sf = SELECTED_FRAME ();
message_enable_multibyte = multibyte;
if (noninteractive)
initialized yet. Error messages get reported properly by
cmd_error, so this must be just an informative message; toss it. */
else if (INTERACTIVE
- && selected_frame->glyphs_initialized_p
- && FRAME_MESSAGE_BUF (selected_frame))
+ && sf->glyphs_initialized_p
+ && FRAME_MESSAGE_BUF (sf))
{
Lisp_Object mini_window;
Lisp_Object frame;
/* Get the frame containing the mini-buffer
that the selected frame is using. */
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
+ mini_window = FRAME_MINIBUF_WINDOW (sf);
frame = XWINDOW (mini_window)->frame;
f = XFRAME (frame);
FRAME_SAMPLE_VISIBILITY (f);
- if (FRAME_VISIBLE_P (selected_frame)
+ if (FRAME_VISIBLE_P (sf)
&& !FRAME_VISIBLE_P (f))
Fmake_frame_visible (frame);
It may be larger than the selected frame, so we need
to use its buffer, not the selected frame's buffer. */
Lisp_Object mini_window;
- FRAME_PTR f;
+ struct frame *f, *sf = SELECTED_FRAME ();
/* Get the frame containing the minibuffer
that the selected frame is using. */
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
+ mini_window = FRAME_MINIBUF_WINDOW (sf);
f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
/* A null message buffer means that the frame hasn't really been
on. It may be larger than the selected frame, so we need to
use its buffer, not the selected frame's buffer. */
Lisp_Object mini_window;
- struct frame *f;
+ struct frame *f, *sf = SELECTED_FRAME ();
/* Get the frame containing the mini-buffer
that the selected frame is using. */
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
+ mini_window = FRAME_MINIBUF_WINDOW (sf);
f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
/* A null message buffer means that the frame hasn't really been
/* Raise the frame containing the echo area. */
if (minibuffer_auto_raise)
{
+ struct frame *sf = SELECTED_FRAME ();
Lisp_Object mini_window;
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
+ mini_window = FRAME_MINIBUF_WINDOW (sf);
Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
}
struct window *w;
{
Lisp_Object window;
- struct frame *f = XFRAME (w->frame);
struct text_pos start;
int window_height_changed_p = 0;
/* Let it grow only, until we display an empty message, in which
case the window shrinks again. */
- if (height > XFASTINT (w->height)
- || exact_p
- || BEGV == ZV)
+ if (height > XFASTINT (w->height))
{
- Lisp_Object old_selected_window;
-
- freeze_window_starts (f, height > XFASTINT (w->height));
- old_selected_window = selected_window;
- XSETWINDOW (selected_window, w);
- change_window_height (height - XFASTINT (w->height), 0);
- selected_window = old_selected_window;
- window_height_changed_p = 1;
+ int old_height = XFASTINT (w->height);
+ freeze_window_starts (f, 1);
+ grow_mini_window (w, height - XFASTINT (w->height));
+ window_height_changed_p = XFASTINT (w->height) != old_height;
+ }
+ else if (height < XFASTINT (w->height)
+ && (exact_p || BEGV == ZV))
+ {
+ int old_height = XFASTINT (w->height);
+ freeze_window_starts (f, 0);
+ shrink_mini_window (w);
+ window_height_changed_p = XFASTINT (w->height) != old_height;
}
}
cmd_error, so this must be just an informative message; toss it. */
else if (!noninteractive
&& INTERACTIVE
- && FRAME_MESSAGE_BUF (selected_frame)
&& !NILP (echo_area_buffer[0]))
- with_echo_area_buffer (0, 0, (int (*) ()) truncate_message_1, nchars);
+ {
+ struct frame *sf = SELECTED_FRAME ();
+ if (FRAME_MESSAGE_BUF (sf))
+ with_echo_area_buffer (0, 0, (int (*) ()) truncate_message_1, nchars);
+ }
}
}
-/* Redisplay the echo area of selected_frame. If UPDATE_FRAME_P is
- non-zero update selected_frame. Value is non-zero if the
+/* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
+ is non-zero update selected_frame. Value is non-zero if the
mini-windows height has been changed. */
static int
struct window *w;
struct frame *f;
int window_height_changed_p = 0;
+ struct frame *sf = SELECTED_FRAME ();
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
+ mini_window = FRAME_MINIBUF_WINDOW (sf);
w = XWINDOW (mini_window);
f = XFRAME (WINDOW_FRAME (w));
if (!FRAME_VISIBLE_P (f) || !f->glyphs_initialized_p)
return 0;
+#if 0 /* inhibit_window_system is not a valid way of testing
+ whether a window system is in use.
+ This code prevents all echo area display
+ when you run plain `emacs' on a tty. */
/* When Emacs starts, selected_frame may be a visible terminal
frame, even if we run under a window system. If we let this
through, a message would be displayed on the terminal. */
#ifdef HAVE_WINDOW_SYSTEM
- if (!inhibit_window_system && !FRAME_WINDOW_P (selected_frame))
+ if (!inhibit_window_system && !FRAME_WINDOW_P (sf))
return 0;
#endif /* HAVE_WINDOW_SYSTEM */
+#endif
/* Redraw garbaged frames. */
if (frame_garbaged)
}
else
{
- update_menu_bar (selected_frame, 1);
+ struct frame *sf = SELECTED_FRAME ();
+ update_menu_bar (sf, 1);
#ifdef HAVE_WINDOW_SYSTEM
- update_tool_bar (selected_frame, 1);
+ update_tool_bar (sf, 1);
#endif
}
struct text_pos tlbufpos, tlendpos;
int number_of_visible_frames;
int count;
+ struct frame *sf = SELECTED_FRAME ();
/* Non-zero means redisplay has to consider all windows on all
frames. Zero means, only selected_window is considered. */
fonts_changed_p = 0;
}
- if (! FRAME_WINDOW_P (selected_frame)
- && previous_terminal_frame != selected_frame)
+ if (! FRAME_WINDOW_P (sf)
+ && previous_terminal_frame != sf)
{
/* Since frames on an ASCII terminal share the same display
area, displaying a different frame means redisplay the whole
thing. */
windows_or_buffers_changed++;
- SET_FRAME_GARBAGED (selected_frame);
- XSETFRAME (Vterminal_frame, selected_frame);
+ SET_FRAME_GARBAGED (sf);
+ XSETFRAME (Vterminal_frame, sf);
}
- previous_terminal_frame = selected_frame;
+ previous_terminal_frame = sf;
/* Set the visible flags for all frames. Do this before checking
for resized or garbaged frames; they want to know if their frames
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
- if (FRAME_WINDOW_P (f) || f == selected_frame)
+ if (FRAME_WINDOW_P (f) || f == sf)
{
/* Mark all the scroll bars to be removed; we'll redeem
the ones we want when we redisplay their windows. */
}
}
}
- else if (FRAME_VISIBLE_P (selected_frame)
- && !FRAME_OBSCURED_P (selected_frame))
+ else if (FRAME_VISIBLE_P (sf)
+ && !FRAME_OBSCURED_P (sf))
redisplay_window (selected_window, 1);
f = XFRAME (XCAR (tail));
if ((FRAME_WINDOW_P (f)
- || f == selected_frame)
+ || f == sf)
&& FRAME_VISIBLE_P (f)
&& !FRAME_OBSCURED_P (f)
&& hscroll_windows (f->root_window))
f = XFRAME (XCAR (tail));
- if ((FRAME_WINDOW_P (f) || f == selected_frame)
+ if ((FRAME_WINDOW_P (f) || f == sf)
&& FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
{
/* Mark all windows as to be updated. */
}
else
{
- if (FRAME_VISIBLE_P (selected_frame)
- && !FRAME_OBSCURED_P (selected_frame))
+ if (FRAME_VISIBLE_P (sf)
+ && !FRAME_OBSCURED_P (sf))
{
if (hscroll_windows (selected_window))
goto retry;
XWINDOW (selected_window)->must_be_updated_p = 1;
- pause = update_frame (selected_frame, 0, 0);
+ pause = update_frame (sf, 0, 0);
}
else
pause = 0;
Lisp_Object mini_window;
struct frame *mini_frame;
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
+ mini_window = FRAME_MINIBUF_WINDOW (sf);
mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
- if (mini_frame != selected_frame && FRAME_WINDOW_P (mini_frame))
+ if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
{
XWINDOW (mini_window)->must_be_updated_p = 1;
pause |= update_frame (mini_frame, 0, 0);
BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
if (consider_all_windows_p)
- mark_window_display_accurate (FRAME_ROOT_WINDOW (selected_frame), 1);
+ mark_window_display_accurate (FRAME_ROOT_WINDOW (sf), 1);
else
{
XSETFASTINT (w->last_point, BUF_PT (b));
last_arrow_position = COERCE_MARKER (Voverlay_arrow_position);
last_arrow_string = Voverlay_arrow_string;
if (frame_up_to_date_hook != 0)
- (*frame_up_to_date_hook) (selected_frame);
+ (*frame_up_to_date_hook) (sf);
w->current_matrix->buffer = b;
w->current_matrix->begv = BUF_BEGV (b);
{
struct it it;
struct glyph_row *row;
+
+ /* Handle the case that the window start is out of range. */
+ if (CHARPOS (start_pos) < BEGV)
+ SET_TEXT_POS (start_pos, BEGV, BEGV_BYTE);
+ else if (CHARPOS (start_pos) > ZV)
+ SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
/* Find the start of the continued line. This should be fast
because scan_buffer is fast (newline cache). */
make_cursor_line_fully_visible (w);
+ done:
+
SET_TEXT_POS_FROM_MARKER (startp, w->start);
w->start_at_line_beg = ((CHARPOS (startp) == BEGV
|| FETCH_BYTE (BYTEPOS (startp) - 1) == '\n')
? Qt : Qnil);
- done:
-
/* Display the mode line, if we must. */
if ((update_mode_line
/* If window not full width, must redo its mode line
while (window_row < window_row_end)
{
int area;
+
for (area = LEFT_MARGIN_AREA; area <= LAST_AREA; ++area)
frame_row->glyphs[area] = window_row->glyphs[area];
+
+ /* Disable frame rows whose corresponding window rows have
+ been disabled in try_window_id. */
+ if (!window_row->enabled_p)
+ frame_row->enabled_p = 0;
+
++window_row, ++frame_row;
}
}
mentioned, this is not a frequent case. */
if (w->cursor.vpos < 0)
{
- int last_y = min (it.last_visible_y, it.last_visible_y + dy);
-
/* Cursor in unchanged rows at the top? */
if (PT < CHARPOS (start_pos)
&& last_unchanged_at_beg_row)
0, 0, "", "")
()
{
- struct glyph_matrix *m = (XWINDOW (selected_frame->tool_bar_window)
+ struct frame *sf = SELECTED_FRAME ();
+ struct glyph_matrix *m = (XWINDOW (sf->tool_bar_window)
->current_matrix);
dump_glyph_row (m, 0, 1);
return Qnil;
staticpro (&Qinhibit_point_motion_hooks);
Qinhibit_point_motion_hooks = intern ("inhibit-point-motion-hooks");
- staticpro (&Qdisplay);
Qdisplay = intern ("display");
- staticpro (&Qleft_margin);
+ staticpro (&Qdisplay);
Qspace_width = intern ("space-width");
staticpro (&Qspace_width);
Qheight = intern ("height");
staticpro (&Qraise);
Qspace = intern ("space");
staticpro (&Qspace);
+ Qmargin = intern ("margin");
+ staticpro (&Qmargin);
Qleft_margin = intern ("left-margin");
- staticpro (&Qright_margin);
+ staticpro (&Qleft_margin);
Qright_margin = intern ("right-margin");
+ staticpro (&Qright_margin);
Qalign_to = intern ("align-to");
staticpro (&Qalign_to);
QCalign_to = intern (":align-to");
staticpro (&QCeval);
Qwhen = intern ("when");
staticpro (&Qwhen);
+ QCfile = intern (":file");
+ staticpro (&QCfile);
Qfontified = intern ("fontified");
staticpro (&Qfontified);
Qfontification_functions = intern ("fontification-functions");
Qimage = intern ("image");
staticpro (&Qimage);
- staticpro (&last_arrow_position);
- staticpro (&last_arrow_string);
last_arrow_position = Qnil;
last_arrow_string = Qnil;
+ staticpro (&last_arrow_position);
+ staticpro (&last_arrow_string);
echo_buffer[0] = echo_buffer[1] = Qnil;
staticpro (&echo_buffer[0]);
HCoop / bpt / emacs.git / blobdiff