X-Git-Url: https://git.hcoop.net/bpt/emacs.git/blobdiff_plain/ba1eeafade86f2f03c7e524ce730b733a56f48e4..8fab6dedbf0d2bd0f97ed8a4abeb717fac384b14:/src/xdisp.c diff --git a/src/xdisp.c b/src/xdisp.c index 984980324b..d37f142e60 100644 --- a/src/xdisp.c +++ b/src/xdisp.c @@ -916,6 +916,7 @@ static int display_string P_ ((unsigned char *, Lisp_Object, Lisp_Object, static void compute_line_metrics P_ ((struct it *)); static void run_redisplay_end_trigger_hook P_ ((struct it *)); static int get_overlay_strings P_ ((struct it *, int)); +static int get_overlay_strings_1 P_ ((struct it *, int, int)); static void next_overlay_string P_ ((struct it *)); static void reseat P_ ((struct it *, struct text_pos, int)); static void reseat_1 P_ ((struct it *, struct text_pos, int)); @@ -1986,15 +1987,15 @@ get_glyph_string_clip_rect (s, nr) Set w->phys_cursor_width to width of phys cursor. */ -int -get_phys_cursor_geometry (w, row, glyph, heightp) +void +get_phys_cursor_geometry (w, row, glyph, xp, yp, heightp) struct window *w; struct glyph_row *row; struct glyph *glyph; - int *heightp; + int *xp, *yp, *heightp; { struct frame *f = XFRAME (WINDOW_FRAME (w)); - int y, wd, h, h0, y0; + int x, y, wd, h, h0, y0; /* Compute the width of the rectangle to draw. If on a stretch glyph, and `x-stretch-block-cursor' is nil, don't draw a @@ -2004,6 +2005,14 @@ get_phys_cursor_geometry (w, row, glyph, heightp) #ifdef HAVE_NTGUI wd++; /* Why? */ #endif + + x = w->phys_cursor.x; + if (x < 0) + { + wd += x; + x = 0; + } + if (glyph->type == STRETCH_GLYPH && !x_stretch_cursor_p) wd = min (FRAME_COLUMN_WIDTH (f), wd); @@ -2033,8 +2042,9 @@ get_phys_cursor_geometry (w, row, glyph, heightp) } } + *xp = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x); + *yp = WINDOW_TO_FRAME_PIXEL_Y (w, y); *heightp = h; - return WINDOW_TO_FRAME_PIXEL_Y (w, y); } /* @@ -2900,8 +2910,8 @@ init_from_display_pos (it, w, pos) also ``processed'' overlay strings at ZV. */ while (it->sp) pop_it (it); - it->current.overlay_string_index = -1; - it->method = GET_FROM_BUFFER; + xassert (it->current.overlay_string_index == -1); + xassert (it->method == GET_FROM_BUFFER); if (CHARPOS (pos->pos) == ZV) it->overlay_strings_at_end_processed_p = 1; } @@ -3012,7 +3022,19 @@ handle_stop (it) if (handled == HANDLED_RECOMPUTE_PROPS) break; else if (handled == HANDLED_RETURN) - return; + { + /* We still want to show before and after strings from + overlays even if the actual buffer text is replaced. */ + if (!handle_overlay_change_p || it->sp > 1) + return; + if (!get_overlay_strings_1 (it, 0, 0)) + return; + it->ignore_overlay_strings_at_pos_p = 1; + it->string_from_display_prop_p = 0; + handle_overlay_change_p = 0; + handled = HANDLED_RECOMPUTE_PROPS; + break; + } else if (handled == HANDLED_OVERLAY_STRING_CONSUMED) handle_overlay_change_p = 0; } @@ -4465,6 +4487,10 @@ handle_composition_prop (it) } return HANDLED_RECOMPUTE_PROPS; } + + it->stop_charpos = end; + push_it (it); + it->method = GET_FROM_COMPOSITION; it->cmp_id = id; it->cmp_len = COMPOSITION_LENGTH (prop); @@ -4474,7 +4500,6 @@ handle_composition_prop (it) it->len = (STRINGP (it->string) ? string_char_to_byte (it->string, end) : CHAR_TO_BYTE (end)) - pos_byte; - it->stop_charpos = end; handled = HANDLED_RETURN; } } @@ -4534,13 +4559,14 @@ next_overlay_string (it) int display_ellipsis_p = it->stack[it->sp - 1].display_ellipsis_p; pop_it (it); - xassert (it->stop_charpos >= BEGV - && it->stop_charpos <= it->end_charpos); - it->string = Qnil; + xassert (it->sp > 0 + || it->method == GET_FROM_COMPOSITION + || (NILP (it->string) + && it->method == GET_FROM_BUFFER + && it->stop_charpos >= BEGV + && it->stop_charpos <= it->end_charpos)); it->current.overlay_string_index = -1; - SET_TEXT_POS (it->current.string_pos, -1, -1); it->n_overlay_strings = 0; - it->method = GET_FROM_BUFFER; /* If we're at the end of the buffer, record that we have processed the overlay strings there already, so that @@ -4796,7 +4822,7 @@ load_overlay_strings (it, charpos) least one overlay string was found. */ static int -get_overlay_strings (it, charpos) +get_overlay_strings_1 (it, charpos, compute_stop_p) struct it *it; int charpos; { @@ -4818,12 +4844,13 @@ get_overlay_strings (it, charpos) /* Make sure we know settings in current_buffer, so that we can restore meaningful values when we're done with the overlay strings. */ - compute_stop_pos (it); + if (compute_stop_p) + compute_stop_pos (it); xassert (it->face_id >= 0); /* Save IT's settings. They are restored after all overlay strings have been processed. */ - xassert (it->sp == 0); + xassert (!compute_stop_p || it->sp == 0); push_it (it); /* Set up IT to deliver display elements from the first overlay @@ -4835,13 +4862,22 @@ get_overlay_strings (it, charpos) it->end_charpos = SCHARS (it->string); it->multibyte_p = STRING_MULTIBYTE (it->string); it->method = GET_FROM_STRING; + return 1; } - else - { - it->string = Qnil; - it->current.overlay_string_index = -1; - it->method = GET_FROM_BUFFER; - } + + it->current.overlay_string_index = -1; + return 0; +} + +static int +get_overlay_strings (it, charpos) + struct it *it; + int charpos; +{ + it->string = Qnil; + it->method = GET_FROM_BUFFER; + + (void) get_overlay_strings_1 (it, charpos, 1); CHECK_IT (it); @@ -4866,19 +4902,38 @@ push_it (it) { struct iterator_stack_entry *p; - xassert (it->sp < 2); + xassert (it->sp < IT_STACK_SIZE); p = it->stack + it->sp; p->stop_charpos = it->stop_charpos; xassert (it->face_id >= 0); p->face_id = it->face_id; p->string = it->string; - p->pos = it->current; + p->method = it->method; + switch (p->method) + { + case GET_FROM_IMAGE: + p->u.image.object = it->object; + p->u.image.image_id = it->image_id; + p->u.image.slice = it->slice; + break; + case GET_FROM_COMPOSITION: + p->u.comp.object = it->object; + p->u.comp.c = it->c; + p->u.comp.len = it->len; + p->u.comp.cmp_id = it->cmp_id; + p->u.comp.cmp_len = it->cmp_len; + break; + case GET_FROM_STRETCH: + p->u.stretch.object = it->object; + break; + } + p->position = it->position; + p->current = it->current; p->end_charpos = it->end_charpos; p->string_nchars = it->string_nchars; p->area = it->area; p->multibyte_p = it->multibyte_p; - p->slice = it->slice; p->space_width = it->space_width; p->font_height = it->font_height; p->voffset = it->voffset; @@ -4905,13 +4960,34 @@ pop_it (it) p = it->stack + it->sp; it->stop_charpos = p->stop_charpos; it->face_id = p->face_id; + it->current = p->current; + it->position = p->position; it->string = p->string; - it->current = p->pos; + if (NILP (it->string)) + SET_TEXT_POS (it->current.string_pos, -1, -1); + it->method = p->method; + switch (it->method) + { + case GET_FROM_IMAGE: + it->image_id = p->u.image.image_id; + it->object = p->u.image.object; + it->slice = p->u.image.slice; + break; + case GET_FROM_COMPOSITION: + it->object = p->u.comp.object; + it->c = p->u.comp.c; + it->len = p->u.comp.len; + it->cmp_id = p->u.comp.cmp_id; + it->cmp_len = p->u.comp.cmp_len; + break; + case GET_FROM_STRETCH: + it->object = p->u.comp.object; + break; + } it->end_charpos = p->end_charpos; it->string_nchars = p->string_nchars; it->area = p->area; it->multibyte_p = p->multibyte_p; - it->slice = p->slice; it->space_width = p->space_width; it->font_height = p->font_height; it->voffset = p->voffset; @@ -5043,6 +5119,7 @@ back_to_previous_visible_line_start (it) while (IT_CHARPOS (*it) > BEGV) { back_to_previous_line_start (it); + if (IT_CHARPOS (*it) <= BEGV) break; @@ -5062,37 +5139,47 @@ back_to_previous_visible_line_start (it) continue; } - /* If newline has a display property that replaces the newline with something - else (image or text), find start of overlay or interval and continue search - from that point. */ - if (IT_CHARPOS (*it) > BEGV) - { - struct it it2 = *it; - int pos; - int beg, end; - Lisp_Object val, overlay; - - pos = --IT_CHARPOS (it2); - --IT_BYTEPOS (it2); - it2.sp = 0; - if (handle_display_prop (&it2) == HANDLED_RETURN - && !NILP (val = get_char_property_and_overlay - (make_number (pos), Qdisplay, Qnil, &overlay)) - && (OVERLAYP (overlay) - ? (beg = OVERLAY_POSITION (OVERLAY_START (overlay))) - : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil))) - { - if (beg < BEGV) - beg = BEGV; - IT_CHARPOS (*it) = beg; - IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg); - continue; - } - } + if (IT_CHARPOS (*it) <= BEGV) + break; - break; + { + struct it it2; + int pos; + int beg, end; + Lisp_Object val, overlay; + + /* If newline is part of a composition, continue from start of composition */ + if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil) + && beg < IT_CHARPOS (*it)) + goto replaced; + + /* If newline is replaced by a display property, find start of overlay + or interval and continue search from that point. */ + it2 = *it; + pos = --IT_CHARPOS (it2); + --IT_BYTEPOS (it2); + it2.sp = 0; + if (handle_display_prop (&it2) == HANDLED_RETURN + && !NILP (val = get_char_property_and_overlay + (make_number (pos), Qdisplay, Qnil, &overlay)) + && (OVERLAYP (overlay) + ? (beg = OVERLAY_POSITION (OVERLAY_START (overlay))) + : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil))) + goto replaced; + + /* Newline is not replaced by anything -- so we are done. */ + break; + + replaced: + if (beg < BEGV) + beg = BEGV; + IT_CHARPOS (*it) = beg; + IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg); + } } + it->continuation_lines_width = 0; + xassert (IT_CHARPOS (*it) >= BEGV); xassert (IT_CHARPOS (*it) == BEGV || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n'); @@ -5224,15 +5311,11 @@ reseat_1 (it, pos, set_stop_p) IT_STRING_BYTEPOS (*it) = -1; it->string = Qnil; it->method = GET_FROM_BUFFER; - /* RMS: I added this to fix a bug in move_it_vertically_backward - where it->area continued to relate to the starting point - for the backward motion. Bug report from - Nick Roberts on 19 May 2003. - However, I am not sure whether reseat still does the right thing - in general after this change. */ + it->object = it->w->buffer; it->area = TEXT_AREA; it->multibyte_p = !NILP (current_buffer->enable_multibyte_characters); it->sp = 0; + it->string_from_display_prop_p = 0; it->face_before_selective_p = 0; if (set_stop_p) @@ -5711,18 +5794,20 @@ set_iterator_to_next (it, reseat_p) case GET_FROM_COMPOSITION: xassert (it->cmp_id >= 0 && it->cmp_id < n_compositions); - if (STRINGP (it->string)) + xassert (it->sp > 0); + pop_it (it); + if (it->method == GET_FROM_STRING) { IT_STRING_BYTEPOS (*it) += it->len; IT_STRING_CHARPOS (*it) += it->cmp_len; - it->method = GET_FROM_STRING; + it->object = it->string; goto consider_string_end; } - else + else if (it->method == GET_FROM_BUFFER) { IT_BYTEPOS (*it) += it->len; IT_CHARPOS (*it) += it->cmp_len; - it->method = GET_FROM_BUFFER; + it->object = it->w->buffer; } break; @@ -5752,7 +5837,10 @@ set_iterator_to_next (it, reseat_p) else if (STRINGP (it->string)) it->method = GET_FROM_STRING; else - it->method = GET_FROM_BUFFER; + { + it->method = GET_FROM_BUFFER; + it->object = it->w->buffer; + } it->dpvec = NULL; it->current.dpvec_index = -1; @@ -5800,9 +5888,8 @@ set_iterator_to_next (it, reseat_p) && it->sp > 0) { pop_it (it); - if (STRINGP (it->string)) + if (it->method == GET_FROM_STRING) goto consider_string_end; - it->method = GET_FROM_BUFFER; } } break; @@ -5814,13 +5901,8 @@ set_iterator_to_next (it, reseat_p) if the `display' property takes up the whole string. */ xassert (it->sp > 0); pop_it (it); - it->image_id = 0; - if (STRINGP (it->string)) - { - it->method = GET_FROM_STRING; - goto consider_string_end; - } - it->method = GET_FROM_BUFFER; + if (it->method == GET_FROM_STRING) + goto consider_string_end; break; default: @@ -6043,6 +6125,7 @@ next_element_from_ellipsis (it) setting face_before_selective_p. */ it->saved_face_id = it->face_id; it->method = GET_FROM_BUFFER; + it->object = it->w->buffer; reseat_at_next_visible_line_start (it, 1); it->face_before_selective_p = 1; } @@ -6229,6 +6312,10 @@ next_element_from_composition (it) it->position = (STRINGP (it->string) ? it->current.string_pos : it->current.pos); + if (STRINGP (it->string)) + it->object = it->string; + else + it->object = it->w->buffer; return 1; } @@ -9491,7 +9578,8 @@ display_tool_bar_line (it, height) while (it->current_x < max_x) { - int x_before, x, n_glyphs_before, i, nglyphs; + int x, n_glyphs_before, i, nglyphs; + struct it it_before; /* Get the next display element. */ if (!get_next_display_element (it)) @@ -9503,22 +9591,29 @@ display_tool_bar_line (it, height) } /* Produce glyphs. */ - x_before = it->current_x; - n_glyphs_before = it->glyph_row->used[TEXT_AREA]; + n_glyphs_before = row->used[TEXT_AREA]; + it_before = *it; + PRODUCE_GLYPHS (it); - nglyphs = it->glyph_row->used[TEXT_AREA] - n_glyphs_before; + nglyphs = row->used[TEXT_AREA] - n_glyphs_before; i = 0; - x = x_before; + x = it_before.current_x; while (i < nglyphs) { struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i; if (x + glyph->pixel_width > max_x) { - /* Glyph doesn't fit on line. */ - it->glyph_row->used[TEXT_AREA] = n_glyphs_before + i; - it->current_x = x; + /* Glyph doesn't fit on line. Backtrack. */ + row->used[TEXT_AREA] = n_glyphs_before; + *it = it_before; + /* If this is the only glyph on this line, it will never fit on the + toolbar, so skip it. But ensure there is at least one glyph, + so we don't accidentally disable the tool-bar. */ + if (n_glyphs_before == 0 + && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1)) + break; goto out; } @@ -9549,6 +9644,8 @@ display_tool_bar_line (it, height) /* Make line the desired height and center it vertically. */ if ((height -= it->max_ascent + it->max_descent) > 0) { + /* Don't add more than one line height. */ + height %= FRAME_LINE_HEIGHT (it->f); it->max_ascent += height / 2; it->max_descent += (height + 1) / 2; } @@ -9575,6 +9672,11 @@ display_tool_bar_line (it, height) } +/* Max tool-bar height. */ + +#define MAX_FRAME_TOOL_BAR_HEIGHT(f) \ + ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f))) + /* Value is the number of screen lines needed to make all tool-bar items of frame F visible. The number of actual rows needed is returned in *N_ROWS if non-NULL. */ @@ -9586,7 +9688,10 @@ tool_bar_lines_needed (f, n_rows) { struct window *w = XWINDOW (f->tool_bar_window); struct it it; - struct glyph_row *temp_row = w->desired_matrix->rows; + /* tool_bar_lines_needed is called from redisplay_tool_bar after building + the desired matrix, so use (unused) mode-line row as temporary row to + avoid destroying the first tool-bar row. */ + struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix); /* Initialize an iterator for iteration over F->desired_tool_bar_string in the tool-bar window of frame F. */ @@ -9692,13 +9797,13 @@ redisplay_tool_bar (f) int old_height = WINDOW_TOTAL_LINES (w); XSETFRAME (frame, f); - clear_glyph_matrix (w->desired_matrix); Fmodify_frame_parameters (frame, Fcons (Fcons (Qtool_bar_lines, make_number (nlines)), Qnil)); if (WINDOW_TOTAL_LINES (w) != old_height) { + clear_glyph_matrix (w->desired_matrix); fonts_changed_p = 1; return 1; } @@ -9723,7 +9828,7 @@ redisplay_tool_bar (f) border = 0; rows = f->n_tool_bar_rows; - height = (it.last_visible_y - border) / rows; + height = max (1, (it.last_visible_y - border) / rows); extra = it.last_visible_y - border - height * rows; while (it.current_y < it.last_visible_y) @@ -9750,17 +9855,20 @@ redisplay_tool_bar (f) if (auto_resize_tool_bars_p) { - int nlines; + int nlines, nrows; + int max_tool_bar_height = MAX_FRAME_TOOL_BAR_HEIGHT (f); /* If we couldn't display everything, change the tool-bar's - height. */ - if (IT_STRING_CHARPOS (it) < it.end_charpos) + height if there is room for more. */ + if (IT_STRING_CHARPOS (it) < it.end_charpos + && it.current_y < max_tool_bar_height) change_height_p = 1; + row = it.glyph_row - 1; + /* If there are blank lines at the end, except for a partially visible blank line at the end that is smaller than FRAME_LINE_HEIGHT, change the tool-bar's height. */ - row = it.glyph_row - 1; if (!row->displays_text_p && row->height >= FRAME_LINE_HEIGHT (f)) change_height_p = 1; @@ -9768,13 +9876,14 @@ redisplay_tool_bar (f) /* If row displays tool-bar items, but is partially visible, change the tool-bar's height. */ if (row->displays_text_p - && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y) + && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y + && MATRIX_ROW_BOTTOM_Y (row) < max_tool_bar_height) change_height_p = 1; /* Resize windows as needed by changing the `tool-bar-lines' frame parameter. */ if (change_height_p - && (nlines = tool_bar_lines_needed (f, &f->n_tool_bar_rows), + && (nlines = tool_bar_lines_needed (f, &nrows), nlines != WINDOW_TOTAL_LINES (w))) { extern Lisp_Object Qtool_bar_lines; @@ -9782,13 +9891,16 @@ redisplay_tool_bar (f) int old_height = WINDOW_TOTAL_LINES (w); XSETFRAME (frame, f); - clear_glyph_matrix (w->desired_matrix); Fmodify_frame_parameters (frame, Fcons (Fcons (Qtool_bar_lines, make_number (nlines)), Qnil)); if (WINDOW_TOTAL_LINES (w) != old_height) - fonts_changed_p = 1; + { + clear_glyph_matrix (w->desired_matrix); + f->n_tool_bar_rows = nrows; + fonts_changed_p = 1; + } } } @@ -11607,9 +11719,11 @@ redisplay_window_1 (window) /* Set cursor position of W. PT is assumed to be displayed in ROW. DELTA is the number of bytes by which positions recorded in ROW - differ from current buffer positions. */ + differ from current buffer positions. -void + Return 0 if cursor is not on this row. 1 otherwise. */ + +int set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos) struct window *w; struct glyph_row *row; @@ -11664,9 +11778,12 @@ set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos) } else { - string_before_pos = last_pos; - string_start = glyph; - string_start_x = x; + if (string_start == NULL) + { + string_before_pos = last_pos; + string_start = glyph; + string_start_x = x; + } /* Skip all glyphs from string. */ do { @@ -11724,25 +11841,25 @@ set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos) glyph on point by scanning from string_start again. */ Lisp_Object limit; Lisp_Object string; + struct glyph *stop = glyph; int pos; limit = make_number (pt_old + 1); - end = glyph; glyph = string_start; x = string_start_x; string = glyph->object; pos = string_buffer_position (w, string, string_before_pos); /* If STRING is from overlay, LAST_POS == 0. We skip such glyphs because we always put cursor after overlay strings. */ - while (pos == 0 && glyph < end) + while (pos == 0 && glyph < stop) { string = glyph->object; - SKIP_GLYPHS (glyph, end, x, EQ (glyph->object, string)); - if (glyph < end) + SKIP_GLYPHS (glyph, stop, x, EQ (glyph->object, string)); + if (glyph < stop) pos = string_buffer_position (w, glyph->object, string_before_pos); } - while (glyph < end) + while (glyph < stop) { pos = XINT (Fnext_single_char_property_change (make_number (pos), Qdisplay, Qnil, limit)); @@ -11750,15 +11867,20 @@ set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos) break; /* Skip glyphs from the same string. */ string = glyph->object; - SKIP_GLYPHS (glyph, end, x, EQ (glyph->object, string)); + SKIP_GLYPHS (glyph, stop, x, EQ (glyph->object, string)); /* Skip glyphs from an overlay. */ - while (glyph < end + while (glyph < stop && ! string_buffer_position (w, glyph->object, pos)) { string = glyph->object; - SKIP_GLYPHS (glyph, end, x, EQ (glyph->object, string)); + SKIP_GLYPHS (glyph, stop, x, EQ (glyph->object, string)); } } + + /* If we reached the end of the line, and end was from a string, + cursor is not on this line. */ + if (glyph == end && row->continued_p) + return 0; } w->cursor.hpos = glyph - row->glyphs[TEXT_AREA]; @@ -11792,6 +11914,8 @@ set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos) else CHARPOS (this_line_start_pos) = 0; } + + return 1; } @@ -12475,8 +12599,18 @@ try_cursor_movement (window, startp, scroll_step) rc = CURSOR_MOVEMENT_MUST_SCROLL; else { - set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0); - rc = CURSOR_MOVEMENT_SUCCESS; + do + { + if (set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0)) + { + rc = CURSOR_MOVEMENT_SUCCESS; + break; + } + ++row; + } + while (MATRIX_ROW_BOTTOM_Y (row) < last_y + && MATRIX_ROW_START_CHARPOS (row) == PT + && cursor_row_p (w, row)); } } } @@ -14929,6 +15063,25 @@ dump_glyph (row, glyph, area) glyph->left_box_line_p, glyph->right_box_line_p); } + else if (glyph->type == COMPOSITE_GLYPH) + { + fprintf (stderr, + " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n", + glyph - row->glyphs[TEXT_AREA], + '+', + glyph->charpos, + (BUFFERP (glyph->object) + ? 'B' + : (STRINGP (glyph->object) + ? 'S' + : '-')), + glyph->pixel_width, + glyph->u.cmp_id, + '.', + glyph->face_id, + glyph->left_box_line_p, + glyph->right_box_line_p); + } } @@ -21315,7 +21468,7 @@ erase_phys_cursor (w) /* Maybe clear the display under the cursor. */ if (w->phys_cursor_type == HOLLOW_BOX_CURSOR) { - int x, y; + int x, y, left_x; int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w); int width; @@ -21323,11 +21476,16 @@ erase_phys_cursor (w) if (cursor_glyph == NULL) goto mark_cursor_off; - x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x); + width = cursor_glyph->pixel_width; + left_x = window_box_left_offset (w, TEXT_AREA); + x = w->phys_cursor.x; + if (x < left_x) + width -= left_x - x; + width = min (width, window_box_width (w, TEXT_AREA) - x); y = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, cursor_row->y)); - width = min (cursor_glyph->pixel_width, - window_box_width (w, TEXT_AREA) - w->phys_cursor.x); + x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, max (x, left_x)); + if (width > 0) rif->clear_frame_area (f, x, y, width, cursor_row->visible_height); }