emacs: src/xdisp.c comparison

comparison src/xdisp.c @ 90084:befae6bafecb

Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-6 Merge from emacs--cvs-trunk--0 Patches applied: * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-48 - miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-51 Update from CVS

author	Miles Bader <miles@gnu.org>
date	Mon, 24 Jan 2005 22:34:31 +0000
parents	6d92d69fae33 4712d3f43248
children	f8a7a9ba3d08

comparison

equal deleted inserted replaced

-:2b2f720892ae
+:befae6bafecb
 struct window *w;
 int charpos, *x, *y, *rtop, *rbot, exact_mode_line_heights_p;
 {
 struct it it;
 struct text_pos top;
-int visible_p;
+int visible_p = 0;
 struct buffer *old_buffer = NULL;
+if (noninteractive)
+return visible_p;
 if (XBUFFER (w->buffer) != current_buffer)
 {
 old_buffer = current_buffer;
 set_buffer_internal_1 (XBUFFER (w->buffer));
 }
-visible_p = 0;
 SET_TEXT_POS_FROM_MARKER (top, w->start);
 /* Compute exact mode line heights, if requested.  */
 if (exact_mode_line_heights_p)
 {
 /* Note that we may overshoot because of invisible text.  */
 if (IT_CHARPOS (it) >= charpos)
 {
 int top_y = it.current_y;
-int bottom_y = line_bottom_y (&it);
+int bottom_y = (last_height = 0, line_bottom_y (&it));
 int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
 if (top_y < window_top_y)
 	visible_p = bottom_y > window_top_y;
 else if (top_y < it.last_visible_y)
 	  visible_p = 1;
 if (visible_p && x)
 	{
 	  *x = it.current_x;
-	  *y = max (top_y + it.max_ascent - it.ascent, window_top_y);
+	  *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
 	  if (rtop)
 	    {
 	      *rtop = max (0, window_top_y - top_y);
 	      *rbot = max (0, bottom_y - it.last_visible_y);
 	    }
 /* This is a text line that may be partially visible.  */
 r.x = window_box_left (s->w, s->area);
 r.width = window_box_width (s->w, s->area);
 r.height = s->row->visible_height;
 }
+if (s->clip_head)
+if (r.x < s->clip_head->x)
+{
+	if (r.width >= s->clip_head->x - r.x)
+	  r.width -= s->clip_head->x - r.x;
+	else
+	  r.width = 0;
+	r.x = s->clip_head->x;
+}
+if (s->clip_tail)
+if (r.x + r.width > s->clip_tail->x + s->clip_tail->background_width)
+{
+	if (s->clip_tail->x + s->clip_tail->background_width >= r.x)
+	  r.width = s->clip_tail->x + s->clip_tail->background_width - r.x;
+	else
+	  r.width = 0;
+}
 /* If S draws overlapping rows, it's sufficient to use the top and
 bottom of the window for clipping because this glyph string
 intentionally draws over other lines.  */
 if (s->for_overlaps_p)
 move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
 it->vpos -= it2.vpos;
 it->current_y -= it2.current_y;
 it->current_x = it->hpos = 0;
-/* If we moved too far, move IT some lines forward.  */
+/* If we moved too far back, move IT some lines forward.  */
 if (it2.vpos > -dvpos)
 	{
 	  int delta = it2.vpos + dvpos;
+	  it2 = *it;
 	  move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
+	  /* Move back again if we got too far ahead.  */
+	  if (IT_CHARPOS (*it) >= start_charpos)
+	    *it = it2;
 	}
 }
 }
 /* Return 1 if IT points into the middle of a display vector.  */
 	}
 /* If centering point failed to make the whole line visible,
 	 put point at the top instead.  That has to make the whole line
 	 visible, if it can be done.  */
+if (centering_position == 0)
+	goto done;
 clear_glyph_matrix (w->desired_matrix);
 centering_position = 0;
 goto point_at_top;
 }
 enum draw_glyphs_face hl;
 int overlaps_p;
 {
 struct glyph_string *head, *tail;
 struct glyph_string *s;
+struct glyph_string *clip_head = NULL, *clip_tail = NULL;
 int last_x, area_width;
 int x_reached;
 int i, j;
 struct frame *f = XFRAME (WINDOW_FRAME (w));
 DECLARE_HDC (hdc);
 	  BUILD_GLYPH_STRINGS (j, start, h, t,
 			       DRAW_NORMAL_TEXT, dummy_x, last_x);
 	  start = i;
 	  compute_overhangs_and_x (t, head->x, 1);
 	  prepend_glyph_string_lists (&head, &tail, h, t);
+	  clip_head = head;
 	}
 /* Prepend glyph strings for glyphs in front of the first glyph
 	 string that overwrite that glyph string because of their
 	 right overhang.  For these strings, only the foreground must
 	 right overhangs of preceding glyphs for which no glyph
 	 strings exist.  */
 i = left_overwriting (head);
 if (i >= 0)
 	{
+	  clip_head = head;
 	  BUILD_GLYPH_STRINGS (i, start, h, t,
 			       DRAW_NORMAL_TEXT, dummy_x, last_x);
 	  for (s = h; s; s = s->next)
 	    s->background_filled_p = 1;
 	  compute_overhangs_and_x (t, head->x, 1);
 	{
 	  BUILD_GLYPH_STRINGS (end, i, h, t,
 			       DRAW_NORMAL_TEXT, x, last_x);
 	  compute_overhangs_and_x (h, tail->x + tail->width, 0);
 	  append_glyph_string_lists (&head, &tail, h, t);
+	  clip_tail = tail;
 	}
 /* Append glyph strings for glyphs following the last glyph
 	 string tail that overwrite tail.  The foreground of such
 	 glyphs has to be drawn because it writes into the background
 	 of tail.  The background must not be drawn because it could
 	 paint over the foreground of following glyphs.  */
 i = right_overwriting (tail);
 if (i >= 0)
 	{
+	  clip_tail = tail;
 	  BUILD_GLYPH_STRINGS (end, i, h, t,
 			       DRAW_NORMAL_TEXT, x, last_x);
 	  for (s = h; s; s = s->next)
 	    s->background_filled_p = 1;
 	  compute_overhangs_and_x (h, tail->x + tail->width, 0);
 	  append_glyph_string_lists (&head, &tail, h, t);
 	}
+if (clip_head || clip_tail)
+	for (s = head; s; s = s->next)
+	  {
+	    s->clip_head = clip_head;
+	    s->clip_tail = clip_tail;
+	  }
 }
 /* Draw all strings.  */
 for (s = head; s; s = s->next)
 rif->draw_glyph_string (s);
 /* When drawing overlapping rows, only the glyph strings'
 	 foreground is drawn, which doesn't erase a cursor
 	 completely. */
 && !overlaps_p)
 {
-int x0 = head ? head->x : x;
+int x0 = clip_head ? clip_head->x : (head ? head->x : x);
-int x1 = tail ? tail->x + tail->background_width : x;
+int x1 = (clip_tail ? clip_tail->x + clip_tail->background_width
+		: (tail ? tail->x + tail->background_width : x));
 int text_left = window_box_left (w, TEXT_AREA);
 x0 -= text_left;
 x1 -= text_left;

Mercurial > emacs

comparison src/xdisp.c @ 90084:befae6bafecb