#endif
#ifdef MAC_OS
#include "macterm.h"
-
-Cursor No_Cursor;
#endif
#ifndef FRAME_X_OUTPUT
extern Lisp_Object Qheight;
extern Lisp_Object QCwidth, QCheight, QCascent;
extern Lisp_Object Qscroll_bar;
+extern Lisp_Object Qcursor;
/* Non-nil means highlight trailing whitespace. */
/* How much to scroll horizontally when point is inside the above margin. */
Lisp_Object Vhscroll_step;
-/* A list of symbols, one for each supported image type. */
-
-Lisp_Object Vimage_types;
-
/* The variable `resize-mini-windows'. If nil, don't resize
mini-windows. If t, always resize them to fit the text they
display. If `grow-only', let mini-windows grow only until they
visible_p = 0;
}
+ if (visible_p)
+ {
+ struct it it2 = *it;
+
+ if (handle_display_prop (&it2) == HANDLED_RETURN)
+ visible_p = 0;
+ }
+
/* Back one more newline if the current one is invisible. */
if (!visible_p)
back_to_previous_line_start (it);
{
int x, i, ascent = 0, descent = 0;
- /* Stop when ZV or TO_CHARPOS reached. */
+ /* Stop when ZV reached.
+ We used to stop here when TO_CHARPOS reached as well, but that is
+ too soon if this glyph does not fit on this line. So we handle it
+ explicitly below. */
if (!get_next_display_element (it)
- || BUFFER_POS_REACHED_P ())
+ || (it->truncate_lines_p
+ && BUFFER_POS_REACHED_P ()))
{
result = MOVE_POS_MATCH_OR_ZV;
break;
/* We want to leave anything reaching TO_X to the caller. */
if ((op & MOVE_TO_X) && new_x > to_x)
{
+ if (BUFFER_POS_REACHED_P ())
+ goto buffer_pos_reached;
it->current_x = x;
result = MOVE_X_REACHED;
break;
#ifdef HAVE_WINDOW_SYSTEM
if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
{
- if (!get_next_display_element (it)
- || BUFFER_POS_REACHED_P ())
+ if (!get_next_display_element (it))
{
result = MOVE_POS_MATCH_OR_ZV;
break;
}
+ if (BUFFER_POS_REACHED_P ())
+ {
+ if (ITERATOR_AT_END_OF_LINE_P (it))
+ result = MOVE_POS_MATCH_OR_ZV;
+ else
+ result = MOVE_LINE_CONTINUED;
+ break;
+ }
if (ITERATOR_AT_END_OF_LINE_P (it))
{
result = MOVE_NEWLINE_OR_CR;
result = MOVE_LINE_CONTINUED;
break;
}
+ else if (BUFFER_POS_REACHED_P ())
+ goto buffer_pos_reached;
else if (new_x > it->first_visible_x)
{
/* Glyph is visible. Increment number of glyphs that
if (result != MOVE_UNDEFINED)
break;
}
+ else if (BUFFER_POS_REACHED_P ())
+ {
+ buffer_pos_reached:
+ it->current_x = x;
+ it->max_ascent = ascent;
+ it->max_descent = descent;
+ result = MOVE_POS_MATCH_OR_ZV;
+ break;
+ }
else if ((op & MOVE_TO_X) && it->current_x >= to_x)
{
/* Stop when TO_X specified and reached. This check is
char *buffer;
int len;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+ USE_SAFE_ALLOCA;
/* Do nothing if called asynchronously. Inserting text into
a buffer may call after-change-functions and alike and
msg = Fformat (3, args);
len = SBYTES (msg) + 1;
- buffer = (char *) alloca (len);
+ SAFE_ALLOCA (buffer, char *, len);
bcopy (SDATA (msg), buffer, len);
message_dolog (buffer, len - 1, 1, 0);
+ SAFE_FREE (len);
+
UNGCPRO;
}
This is useful in situations where you need to redisplay but no
user action has occurred, making it inappropriate for the message
area to be cleared. See tracking_off and
- wait_reading_process_input for examples of these situations.
+ wait_reading_process_output for examples of these situations.
FROM_WHERE is an integer saying from where this function was
called. This is useful for debugging. */
{
struct glyph *glyph = row->glyphs[TEXT_AREA];
struct glyph *end = glyph + row->used[TEXT_AREA];
+ struct glyph *cursor = NULL;
/* The first glyph that starts a sequence of glyphs from string. */
struct glyph *string_start;
/* The X coordinate of string_start. */
/* The last known character position before string_start. */
int string_before_pos;
int x = row->x;
+ int cursor_x = x;
+ int cursor_from_overlay_pos = 0;
int pt_old = PT - delta;
/* Skip over glyphs not having an object at the start of the row.
string_start = NULL;
x += glyph->pixel_width;
++glyph;
+ if (cursor_from_overlay_pos
+ && last_pos > cursor_from_overlay_pos)
+ {
+ cursor_from_overlay_pos = 0;
+ cursor = 0;
+ }
}
else
{
string_start = glyph;
string_start_x = x;
/* Skip all glyphs from string. */
- SKIP_GLYPHS (glyph, end, x, STRINGP (glyph->object));
+ do
+ {
+ int pos;
+ if ((cursor == NULL || glyph > cursor)
+ && !NILP (Fget_char_property (make_number ((glyph)->charpos),
+ Qcursor, (glyph)->object))
+ && (pos = string_buffer_position (w, glyph->object,
+ string_before_pos),
+ (pos == 0 /* From overlay */
+ || pos == pt_old)))
+ {
+ /* Estimate overlay buffer position from the buffer
+ positions of the glyphs before and after the overlay.
+ Add 1 to last_pos so that if point corresponds to the
+ glyph right after the overlay, we still use a 'cursor'
+ property found in that overlay. */
+ cursor_from_overlay_pos = pos == 0 ? last_pos+1 : 0;
+ cursor = glyph;
+ cursor_x = x;
+ }
+ x += glyph->pixel_width;
+ ++glyph;
+ }
+ while (glyph < end && STRINGP (glyph->object));
}
}
- if (string_start
- && (glyph == end || !BUFFERP (glyph->object) || last_pos > pt_old))
+ if (cursor != NULL)
+ {
+ glyph = cursor;
+ x = cursor_x;
+ }
+ else if (string_start
+ && (glyph == end || !BUFFERP (glyph->object) || last_pos > pt_old))
{
/* We may have skipped over point because the previous glyphs
are from string. As there's no easy way to know the
aggressive = current_buffer->scroll_up_aggressively;
height = WINDOW_BOX_TEXT_HEIGHT (w);
if (NUMBERP (aggressive))
- amount_to_scroll = XFLOATINT (aggressive) * height;
+ {
+ double float_amount = XFLOATINT (aggressive) * height;
+ amount_to_scroll = float_amount;
+ if (amount_to_scroll == 0 && float_amount > 0)
+ amount_to_scroll = 1;
+ }
}
if (amount_to_scroll <= 0)
start_display (&it, w, startp);
if (scroll_conservatively)
- amount_to_scroll =
- max (dy, FRAME_LINE_HEIGHT (f) * max (scroll_step, temp_scroll_step));
+ amount_to_scroll
+ = max (dy, FRAME_LINE_HEIGHT (f) * max (scroll_step, temp_scroll_step));
else if (scroll_step || temp_scroll_step)
amount_to_scroll = scroll_max;
else
aggressive = current_buffer->scroll_down_aggressively;
height = WINDOW_BOX_TEXT_HEIGHT (w);
if (NUMBERP (aggressive))
- amount_to_scroll = XFLOATINT (aggressive) * height;
+ {
+ double float_amount = XFLOATINT (aggressive) * height;
+ amount_to_scroll = float_amount;
+ if (amount_to_scroll == 0 && float_amount > 0)
+ amount_to_scroll = 1;
+ }
}
if (amount_to_scroll <= 0)
&& (FRAME_WINDOW_P (f)
|| !overlay_arrow_in_current_buffer_p ()))
{
- int this_scroll_margin;
+ int this_scroll_margin, top_scroll_margin;
struct glyph_row *row = NULL;
#if GLYPH_DEBUG
this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
this_scroll_margin *= FRAME_LINE_HEIGHT (f);
+ top_scroll_margin = this_scroll_margin;
+ if (WINDOW_WANTS_HEADER_LINE_P (w))
+ top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
+
/* Start with the row the cursor was displayed during the last
not paused redisplay. Give up if that row is not valid. */
if (w->last_cursor.vpos < 0
else if (PT < XFASTINT (w->last_point))
{
/* Cursor has to be moved backward. Note that PT >=
- CHARPOS (startp) because of the outer
- if-statement. */
+ CHARPOS (startp) because of the outer if-statement. */
while (!row->mode_line_p
&& (MATRIX_ROW_START_CHARPOS (row) > PT
|| (MATRIX_ROW_START_CHARPOS (row) == PT
&& MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)))
- && (row->y > this_scroll_margin
+ && (row->y > top_scroll_margin
|| CHARPOS (startp) == BEGV))
{
xassert (row->enabled_p);
++row;
/* If within the scroll margin, scroll. */
- if (row->y < this_scroll_margin
+ if (row->y < top_scroll_margin
&& CHARPOS (startp) != BEGV)
scroll_p = 1;
}
buffer. */
|| !NILP (Vwindow_scroll_functions)
|| MINI_WINDOW_P (w)
- || !(used_current_matrix_p =
- try_window_reusing_current_matrix (w)))
+ || !(used_current_matrix_p
+ = try_window_reusing_current_matrix (w)))
{
IF_DEBUG (debug_method_add (w, "1"));
try_window (window, startp);
|| !NILP (Vwindow_scroll_functions)
|| !just_this_one_p
|| MINI_WINDOW_P (w)
- || !(used_current_matrix_p =
- try_window_reusing_current_matrix (w)))
+ || !(used_current_matrix_p
+ = try_window_reusing_current_matrix (w)))
try_window (window, startp);
/* If new fonts have been loaded (due to fontsets), give up. We
last_text_row = last_reused_text_row = NULL;
while (it.current_y < it.last_visible_y
- && IT_CHARPOS (it) < CHARPOS (start)
&& !fonts_changed_p)
- if (display_line (&it))
- last_text_row = it.glyph_row - 1;
+ {
+ /* If we have reached into the characters in the START row,
+ that means the line boundaries have changed. So we
+ can't start copying with the row START. Maybe it will
+ work to start copying with the following row. */
+ while (IT_CHARPOS (it) > CHARPOS (start))
+ {
+ /* Advance to the next row as the "start". */
+ start_row++;
+ start = start_row->start.pos;
+ /* If there are no more rows to try, or just one, give up. */
+ if (start_row == MATRIX_MODE_LINE_ROW (w->current_matrix) - 1
+ || w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (start_row)
+ || CHARPOS (start) == ZV)
+ {
+ clear_glyph_matrix (w->desired_matrix);
+ return 0;
+ }
+
+ start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
+ }
+ /* If we have reached alignment,
+ we can copy the rest of the rows. */
+ if (IT_CHARPOS (it) == CHARPOS (start))
+ break;
+
+ if (display_line (&it))
+ last_text_row = it.glyph_row - 1;
+ }
/* A value of current_y < last_visible_y means that we stopped
at the previous window start, which in turn means that we
if (it.current_y < it.last_visible_y)
{
/* IT.vpos always starts from 0; it counts text lines. */
- nrows_scrolled = it.vpos;
+ nrows_scrolled = it.vpos - (start_row - MATRIX_FIRST_TEXT_ROW (w->current_matrix));
/* Find PT if not already found in the lines displayed. */
if (w->cursor.vpos < 0)
{
- int dy = it.current_y - first_row_y;
+ int dy = it.current_y - start_row->y;
row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
row = row_containing_pos (w, PT, row, NULL, dy);
scroll_run_hook will clear the cursor, and use the
current matrix to get the height of the row the cursor is
in. */
- run.current_y = first_row_y;
+ run.current_y = start_row->y;
run.desired_y = it.current_y;
run.height = it.last_visible_y - it.current_y;
position. */
if (pt_row)
{
- w->cursor.vpos -= MATRIX_ROW_VPOS (first_reusable_row,
- w->current_matrix);
- w->cursor.y -= first_reusable_row->y;
+ w->cursor.vpos -= nrows_scrolled;
+ w->cursor.y -= first_reusable_row->y - start_row->y;
}
/* Scroll the display. */
for (row -= nrows_scrolled; row < bottom_row; ++row)
row->enabled_p = 0;
+ /* Point may have moved to a different line, so we cannot assume that
+ the previous cursor position is valid; locate the correct row. */
+ if (pt_row)
+ {
+ for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
+ row < bottom_row && PT >= MATRIX_ROW_END_CHARPOS (row);
+ row++)
+ {
+ w->cursor.vpos++;
+ w->cursor.y = row->y;
+ }
+ if (row < bottom_row)
+ {
+ struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
+ while (glyph->charpos < PT)
+ {
+ w->cursor.hpos++;
+ w->cursor.x += glyph->pixel_width;
+ glyph++;
+ }
+ }
+ }
+
/* Adjust window end. A null value of last_text_row means that
the window end is in reused rows which in turn means that
only its vpos can have changed. */
if ((w->cursor.y < this_scroll_margin
&& CHARPOS (start) > BEGV)
- /* Don't take scroll margin into account at the bottom because
- old redisplay didn't do it either. */
- || w->cursor.y + cursor_height > it.last_visible_y)
+ /* Old redisplay didn't take scroll margin into account at the bottom,
+ but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
+ || w->cursor.y + cursor_height + this_scroll_margin > it.last_visible_y)
{
w->cursor.vpos = -1;
clear_glyph_matrix (w->desired_matrix);
/* We always start displaying at hpos zero even if hscrolled. */
xassert (it->hpos == 0 && it->current_x == 0);
- /* We must not display in a row that's not a text row. */
- xassert (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
- < it->w->desired_matrix->nrows);
+ if (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
+ >= it->w->desired_matrix->nrows)
+ {
+ it->w->nrows_scale_factor++;
+ fonts_changed_p = 1;
+ return 0;
+ }
/* Is IT->w showing the region? */
it->w->region_showing = it->region_beg_charpos > 0 ? Qt : Qnil;
Lisp_Object oprops, aelt;
oprops = Ftext_properties_at (make_number (0), elt);
+ /* If the starting string's properties are not what
+ we want, translate the string. Also, if the string
+ is risky, do that anyway. */
+
if (NILP (Fequal (props, oprops)) || risky)
{
/* If the starting string has properties,
The mode_line_string_face face property is always added to the string.
*/
-static int store_mode_line_string (string, lisp_string, copy_string, field_width, precision, props)
+static int
+store_mode_line_string (string, lisp_string, copy_string, field_width, precision, props)
char *string;
Lisp_Object lisp_string;
int copy_string;
DEFUN ("format-mode-line", Fformat_mode_line, Sformat_mode_line,
- 0, 3, 0,
+ 0, 4, 0,
doc: /* Return the mode-line of selected window as a string.
First optional arg FORMAT specifies a different format string (see
`mode-line-format' for details) to use. If FORMAT is t, return
the buffer's header-line. Second optional arg WINDOW specifies a
different window to use as the context for the formatting.
-If third optional arg NO-PROPS is non-nil, string is not propertized. */)
- (format, window, no_props)
- Lisp_Object format, window, no_props;
+If third optional arg NO-PROPS is non-nil, string is not propertized.
+Fourth optional arg BUFFER specifies which buffer to use. */)
+ (format, window, no_props, buffer)
+ Lisp_Object format, window, no_props, buffer;
{
struct it it;
int len;
window = selected_window;
CHECK_WINDOW (window);
w = XWINDOW (window);
- CHECK_BUFFER (w->buffer);
- if (XBUFFER (w->buffer) != current_buffer)
+ if (NILP (buffer))
+ buffer = w->buffer;
+
+ CHECK_BUFFER (buffer);
+
+ if (XBUFFER (buffer) != current_buffer)
{
old_buffer = current_buffer;
- set_buffer_internal_1 (XBUFFER (w->buffer));
+ set_buffer_internal_1 (XBUFFER (buffer));
}
if (NILP (format) || EQ (format, Qt))
{
- face_id = NILP (format)
- ? CURRENT_MODE_LINE_FACE_ID (w) :
- HEADER_LINE_FACE_ID;
- format = NILP (format)
- ? current_buffer->mode_line_format
- : current_buffer->header_line_format;
+ face_id = (NILP (format)
+ ? CURRENT_MODE_LINE_FACE_ID (w)
+ : HEADER_LINE_FACE_ID);
+ format = (NILP (format)
+ ? current_buffer->mode_line_format
+ : current_buffer->header_line_format);
}
init_iterator (&it, w, -1, -1, NULL, face_id);
if (NILP (no_props))
{
- mode_line_string_face =
- (face_id == MODE_LINE_FACE_ID ? Qmode_line :
- face_id == MODE_LINE_INACTIVE_FACE_ID ? Qmode_line_inactive :
- face_id == HEADER_LINE_FACE_ID ? Qheader_line : Qnil);
+ mode_line_string_face
+ = (face_id == MODE_LINE_FACE_ID ? Qmode_line
+ : face_id == MODE_LINE_INACTIVE_FACE_ID ? Qmode_line_inactive
+ : face_id == HEADER_LINE_FACE_ID ? Qheader_line : Qnil);
- mode_line_string_face_prop =
- NILP (mode_line_string_face) ? Qnil :
- Fcons (Qface, Fcons (mode_line_string_face, Qnil));
+ mode_line_string_face_prop
+ = (NILP (mode_line_string_face) ? Qnil
+ : Fcons (Qface, Fcons (mode_line_string_face, Qnil)));
/* We need a dummy last element in mode_line_string_list to
indicate we are building the propertized mode-line string.
Using mode_line_string_face_prop here GC protects it. */
- mode_line_string_list =
- Fcons (mode_line_string_face_prop, Qnil);
+ mode_line_string_list
+ = Fcons (mode_line_string_face_prop, Qnil);
frame_title_ptr = NULL;
}
else
generated by character C. PRECISION >= 0 means don't return a
string longer than that value. FIELD_WIDTH > 0 means pad the
string returned with spaces to that value. Return 1 in *MULTIBYTE
- if the result is multibyte text. */
+ if the result is multibyte text.
+
+ Note we operate on the current buffer for most purposes,
+ the exception being w->base_line_pos. */
static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
Lisp_Object obj;
struct frame *f = XFRAME (WINDOW_FRAME (w));
char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
- struct buffer *b = XBUFFER (w->buffer);
+ struct buffer *b = current_buffer;
obj = Qnil;
*multibyte = 0;
case 's':
/* status of process */
- obj = Fget_buffer_process (w->buffer);
+ obj = Fget_buffer_process (Fcurrent_buffer ());
if (NILP (obj))
return "no process";
#ifdef subprocesses
{
/* No need to mention EOL here--the terminal never needs
to do EOL conversion. */
- p = decode_mode_spec_coding (keyboard_coding.symbol, p, 0);
- p = decode_mode_spec_coding (terminal_coding.symbol, p, 0);
+ p = decode_mode_spec_coding (FRAME_KEYBOARD_CODING (f)->symbol, p, 0);
+ p = decode_mode_spec_coding (FRAME_TERMINAL_CODING (f)->symbol, p, 0);
}
p = decode_mode_spec_coding (b->buffer_file_coding_system,
p, eol_flag);
glyph->font_type = FONT_TYPE_UNKNOWN;
++it->glyph_row->used[area];
}
+ else if (!fonts_changed_p)
+ {
+ it->w->ncols_scale_factor++;
+ fonts_changed_p = 1;
+ }
}
/* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
glyph->font_type = FONT_TYPE_UNKNOWN;
++it->glyph_row->used[area];
}
+ else if (!fonts_changed_p)
+ {
+ it->w->ncols_scale_factor++;
+ fonts_changed_p = 1;
+ }
}
glyph->font_type = FONT_TYPE_UNKNOWN;
++it->glyph_row->used[area];
}
+ else if (!fonts_changed_p)
+ {
+ it->w->ncols_scale_factor++;
+ fonts_changed_p = 1;
+ }
}
}
glyph->font_type = FONT_TYPE_UNKNOWN;
++it->glyph_row->used[area];
}
+ else if (!fonts_changed_p)
+ {
+ it->w->ncols_scale_factor++;
+ fonts_changed_p = 1;
+ }
}
cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
}
-#ifndef HAVE_CARBON
if (cursor != No_Cursor)
-#else
- if (bcmp (&cursor, &No_Cursor, sizeof (Cursor)))
-#endif
FRAME_RIF (f)->define_frame_cursor (f, cursor);
}
if (part == ON_VERTICAL_BORDER)
cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
- else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE)
+ else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
+ || part == ON_SCROLL_BAR)
cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
else
cursor = FRAME_X_OUTPUT (f)->text_cursor;
Vwindow_size_change_functions = Qnil;
DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions,
- doc: /* List of Functions to call before redisplaying a window with scrolling.
+ doc: /* List of functions to call before redisplaying a window with scrolling.
Each function is called with two arguments, the window
and its new display-start position. Note that the value of `window-end'
is not valid when these functions are called. */);
and `scroll-right' overrides this variable's effect. */);
Vhscroll_step = make_number (0);
- DEFVAR_LISP ("image-types", &Vimage_types,
- doc: /* List of supported image types.
-Each element of the list is a symbol for a supported image type. */);
- Vimage_types = Qnil;
-
DEFVAR_BOOL ("message-truncate-lines", &message_truncate_lines,
doc: /* If non-nil, messages are truncated instead of resizing the echo area.
Bind this around calls to `message' to let it take effect. */);