emacs: src/xdisp.c comparison

comparison src/xdisp.c @ 107998:531d454c3a99

Implement GUI display of R2L lines, fix TTY display of R2L lines. xdisp.c [HAVE_WINDOW_SYSTEM]: Add prototype for append_stretch_glyph. (set_cursor_from_row) <cursor_x>: Remove unused variable. Fix off-by-one error in computing x at end of text in the row. (append_stretch_glyph): In reversed row, prepend the glyph rather than append it. Set resolved_level and bidi_type of the glyph. (extend_face_to_end_of_line): If the row is reversed, prepend a stretch glyph whose width is such that the rightmost glyph will be drawn at the right margin of the window. Fix off-by-one error on TTY frames in testing whether a line needs face extension. Fix face extension at ZV. If this is the last glyph row, use DEFAULT_FACE_ID, to avoid painting the rest of the window with the region face. (set_cursor_from_row, display_line): Use MATRIX_ROW_CONTINUATION_LINE_P instead of testing value of row->continuation_lines_width. (next_element_from_buffer): Don't call bidi_paragraph_init if we are at ZV. Fixes a crash when reseated to ZV by try_window_reusing_current_matrix. (display_and_set_cursor, erase_phys_cursor): Handle negative HPOS, which happens with R2L glyph rows. Fixes a crash when inserting a character at end of an R2L line. (set_cursor_from_row): Don't be fooled by truncated rows: don't treat them as having zero-width characters. Improve comments. Don't reverse pos_before and pos_after for reversed glyph rows. Set cursor.x to negative value when the cursor might be on the left fringe. (IT_OVERFLOW_NEWLINE_INTO_FRINGE): For R2L lines, consider the left fringe, not the right one. (notice_overwritten_cursor, draw_phys_cursor_glyph) (erase_phys_cursor): For reversed cursor_row, support cursor on the left fringe. fringe.c (update_window_fringes): For R2L rows, swap the bitmaps of continuation indicators on the fringes. (draw_fringe_bitmap): For reversed glyph rows, allow cursor on the left fringe. w32term.c (w32_draw_window_cursor): For reversed glyph rows, draw cursor on the left fringe. xterm.c (x_draw_window_cursor): For reversed glyph rows, draw cursor on the left fringe. dispnew.c (update_text_area): Handle reversed desired rows when the cursor is on the left fringe. (set_window_cursor_after_update): Limit cursor's hpos by -1 from below, not by 0, for when the cursor is on the left fringe. xdisp.c (unproduce_glyphs): New function. (display_line): Use it when produced glyphs are discarded from R2L glyph rows. (append_composite_glyph): In R2L rows, prepend the glyph rather than appending it. term.c (append_composite_glyph): In R2L rows, prepend the glyph rather than append it. Set up the resolved_level and bidi_type attributes of the appended glyph. (produce_special_glyphs): Mirror the backslash continuation character in R2L lines.

author	Eli Zaretskii <eliz@gnu.org>
date	Tue, 20 Apr 2010 16:31:28 +0300
parents	bef5d1738c0b 8ef8b6523597
children	4d8277a44bb4

comparison

equal deleted inserted replaced

-:d94009e7a0cc
+:531d454c3a99
 extern Lisp_Object Voverflow_newline_into_fringe;
 /* Test if overflow newline into fringe.  Called with iterator IT
 at or past right window margin, and with IT->current_x set.  */
-#define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it)	\
+#define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT)		\
-(!NILP (Voverflow_newline_into_fringe)	\
+(!NILP (Voverflow_newline_into_fringe)		\
-&& FRAME_WINDOW_P (it->f)			\
+&& FRAME_WINDOW_P ((IT)->f)				\
-&& WINDOW_RIGHT_FRINGE_WIDTH (it->w) > 0	\
+&& ((IT)->bidi_it.paragraph_dir == R2L		\
-&& it->current_x == it->last_visible_x	\
+? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0)	\
-&& it->line_wrap != WORD_WRAP)
+: (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0))	\
+&& (IT)->current_x == (IT)->last_visible_x		\
+&& (IT)->line_wrap != WORD_WRAP)
 #else /* !HAVE_WINDOW_SYSTEM */
 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
 #endif /* HAVE_WINDOW_SYSTEM */
 static int redisplay_tool_bar P_ ((struct frame *));
 static void display_tool_bar_line P_ ((struct it *, int));
 static void notice_overwritten_cursor P_ ((struct window *,
 					   enum glyph_row_area,
 					   int, int, int, int));
+static void append_stretch_glyph P_ ((struct it *, Lisp_Object,
+				      int, int, int));
 #endif /* HAVE_WINDOW_SYSTEM */
 a different paragraph.  */
 if (it->bidi_p && it->bidi_it.first_elt)
 {
 it->bidi_it.charpos = IT_CHARPOS (*it);
 it->bidi_it.bytepos = IT_BYTEPOS (*it);
-/* If we are at the beginning of a line, we can produce the next
+if (it->bidi_it.bytepos == ZV_BYTE)
-	 element right away.  */
+	{
-if (it->bidi_it.bytepos == BEGV_BYTE
+	  /* Nothing to do, but reset the FIRST_ELT flag, like
+	     bidi_paragraph_init does, because we are not going to
+	     call it.  */
+	  it->bidi_it.first_elt = 0;
+	}
+else if (it->bidi_it.bytepos == BEGV_BYTE
 	  /* FIXME: Should support all Unicode line separators.  */
 	  || FETCH_CHAR (it->bidi_it.bytepos - 1) == '\n'
 	  || FETCH_CHAR (it->bidi_it.bytepos) == '\n')
 	{
+	  /* If we are at the beginning of a line, we can produce the
+	     next element right away.  */
 	  bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
 	  bidi_get_next_char_visually (&it->bidi_it);
 	}
 else
 	{
 struct glyph *end = glyph + row->used[TEXT_AREA];
 struct glyph *cursor = NULL;
 /* The last known character position in row.  */
 int last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
 int x = row->x;
-int cursor_x = x;
 EMACS_INT pt_old = PT - delta;
 EMACS_INT pos_before = MATRIX_ROW_START_CHARPOS (row) + delta;
 EMACS_INT pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
 struct glyph *glyph_before = glyph - 1, *glyph_after = end;
 /* A glyph beyond the edge of TEXT_AREA which we should never
 	      x += glyph->pixel_width;
 	      ++glyph;
 	    }
 	  while (end > glyph
 		 && INTEGERP ((end - 1)->object)
-		 /* CHARPOS is zero for blanks inserted by
+		 /* CHARPOS is zero for blanks and stretch glyphs
-		    extend_face_to_end_of_line.  */
+		    inserted by extend_face_to_end_of_line.  */
 		 && (end - 1)->charpos <= 0)
 	    --end;
 	  glyph_before = glyph - 1;
 	  glyph_after = end;
 	}
 	  /* If the glyph row is reversed, we need to process it from back
 	     to front, so swap the edge pointers.  */
 	  glyphs_end = end = glyph - 1;
 	  glyph += row->used[TEXT_AREA] - 1;
-	  /* Reverse the known positions in the row.  */
-	  last_pos = pos_after = MATRIX_ROW_START_CHARPOS (row) + delta;
-	  pos_before = MATRIX_ROW_END_CHARPOS (row) + delta;
 	  while (glyph > end + 1
 		 && INTEGERP (glyph->object)
 		 && glyph->charpos < 0)
 	    {
 	    --glyph;
 	  /* By default, in reversed rows we put the cursor on the
 	     rightmost (first in the reading order) glyph.  */
 	  for (g = end + 1; g < glyph; g++)
 	    x += g->pixel_width;
-	  cursor_x = x;
 	  while (end < glyph
 		 && INTEGERP ((end + 1)->object)
 		 && (end + 1)->charpos <= 0)
 	    ++end;
 	  glyph_before = glyph + 1;
 {
 /* In R2L rows that don't display text, put the cursor on the
 	 rightmost glyph.  Case in point: an empty last line that is
 	 part of an R2L paragraph.  */
 cursor = end - 1;
-x = -1;	/* will be computed below, at lable compute_x */
+x = -1;	/* will be computed below, at label compute_x */
 }
 /* Step 1: Try to find the glyph whose character position
 corresponds to point.  If that's not possible, find 2 glyphs
 whose character positions are the closest to point, one before
 		  }
 	      }
 	    string_seen = 1;
 	  }
 	--glyph;
-	if (glyph == end)
+	if (glyph == glyphs_end) /* don't dereference outside TEXT_AREA */
-	  break;
+	  {
+	    x--;		/* can't use any pixel_width */
+	    break;
+	  }
 	x -= glyph->pixel_width;
 }
 /* Step 2: If we didn't find an exact match for point, we need to
 look for a proper place to put the cursor among glyphs between
 	      glyph--;
 	    }
 	}
 else if (match_with_avoid_cursor
 	       /* zero-width characters produce no glyphs */
-	       || eabs (glyph_after - glyph_before) == 1)
+	       || ((row->reversed_p
+		    ? glyph_after > glyphs_end
+		    : glyph_after < glyphs_end)
+		   && eabs (glyph_after - glyph_before) == 1))
 	{
 	  cursor = glyph_after;
 	  x = -1;
 	}
 else if (string_seen)
 	    abort ();
 	  x += g->pixel_width;
 	}
 }
-/* ROW could be part of a continued line, which might have other
+/* ROW could be part of a continued line, which, under bidi
-rows whose start and end charpos occlude point.  Only set
+reordering, might have other rows whose start and end charpos
-w->cursor if we found a better approximation to the cursor
+occlude point.  Only set w->cursor if we found a better
-position than we have from previously examined rows.  */
+approximation to the cursor position than we have from previously
+examined candidate rows belonging to the same continued line.  */
 if (/* we already have a candidate row */
 w->cursor.vpos >= 0
 /* that candidate is not the row we are processing */
 && MATRIX_ROW (matrix, w->cursor.vpos) != row
-/* this row is part of a continued line */
+/* the row we are processing is part of a continued line */
-&& (row->continued_p || row->continuation_lines_width)
+&& (row->continued_p || MATRIX_ROW_CONTINUATION_LINE_P (row))
 /* Make sure cursor.vpos specifies a row whose start and end
 	 charpos occlude point.  This is because some callers of this
 	 function leave cursor.vpos at the row where the cursor was
 	 displayed during the last redisplay cycle.  */
 && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)) <= pt_old
 return 0;
 }
 /* Extend the face of the last glyph in the text area of IT->glyph_row
-to the end of the display line.  Called from display_line.
+to the end of the display line.  Called from display_line.  If the
-If the glyph row is empty, add a space glyph to it so that we
+glyph row is empty, add a space glyph to it so that we know the
-know the face to draw.  Set the glyph row flag fill_line_p.  */
+face to draw.  Set the glyph row flag fill_line_p.  If the glyph
+row is R2L, prepend a stretch glyph to cover the empty space to the
+left of the leftmost glyph.  */
 static void
 extend_face_to_end_of_line (it)
 struct it *it;
 {
 struct face *face;
 struct frame *f = it->f;
-/* If line is already filled, do nothing.  */
+/* If line is already filled, do nothing.  Non window-system frames
-if (it->current_x >= it->last_visible_x)
+get a grace of one more ``pixel'' because their characters are
+1-``pixel'' wide, so they hit the equality too early.  */
+if (it->current_x >= it->last_visible_x + !FRAME_WINDOW_P (f))
 return;
 /* Face extension extends the background and box of IT->face_id
 to the end of the line.  If the background equals the background
 of the frame, we don't have to do anything.  */
 if (it->face_before_selective_p)
-face = FACE_FROM_ID (it->f, it->saved_face_id);
+face = FACE_FROM_ID (f, it->saved_face_id);
 else
 face = FACE_FROM_ID (f, it->face_id);
 if (FRAME_WINDOW_P (f)
 && it->glyph_row->displays_text_p
 && face->box == FACE_NO_BOX
 && face->background == FRAME_BACKGROUND_PIXEL (f)
-&& !face->stipple)
+&& !face->stipple
+&& !it->glyph_row->reversed_p)
 return;
 /* Set the glyph row flag indicating that the face of the last glyph
 in the text area has to be drawn to the end of the text area.  */
 it->glyph_row->fill_line_p = 1;
 	{
 	  it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
 	  it->glyph_row->glyphs[TEXT_AREA][0].face_id = it->face_id;
 	  it->glyph_row->used[TEXT_AREA] = 1;
 	}
+#ifdef HAVE_WINDOW_SYSTEM
+if (it->glyph_row->reversed_p)
+	{
+	  /* Prepend a stretch glyph to the row, such that the
+	     rightmost glyph will be drawn flushed all the way to the
+	     right margin of the window.  The stretch glyph that will
+	     occupy the empty space, if any, to the left of the
+	     glyphs.  */
+	  struct font *font = face->font ? face->font : FRAME_FONT (f);
+	  struct glyph *row_start = it->glyph_row->glyphs[TEXT_AREA];
+	  struct glyph *row_end = row_start + it->glyph_row->used[TEXT_AREA];
+	  struct glyph *g;
+	  int row_width, stretch_ascent, stretch_width;
+	  struct text_pos saved_pos;
+	  int saved_face_id, saved_avoid_cursor;
+	  for (row_width = 0, g = row_start; g < row_end; g++)
+	    row_width += g->pixel_width;
+	  stretch_width = window_box_width (it->w, TEXT_AREA) - row_width;
+	  if (stretch_width > 0)
+	    {
+	      stretch_ascent =
+		(((it->ascent + it->descent)
+		  * FONT_BASE (font)) / FONT_HEIGHT (font));
+	      saved_pos = it->position;
+	      bzero (&it->position, sizeof it->position);
+	      saved_avoid_cursor = it->avoid_cursor_p;
+	      it->avoid_cursor_p = 1;
+	      saved_face_id = it->face_id;
+	      /* The last row's stretch glyph should get the default
+		 face, to avoid painting the rest of the window with
+		 the region face, if the region ends at ZV.  */
+	      if (it->glyph_row->ends_at_zv_p)
+		it->face_id = DEFAULT_FACE_ID;
+	      else
+		it->face_id = face->id;
+	      append_stretch_glyph (it, make_number (0), stretch_width,
+				    it->ascent + it->descent, stretch_ascent);
+	      it->position = saved_pos;
+	      it->avoid_cursor_p = saved_avoid_cursor;
+	      it->face_id = saved_face_id;
+	    }
+	}
+#endif	/* HAVE_WINDOW_SYSTEM */
 }
 else
 {
 /* Save some values that must not be changed.  */
 int saved_x = it->current_x;
 it->what = IT_CHARACTER;
 bzero (&it->position, sizeof it->position);
 it->object = make_number (0);
 it->c = ' ';
 it->len = 1;
-it->face_id = face->id;
+/* The last row's blank glyphs should get the default face, to
+	 avoid painting the rest of the window with the region face,
+	 if the region ends at ZV.  */
+if (it->glyph_row->ends_at_zv_p)
+	it->face_id = DEFAULT_FACE_ID;
+else
+	it->face_id = face->id;
 PRODUCE_GLYPHS (it);
 while (it->current_x <= it->last_visible_x)
 	PRODUCE_GLYPHS (it);
 it->avoid_cursor_p = 1;
 }
 }
+/* Remove N glyphs at the start of a reversed IT->glyph_row.  Called
+only for R2L lines from display_line, when it decides that too many
+glyphs were produced by PRODUCE_GLYPHS, and the line needs to be
+continued.  */
+static void
+unproduce_glyphs (it, n)
+struct it *it;
+int n;
+{
+struct glyph *glyph, *end;
+xassert (it->glyph_row);
+xassert (it->glyph_row->reversed_p);
+xassert (it->area == TEXT_AREA);
+xassert (n <= it->glyph_row->used[TEXT_AREA]);
+if (n > it->glyph_row->used[TEXT_AREA])
+n = it->glyph_row->used[TEXT_AREA];
+glyph = it->glyph_row->glyphs[TEXT_AREA] + n;
+end = it->glyph_row->glyphs[TEXT_AREA] + it->glyph_row->used[TEXT_AREA];
+for ( ; glyph < end; glyph++)
+glyph[-n] = *glyph;
+}
 /* Construct the glyph row IT->glyph_row in the desired matrix of
 IT->w from text at the current position of IT.  See dispextern.h
 for an overview of struct it.  Value is non-zero if
 IT->glyph_row displays text, as opposed to a line displaying ZV
 			   && !FRAME_WINDOW_P (it->f))
 		    {
 		      /* A padding glyph that doesn't fit on this line.
 			 This means the whole character doesn't fit
 			 on the line.  */
+		      if (row->reversed_p)
+			unproduce_glyphs (it, row->used[TEXT_AREA]
+					       - n_glyphs_before);
 		      row->used[TEXT_AREA] = n_glyphs_before;
 		      /* Fill the rest of the row with continuation
 			 glyphs like in 20.x.  */
 		      while (row->glyphs[TEXT_AREA] + row->used[TEXT_AREA]
 		      it->max_phys_descent = phys_descent;
 		    }
 		  else if (wrap_row_used > 0)
 		    {
 		    back_to_wrap:
+		      if (row->reversed_p)
+			unproduce_glyphs (it,
+					  row->used[TEXT_AREA] - wrap_row_used);
 		      *it = wrap_it;
 		      it->continuation_lines_width += wrap_x;
 		      row->used[TEXT_AREA] = wrap_row_used;
 		      row->ascent = wrap_row_ascent;
 		      row->height = wrap_row_height;
 		  else
 		    {
 		      /* Something other than a TAB that draws past
 			 the right edge of the window.  Restore
 			 positions to values before the element.  */
+		      if (row->reversed_p)
+			unproduce_glyphs (it, row->used[TEXT_AREA]
+					       - (n_glyphs_before + i));
 		      row->used[TEXT_AREA] = n_glyphs_before + i;
 		      /* Display continuation glyphs.  */
 		      if (!FRAME_WINDOW_P (it->f))
 			produce_special_glyphs (it, IT_CONTINUATION);
 	  /* Maybe add truncation glyphs.  */
 	  if (!FRAME_WINDOW_P (it->f))
 	    {
 	      int i, n;
-	      for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
+	      if (!row->reversed_p)
-		if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
+		{
-		  break;
+		  for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
+		    if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
+		      break;
+		}
+	      else
+		{
+		  for (i = 0; i < row->used[TEXT_AREA]; i++)
+		    if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
+		      break;
+		  /* Remove padding glyphs at the front of ROW, to
+		     make room for the truncation glyphs we will be
+		     adding below.  */
+		  unproduce_glyphs (it, i);
+		}
 	      for (n = row->used[TEXT_AREA]; i < n; ++i)
 		{
 		  row->used[TEXT_AREA] = i;
 		  produce_special_glyphs (it, IT_TRUNCATION);
 		  save_it.eol_pos.charpos = save_it.eol_pos.bytepos = 0;
 		}
 	      *it = save_it;
 	    }
 	  else if (!row->continued_p
-		   && row->continuation_lines_width
+		   && MATRIX_ROW_CONTINUATION_LINE_P (row)
 		   && it->eol_pos.charpos > 0)
 	    {
 	      /* Last row of a continued line.  Use the position
 		 recorded in ROW->eol_pos, to the effect that the
 		 newline belongs to this row, not to the row which
 xassert (it->glyph_row);
 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 if (glyph < it->glyph_row->glyphs[area + 1])
 {
+/* If the glyph row is reversed, we need to prepend the glyph
+	 rather than append it.  */
+if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
+	{
+	  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];
+	}
 glyph->charpos = CHARPOS (it->position);
 glyph->object = it->object;
 glyph->pixel_width = it->pixel_width;
 glyph->ascent = it->ascent;
 glyph->descent = it->descent;
 xassert (ascent >= 0 && ascent <= height);
 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 if (glyph < it->glyph_row->glyphs[area + 1])
 {
+/* If the glyph row is reversed, we need to prepend the glyph
+	 rather than append it.  */
+if (it->glyph_row->reversed_p && area == TEXT_AREA)
+	{
+	  struct glyph *g;
+	  /* Make room for the additional glyph.  */
+	  for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
+	    g[1] = *g;
+	  glyph = it->glyph_row->glyphs[area];
+	}
 glyph->charpos = CHARPOS (it->position);
 glyph->object = object;
 glyph->pixel_width = width;
 glyph->ascent = ascent;
 glyph->descent = height - ascent;
 	{
 	  glyph->resolved_level = it->bidi_it.resolved_level;
 	  if ((it->bidi_it.type & 7) != it->bidi_it.type)
 	    abort ();
 	  glyph->bidi_type = it->bidi_it.type;
+	}
+else
+	{
+	  glyph->resolved_level = 0;
+	  glyph->bidi_type = UNKNOWN_BT;
 	}
 ++it->glyph_row->used[area];
 }
 else
 IT_EXPAND_MATRIX_WIDTH (it, area);
 return;
 if (row->cursor_in_fringe_p)
 {
 row->cursor_in_fringe_p = 0;
-draw_fringe_bitmap (w, row, 0);
+draw_fringe_bitmap (w, row, row->reversed_p);
 w->phys_cursor_on_p = 0;
 return;
 }
 cx0 = w->phys_cursor.x;
 enum draw_glyphs_face hl;
 {
 /* If cursor hpos is out of bounds, don't draw garbage.  This can
 happen in mini-buffer windows when switching between echo area
 glyphs and mini-buffer.  */
-if (w->phys_cursor.hpos < row->used[TEXT_AREA])
+if ((row->reversed_p
+? (w->phys_cursor.hpos >= 0)
+: (w->phys_cursor.hpos < row->used[TEXT_AREA])))
 {
 int on_p = w->phys_cursor_on_p;
 int x1;
 x1 = draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
 			w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
 /* If cursor is in the fringe, erase by drawing actual bitmap there.  */
 if (cursor_row->cursor_in_fringe_p)
 {
 cursor_row->cursor_in_fringe_p = 0;
-draw_fringe_bitmap (w, cursor_row, 0);
+draw_fringe_bitmap (w, cursor_row, cursor_row->reversed_p);
 goto mark_cursor_off;
 }
 /* This can happen when the new row is shorter than the old one.
 In this case, either draw_glyphs or clear_end_of_line
 should have cleared the cursor.  Note that we wouldn't be
 able to erase the cursor in this case because we don't have a
 cursor glyph at hand.  */
-if (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])
+if ((cursor_row->reversed_p
+? (w->phys_cursor.hpos < 0)
+: (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])))
 goto mark_cursor_off;
 /* If the cursor is in the mouse face area, redisplay that when
 we clear the cursor.  */
 if (! NILP (dpyinfo->mouse_face_window)
 	  || (vpos == dpyinfo->mouse_face_end_row
 	      && hpos < dpyinfo->mouse_face_end_col))
 /* Don't redraw the cursor's spot in mouse face if it is at the
 	 end of a line (on a newline).  The cursor appears there, but
 	 mouse highlighting does not.  */
-&& cursor_row->used[TEXT_AREA] > hpos)
+&& cursor_row->used[TEXT_AREA] > hpos && hpos >= 0)
 mouse_face_here_p = 1;
 /* Maybe clear the display under the cursor.  */
 if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
 {
 return;
 }
 glyph = NULL;
 if (!glyph_row->exact_window_width_line_p
-|| hpos < glyph_row->used[TEXT_AREA])
+|| (0 <= hpos && hpos < glyph_row->used[TEXT_AREA]))
 glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
 xassert (interrupt_input_blocked);
 /* Set new_cursor_type to the cursor we want to be displayed.  */

Mercurial > emacs

comparison src/xdisp.c @ 107998:531d454c3a99