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

7 files changed, 221 insertions, 63 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 53f0d8722a8..e9a38a7d64c 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,53 @@
+2005-01-24  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (move_it_by_lines): If we move forward after going too
+        far back, cancel move if end position is same as start position.
+
+2005-01-24  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * dispextern.h (struct glyph_string): New members clip_head and
+        clip_tail.
+
+        * xdisp.c (get_glyph_string_clip_rect): Restrict horizontal clip
+        region to the area between clip_head and clip_tail.
+        (draw_glyphs): Record the area that need to be actually redrawn to
+        the new variables clip_head and clip_tail when there are
+        overhangs.  Set values of these variables to the corresponding
+        members in struct glyph_string.  Refine x coordinates for
+        notice_overwritten_cursor using clip_head and clip_tail.
+
+        * macgui.h (STORE_XCHARSETSTRUCT): New macro.
+
+        * macterm.c (mac_compute_glyph_string_overhangs): Implement with
+        QDTextBounds.
+        (x_draw_glyph_string): Don't fill the background of the successor
+        of a glyph with a right overhang if the successor will draw a cursor.
+        (XLoadQueryFont): Obtain font metrics using QDTextBounds.
+        (x_redisplay_interface): Add entry for compute_glyph_string_overhangs.
+
+2005-01-24  Kim F. Storm  <storm@cua.dk>
+
+        * window.c (window_scroll_pixel_based): Fix scrolling in the wrong
+        direction if window height was smaller than next-screen-context-lines.
+        Now always scroll at least one line in the requested direction.
+        Ensure that we actually do scroll backwards when requested to do so.
+
+        * xdisp.c (redisplay_window): Only try to make cursor line fully
+        visible once (to avoid redisplay loop).
+
+2005-01-23  Kim F. Storm  <storm@cua.dk>
+
+        * window.c (Fpos_visible_in_window_p): Simplify return value for
+        partially visible rows.
+        (window_scroll_pixel_based): Adapt to that change.
+
+        * window.c (window_scroll_pixel_based): Force moving to next line
+        if scrolling doesn't move start point, e.g. if looking at tall image.
+
+        * xdisp.c (pos_visible_p): Return 0 if non-interactive.
+        Clear last_height before calling line_bottom_y to get real height.
+        Fix calculation of y.
+
 2005-01-22  Steven Tamm  <steventamm@mac.com>
 
         * s/darwin.h: Removed PTY_ITERATION from here.
diff --git a/src/dispextern.h b/src/dispextern.h
index 8a24551260d..ac56cdd31f2 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1193,6 +1193,11 @@ struct glyph_string
   /* Slice */
   struct glyph_slice slice;
 
+  /* Non-null means the horizontal clipping region starts from the
+     left edge of *clip_head, and ends with the right edge of
+     *clip_tail, not including their overhangs.  */
+  struct glyph_string *clip_head, *clip_tail;
+
   struct glyph_string *next, *prev;
 };
 
diff --git a/src/indent.c b/src/indent.c
index 1d69d346f92..8b8bf924a94 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1,6 +1,6 @@
 /* Indentation functions.
-   Copyright (C) 1985,86,87,88,93,94,95,98,2000,01,02,03,2004
-   Free Software Foundation, Inc.
+   Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1998, 2000, 2001,
+     2002, 2003, 2004, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -340,7 +340,9 @@ will have a variable width)
 Ignores finite width of frame, which means that this function may return
 values greater than (frame-width).
 Whether the line is visible (if `selective-display' is t) has no effect;
-however, ^M is treated as end of line when `selective-display' is t.  */)
+however, ^M is treated as end of line when `selective-display' is t.
+Text that has an invisible property is considered as having width 0, unless
+`buffer-invisibility-spec' specifies that it is replaced by an ellipsis.  */)
      ()
 {
   Lisp_Object temp;
diff --git a/src/macgui.h b/src/macgui.h
index 1e1447dfaa8..cb157bb8c25 100644
--- a/src/macgui.h
+++ b/src/macgui.h
@@ -92,6 +92,13 @@ typedef struct _XCharStruct
   int descent;
 } XCharStruct;
 
+#define STORE_XCHARSTRUCT(xcs, w, bds)                  \
+  ((xcs).width = (w),                                   \
+   (xcs).lbearing = (bds).left,                         \
+   (xcs).rbearing = (bds).right,                        \
+   (xcs).ascent = -(bds).top,                           \
+   (xcs).descent = (bds).bottom)
+
 struct MacFontStruct {
   char *fontname;
 
diff --git a/src/macterm.c b/src/macterm.c
index d083252d90c..9a1ee834ce5 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -1997,20 +1997,33 @@ static void
 mac_compute_glyph_string_overhangs (s)
      struct glyph_string *s;
 {
-#if 0
-  /* MAC_TODO: XTextExtents16 does nothing yet... */
+  Rect r;
+  MacFontStruct *font = s->font;
+
+  TextFont (font->mac_fontnum);
+  TextSize (font->mac_fontsize);
+  TextFace (font->mac_fontface);
 
-  if (s->cmp == NULL
-      && s->first_glyph->type == CHAR_GLYPH)
+  if (s->two_byte_p)
+    QDTextBounds (s->nchars * 2, (char *)s->char2b, &r);
+  else
     {
-      XCharStruct cs;
-      int direction, font_ascent, font_descent;
-      XTextExtents16 (s->font, s->char2b, s->nchars, &direction,
-                      &font_ascent, &font_descent, &cs);
-      s->right_overhang = cs.rbearing > cs.width ? cs.rbearing - cs.width : 0;
-      s->left_overhang = cs.lbearing < 0 ? -cs.lbearing : 0;
+      int i;
+      char *buf = xmalloc (s->nchars);
+
+      if (buf == NULL)
+        SetRect (&r, 0, 0, 0, 0);
+      else
+        {
+          for (i = 0; i < s->nchars; ++i)
+            buf[i] = s->char2b[i].byte2;
+          QDTextBounds (s->nchars, buf, &r);
+          xfree (buf);
+        }
     }
-#endif
+
+  s->right_overhang = r.right > s->width ? r.right - s->width : 0;
+  s->left_overhang = r.left < 0 ? -r.left : 0;
 }
 
 
@@ -3078,10 +3091,12 @@ x_draw_glyph_string (s)
 {
   int relief_drawn_p = 0;
 
-  /* If S draws into the background of its successor, draw the
-     background of the successor first so that S can draw into it.
-     This makes S->next use XDrawString instead of XDrawImageString.  */
-  if (s->next && s->right_overhang && !s->for_overlaps_p)
+  /* If S draws into the background of its successor that does not
+     draw a cursor, draw the background of the successor first so that
+     S can draw into it.  This makes S->next use XDrawString instead
+     of XDrawImageString.  */
+  if (s->next && s->right_overhang && !s->for_overlaps_p
+      && s->next->hl != DRAW_CURSOR)
     {
       xassert (s->next->img == NULL);
       x_set_glyph_string_gc (s->next);
@@ -6780,30 +6795,40 @@ XLoadQueryFont (Display *dpy, char *fontname)
        returns 15 for 12-point Monaco! */
     char_width = CharWidth ('m');
 
-  font->max_bounds.rbearing = char_width;
-  font->max_bounds.lbearing = 0;
-  font->max_bounds.width = char_width;
-  font->max_bounds.ascent = the_fontinfo.ascent;
-  font->max_bounds.descent = the_fontinfo.descent;
+  if (is_two_byte_font)
+    {
+      font->per_char = NULL;
 
-  font->min_bounds = font->max_bounds;
+      if (fontface & italic)
+        font->max_bounds.rbearing = char_width + 1;
+      else
+        font->max_bounds.rbearing = char_width;
+      font->max_bounds.lbearing = 0;
+      font->max_bounds.width = char_width;
+      font->max_bounds.ascent = the_fontinfo.ascent;
+      font->max_bounds.descent = the_fontinfo.descent;
 
-  if (is_two_byte_font || CharWidth ('m') == CharWidth ('i'))
-    font->per_char = NULL;
+      font->min_bounds = font->max_bounds;
+    }
   else
     {
       font->per_char = (XCharStruct *)
         xmalloc (sizeof (XCharStruct) * (0xff - 0x20 + 1));
       {
-        int c, min_width, max_width;
+        int c, min_width, max_width;
+        Rect char_bounds, min_bounds, max_bounds;
+        char ch;
 
         min_width = max_width = char_width;
+        SetRect (&min_bounds, -32767, -32767, 32767, 32767);
+        SetRect (&max_bounds, 0, 0, 0, 0);
         for (c = 0x20; c <= 0xff; c++)
           {
-            font->per_char[c - 0x20] = font->max_bounds;
-            char_width = CharWidth (c);
-            font->per_char[c - 0x20].width = char_width;
-            font->per_char[c - 0x20].rbearing = char_width;
+            ch = c;
+            char_width = CharWidth (ch);
+            QDTextBounds (1, &ch, &char_bounds);
+            STORE_XCHARSTRUCT (font->per_char[c - 0x20],
+                               char_width, char_bounds);
             /* Some Japanese fonts (in SJIS encoding) return 0 as the
                character width of 0x7f.  */
             if (char_width > 0)
@@ -6811,9 +6836,25 @@ XLoadQueryFont (Display *dpy, char *fontname)
                 min_width = min (min_width, char_width);
                 max_width = max (max_width, char_width);
               }
-            }
-        font->min_bounds.width = min_width;
-        font->max_bounds.width = max_width;
+            if (!EmptyRect (&char_bounds))
+              {
+                SetRect (&min_bounds,
+                         max (min_bounds.left, char_bounds.left),
+                         max (min_bounds.top, char_bounds.top),
+                         min (min_bounds.right, char_bounds.right),
+                         min (min_bounds.bottom, char_bounds.bottom));
+                UnionRect (&max_bounds, &char_bounds, &max_bounds);
+              }
+          }
+        STORE_XCHARSTRUCT (font->min_bounds, min_width, min_bounds);
+        STORE_XCHARSTRUCT (font->max_bounds, max_width, max_bounds);
+        if (min_width == max_width
+            && max_bounds.left >= 0 && max_bounds.right <= max_width)
+          {
+            /* Fixed width and no overhangs.  */
+            xfree (font->per_char);
+            font->per_char = NULL;
+          }
       }
     }
 
@@ -9719,7 +9760,7 @@ static struct redisplay_interface x_redisplay_interface =
   0, /* destroy_fringe_bitmap */
   mac_per_char_metric,
   mac_encode_char,
-  NULL, /* mac_compute_glyph_string_overhangs */
+  mac_compute_glyph_string_overhangs,
   x_draw_glyph_string,
   mac_define_frame_cursor,
   mac_clear_frame_area,
diff --git a/src/window.c b/src/window.c
index 9b8a031f6c1..370251882ba 100644
--- a/src/window.c
+++ b/src/window.c
@@ -333,11 +333,10 @@ If POS is only out of view because of horizontal scrolling, return non-nil.
 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
 
 If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
-return value is a list (X Y FULLY [RTOP RBOT]) where X and Y are the pixel
-coordinates relative to the top left corner of the window, and FULLY is t if the
-character after POS is fully visible and nil otherwise.  If FULLY is nil,
-RTOP and RBOT are the number of pixels invisible at the top and bottom row
-of the window.  */)
+return value is a list (X Y PARTIAL) where X and Y are the pixel coordinates
+relative to the top left corner of the window. PARTIAL is nil if the character
+after POS is fully visible; otherwise it is a cons (RTOP . RBOT) where RTOP
+and RBOT are the number of pixels invisible at the top and bottom of the row.  */)
      (pos, window, partially)
      Lisp_Object pos, window, partially;
 {
@@ -376,12 +375,10 @@ of the window.  */)
   if (!NILP (in_window) && !NILP (partially))
     in_window = Fcons (make_number (x),
                        Fcons (make_number (y),
-                              Fcons (fully_p ? Qt : Qnil,
-                                     (fully_p
-                                      ? Qnil
-                                      : Fcons (make_number (rtop),
-                                               Fcons (make_number (rbot),
-                                                      Qnil))))));
+                              Fcons ((fully_p ? Qnil
+                                     : Fcons (make_number (rtop),
+                                              make_number (rbot))),
+                                     Qnil)));
   return in_window;
 }
 
@@ -4578,21 +4575,23 @@ window_scroll_pixel_based (window, n, whole, noerror)
     }
   else if (auto_window_vscroll_p)
     {
-      if (NILP (XCAR (XCDR (XCDR (tem)))))
+      if (tem = XCAR (XCDR (XCDR (tem))), CONSP (tem))
         {
           int px;
           int dy = WINDOW_FRAME_LINE_HEIGHT (w);
           if (whole)
-            dy = window_box_height (w) - next_screen_context_lines * dy;
+            dy = max ((window_box_height (w)
+                       - next_screen_context_lines * dy),
+                      dy);
           dy *= n;
 
-          if (n < 0 && (px = XINT (Fnth (make_number (3), tem))) > 0)
+          if (n < 0 && (px = XINT (XCAR (tem))) > 0)
             {
               px = max (0, -w->vscroll - min (px, -dy));
               Fset_window_vscroll (window, make_number (px), Qt);
               return;
             }
-          if (n > 0 && (px = XINT (Fnth (make_number (4), tem))) > 0)
+          if (n > 0 && (px = XINT (XCDR (tem))) > 0)
             {
               px = max (0, -w->vscroll + min (px, dy));
               Fset_window_vscroll (window, make_number (px), Qt);
@@ -4618,18 +4617,34 @@ window_scroll_pixel_based (window, n, whole, noerror)
   start_display (&it, w, start);
   if (whole)
     {
-      int screen_full = (window_box_height (w)
-                         - next_screen_context_lines * FRAME_LINE_HEIGHT (it.f));
-      int dy = n * screen_full;
+      int start_pos = IT_CHARPOS (it);
+      int dy = WINDOW_FRAME_LINE_HEIGHT (w);
+      dy = max ((window_box_height (w)
+                 - next_screen_context_lines * dy),
+                dy) * n;
 
       /* Note that move_it_vertically always moves the iterator to the
          start of a line.  So, if the last line doesn't have a newline,
          we would end up at the start of the line ending at ZV.  */
       if (dy <= 0)
-        move_it_vertically_backward (&it, -dy);
+        {
+          move_it_vertically_backward (&it, -dy);
+          /* Ensure we actually does move, e.g. in case we are currently
+             looking at an image that is taller that the window height.  */
+          while (start_pos == IT_CHARPOS (it)
+                 && start_pos > BEGV)
+            move_it_by_lines (&it, -1, 1);
+        }
       else if (dy > 0)
-        move_it_to (&it, ZV, -1, it.current_y + dy, -1,
-                    MOVE_TO_POS | MOVE_TO_Y);
+        {
+          move_it_to (&it, ZV, -1, it.current_y + dy, -1,
+                      MOVE_TO_POS | MOVE_TO_Y);
+          /* Ensure we actually does move, e.g. in case we are currently
+             looking at an image that is taller that the window height.  */
+          while (start_pos == IT_CHARPOS (it)
+                 && start_pos < ZV)
+            move_it_by_lines (&it, 1, 1);
+        }
     }
   else
     move_it_by_lines (&it, n, 1);
diff --git a/src/xdisp.c b/src/xdisp.c
index 6a59de7ef8d..a8f36e04e38 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1259,16 +1259,18 @@ pos_visible_p (w, 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.  */
@@ -1293,7 +1295,7 @@ pos_visible_p (w, charpos, x, y, rtop, rbot, exact_mode_line_heights_p)
   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)
@@ -1303,7 +1305,7 @@ pos_visible_p (w, charpos, x, y, rtop, rbot, exact_mode_line_heights_p)
       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);
@@ -1787,6 +1789,24 @@ get_glyph_string_clip_rect (s, nr)
       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.  */
@@ -6505,11 +6525,15 @@ move_it_by_lines (it, dvpos, need_y_p)
       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;
         }
     }
 }
@@ -12332,6 +12356,8 @@ redisplay_window (window, just_this_one_p)
       /* 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;
@@ -18338,6 +18364,7 @@ draw_glyphs (w, x, row, area, start, end, hl, 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;
@@ -18406,6 +18433,7 @@ draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
           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
@@ -18418,6 +18446,7 @@ draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
       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)
@@ -18437,6 +18466,7 @@ draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
                                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
@@ -18447,6 +18477,7 @@ draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
       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)
@@ -18454,6 +18485,12 @@ draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
           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.  */
@@ -18467,8 +18504,9 @@ draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
          completely. */
       && !overlaps_p)
     {
-      int x0 = head ? head->x : x;
-      int x1 = tail ? tail->x + tail->background_width : x;
+      int x0 = clip_head ? clip_head->x : (head ? head->x : 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;