Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 423-426)

   - Update from CVS
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 131-133)

   - Update from CVS

Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-109

5 files changed, 126 insertions, 47 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 64b3b884bfa..a1194906fbb 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,29 @@
+2006-09-06  Kenichi Handa  <handa@m17n.org>
+
+        * editfns.c (Fformat_time_string): Use make_unibyte_string to make
+        a Lisp string from the result of emacs_memftimeu call.
+
+2006-09-06  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (pos_visible_p): Remove exact_mode_line_heights_p arg;
+        so always calculate heights even when pos-visible-in-window-p is
+        called with partially = t.  Don't overshoot last_visible_y in move_it_to.
+        Return row height and row number in new rowh and vpos args.
+        (cursor_row_fully_visible_p): First line is always "fully visible".
+        (try_window): Don't clear matrix if vscrolled.
+
+        * lisp.h (pos_visible_p): Update prototype.
+
+        * window.c (Fpos_visible_in_window_p): Adapt to new pos_visible_p.
+        Return row height and row number for partially visible rows.
+        Modify return value to a 2 element list for fully visible rows
+        and 6 for partially visible row.
+        (window_scroll_pixel_based): Use pos_visible_p directly instead of
+        Fpos_visible_in_window_p.  Fix auto vscrolling for partially visible lines.
+        Only vscroll backwards if already vscrolled forwards.  Unconditionally
+        vscroll forwards if PT is first (and only) line.  Set new window start
+        instead of scrolling at start/end of tall line.
+
 2006-09-05  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
 
         * macterm.c (install_window_handler, mac_handle_window_event)
diff --git a/src/editfns.c b/src/editfns.c
index 2fcacc16901..10c5cbe1153 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1692,7 +1692,7 @@ For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".  */)
                                 SBYTES (format_string),
                                 tm, ut);
       if ((result > 0 && result < size) || (result == 0 && buf[0] == '\0'))
-        return code_convert_string_norecord (make_string (buf, result),
+        return code_convert_string_norecord (make_unibyte_string (buf, result),
                                              Vlocale_coding_system, 0);
 
       /* If buffer was too small, make it bigger and try again.  */
diff --git a/src/lisp.h b/src/lisp.h
index 7c6826d7bda..4421dfedf95 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2551,7 +2551,7 @@ extern void syms_of_xdisp P_ ((void));
 extern void init_xdisp P_ ((void));
 extern Lisp_Object safe_eval P_ ((Lisp_Object));
 extern int pos_visible_p P_ ((struct window *, int, int *,
-                              int *, int *, int *, int));
+                              int *, int *, int *, int *, int *));
 
 /* Defined in vm-limit.c.  */
 extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
diff --git a/src/window.c b/src/window.c
index 7f3e71ec145..4208323eab3 100644
--- a/src/window.c
+++ b/src/window.c
@@ -336,10 +336,12 @@ 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 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.  */)
+return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
+where X and Y are the pixel coordinates relative to the top left corner
+of the window.  The remaining elements are omitted if the character after
+POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
+invisible at the top and bottom of the row, ROWH is the height of the display
+row, and VPOS is the row number (0-based) containing POS.  */)
      (pos, window, partially)
      Lisp_Object pos, window, partially;
 {
@@ -348,7 +350,7 @@ and RBOT are the number of pixels invisible at the top and bottom of the row.  *
   register struct buffer *buf;
   struct text_pos top;
   Lisp_Object in_window = Qnil;
-  int rtop, rbot, fully_p = 1;
+  int rtop, rbot, rowh, vpos, fully_p = 1;
   int x, y;
 
   w = decode_window (window);
@@ -371,17 +373,20 @@ and RBOT are the number of pixels invisible at the top and bottom of the row.  *
       && posint <= BUF_ZV (buf)
       && CHARPOS (top) >= BUF_BEGV (buf)
       && CHARPOS (top) <= BUF_ZV (buf)
-      && pos_visible_p (w, posint, &x, &y, &rtop, &rbot, NILP (partially))
+      && pos_visible_p (w, posint, &x, &y, &rtop, &rbot, &rowh, &vpos)
       && (fully_p = !rtop && !rbot, (!NILP (partially) || fully_p)))
     in_window = Qt;
 
   if (!NILP (in_window) && !NILP (partially))
-    in_window = Fcons (make_number (x),
-                       Fcons (make_number (y),
-                              Fcons ((fully_p ? Qnil
-                                     : Fcons (make_number (rtop),
-                                              make_number (rbot))),
-                                     Qnil)));
+    {
+      Lisp_Object part = Qnil;
+      if (!fully_p)
+        part = list4 (make_number (rtop), make_number (rbot),
+                        make_number (rowh), make_number (vpos));
+      in_window = Fcons (make_number (x),
+                         Fcons (make_number (y), part));
+    }
+
   return in_window;
 }
 
@@ -4818,10 +4823,10 @@ window_scroll_pixel_based (window, n, whole, noerror)
   struct it it;
   struct window *w = XWINDOW (window);
   struct text_pos start;
-  Lisp_Object tem;
   int this_scroll_margin;
   /* True if we fiddled the window vscroll field without really scrolling.   */
   int vscrolled = 0;
+  int x, y, rtop, rbot, rowh, vpos;
 
   SET_TEXT_POS_FROM_MARKER (start, w->start);
 
@@ -4829,8 +4834,8 @@ window_scroll_pixel_based (window, n, whole, noerror)
      the screen.  Allow PT to be partially visible, otherwise
      something like (scroll-down 1) with PT in the line before
      the partially visible one would recenter. */
-  tem = Fpos_visible_in_window_p (make_number (PT), window, Qt);
-  if (NILP (tem))
+
+  if (!pos_visible_p (w, PT, &x, &y, &rtop, &rbot, &rowh, &vpos))
     {
       /* Move backward half the height of the window.  Performance note:
          vmotion used here is about 10% faster, but would give wrong
@@ -4855,7 +4860,7 @@ window_scroll_pixel_based (window, n, whole, noerror)
     }
   else if (auto_window_vscroll_p)
     {
-      if (tem = XCAR (XCDR (XCDR (tem))), CONSP (tem))
+      if (rtop || rbot)         /* partially visible */
         {
           int px;
           int dy = WINDOW_FRAME_LINE_HEIGHT (w);
@@ -4865,19 +4870,52 @@ window_scroll_pixel_based (window, n, whole, noerror)
                       dy);
           dy *= n;
 
-          if (n < 0 && (px = XINT (XCAR (tem))) > 0)
+          if (n < 0)
             {
-              px = max (0, -w->vscroll - min (px, -dy));
-              Fset_window_vscroll (window, make_number (px), Qt);
-              return;
+              /* Only vscroll backwards if already vscrolled forwards.  */
+              if (w->vscroll < 0 && rtop > 0)
+                {
+                  px = max (0, -w->vscroll - min (rtop, -dy));
+                  Fset_window_vscroll (window, make_number (px), Qt);
+                  return;
+                }
             }
-          if (n > 0 && (px = XINT (XCDR (tem))) > 0)
+          if (n > 0)
             {
-              px = max (0, -w->vscroll + min (px, dy));
-              Fset_window_vscroll (window, make_number (px), Qt);
-              return;
+              /* Do vscroll if already vscrolled or only display line.  */
+              if (rbot > 0 && (w->vscroll < 0 || vpos == 0))
+                {
+                  px = max (0, -w->vscroll + min (rbot, dy));
+                  Fset_window_vscroll (window, make_number (px), Qt);
+                  return;
+                }
+
+              /* Maybe modify window start instead of scrolling.  */
+              if (rbot > 0 || w->vscroll < 0)
+                {
+                  int spos;
+
+                  Fset_window_vscroll (window, make_number (0), Qt);
+                  /* If there are other text lines above the current row,
+                     move window start to current row.  Else to next row. */
+                  if (rbot > 0)
+                    spos = XINT (Fline_beginning_position (Qnil));
+                  else
+                    spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
+                  set_marker_restricted (w->start, make_number (spos),
+                                         w->buffer);
+                  w->start_at_line_beg = Qt;
+                  w->update_mode_line = Qt;
+                  XSETFASTINT (w->last_modified, 0);
+                  XSETFASTINT (w->last_overlay_modified, 0);
+                  /* Set force_start so that redisplay_window will run the
+                     window-scroll-functions.  */
+                  w->force_start = Qt;
+                  return;
+                }
             }
         }
+      /* Cancel previous vscroll.  */
       Fset_window_vscroll (window, make_number (0), Qt);
     }
 
@@ -4918,7 +4956,7 @@ window_scroll_pixel_based (window, n, whole, noerror)
       if (dy <= 0)
         {
           move_it_vertically_backward (&it, -dy);
-          /* Ensure we actually does move, e.g. in case we are currently
+          /* Ensure we actually do 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)
@@ -4928,7 +4966,7 @@ window_scroll_pixel_based (window, n, whole, noerror)
         {
           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
+          /* Ensure we actually do 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)
@@ -6656,7 +6694,7 @@ display marginal areas and the text area.  */)
     CHECK_NATNUM (left_width);
   if (!NILP (right_width))
     CHECK_NATNUM (right_width);
- 
+
   /* Do nothing on a tty.  */
   if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
       && (!EQ (w->left_fringe_width, left_width)
diff --git a/src/xdisp.c b/src/xdisp.c
index 0e60020f110..f26a4231e9d 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1281,13 +1281,12 @@ line_bottom_y (it)
 /* Return 1 if position CHARPOS is visible in window W.
    If visible, set *X and *Y to pixel coordinates of top left corner.
    Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
-   EXACT_MODE_LINE_HEIGHTS_P non-zero means compute exact mode-line
-   and header-lines heights.  */
+   Set *ROWH and *VPOS to row's visible height and VPOS (row number).  */
 
 int
-pos_visible_p (w, charpos, x, y, rtop, rbot, exact_mode_line_heights_p)
+pos_visible_p (w, charpos, x, y, rtop, rbot, rowh, vpos)
      struct window *w;
-     int charpos, *x, *y, *rtop, *rbot, exact_mode_line_heights_p;
+     int charpos, *x, *y, *rtop, *rbot, *rowh, *vpos;
 {
   struct it it;
   struct text_pos top;
@@ -1305,22 +1304,19 @@ pos_visible_p (w, charpos, x, y, rtop, rbot, exact_mode_line_heights_p)
 
   SET_TEXT_POS_FROM_MARKER (top, w->start);
 
-  /* Compute exact mode line heights, if requested.  */
-  if (exact_mode_line_heights_p)
-    {
-      if (WINDOW_WANTS_MODELINE_P (w))
-        current_mode_line_height
-          = display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
-                               current_buffer->mode_line_format);
+  /* Compute exact mode line heights.  */
+  if (WINDOW_WANTS_MODELINE_P (w))
+    current_mode_line_height
+      = display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
+                           current_buffer->mode_line_format);
 
-      if (WINDOW_WANTS_HEADER_LINE_P (w))
-        current_header_line_height
-          = display_mode_line (w, HEADER_LINE_FACE_ID,
+  if (WINDOW_WANTS_HEADER_LINE_P (w))
+    current_header_line_height
+      = display_mode_line (w, HEADER_LINE_FACE_ID,
                                current_buffer->header_line_format);
-    }
 
   start_display (&it, w, top);
-  move_it_to (&it, charpos, -1, it.last_visible_y, -1,
+  move_it_to (&it, charpos, -1, it.last_visible_y-1, -1,
               MOVE_TO_POS | MOVE_TO_Y);
 
   /* Note that we may overshoot because of invisible text.  */
@@ -1341,6 +1337,9 @@ pos_visible_p (w, charpos, x, y, rtop, rbot, exact_mode_line_heights_p)
           *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
           *rtop = max (0, window_top_y - top_y);
           *rbot = max (0, bottom_y - it.last_visible_y);
+          *rowh = max (0, (min (bottom_y, it.last_visible_y)
+                           - max (top_y, window_top_y)));
+          *vpos = it.vpos;
         }
     }
   else
@@ -1359,6 +1358,11 @@ pos_visible_p (w, charpos, x, y, rtop, rbot, exact_mode_line_heights_p)
           *rtop = max (0, -it2.current_y);
           *rbot = max (0, ((it2.current_y + it2.max_ascent + it2.max_descent)
                            - it.last_visible_y));
+          *rowh = max (0, (min (it2.current_y + it2.max_ascent + it2.max_descent,
+                                it.last_visible_y)
+                           - max (it2.current_y,
+                                  WINDOW_HEADER_LINE_HEIGHT (w))));
+          *vpos = it2.vpos;
         }
     }
 
@@ -1370,6 +1374,15 @@ pos_visible_p (w, charpos, x, y, rtop, rbot, exact_mode_line_heights_p)
   if (visible_p && XFASTINT (w->hscroll) > 0)
     *x -= XFASTINT (w->hscroll) * WINDOW_FRAME_COLUMN_WIDTH (w);
 
+#if 0
+  /* Debugging code.  */
+  if (visible_p)
+    fprintf (stderr, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
+             charpos, w->vscroll, *x, *y, *rtop, *rbot, *rowh, *vpos);
+  else
+    fprintf (stderr, "-pv pt=%d vs=%d\n", charpos, w->vscroll);
+#endif
+
   return visible_p;
 }
 
@@ -12166,7 +12179,8 @@ cursor_row_fully_visible_p (w, force_p, current_matrix_p)
   window_height = window_box_height (w);
   if (row->height >= window_height)
     {
-      if (!force_p || MINI_WINDOW_P (w) || w->vscroll)
+      if (!force_p || MINI_WINDOW_P (w)
+          || w->vscroll || w->cursor.vpos == 0)
         return 1;
     }
   return 0;
@@ -13650,7 +13664,8 @@ try_window (window, pos, check_margins)
       this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
       this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
 
-      if ((w->cursor.y < this_scroll_margin
+      if ((w->cursor.y >= 0     /* not vscrolled */
+           && w->cursor.y < this_scroll_margin
            && CHARPOS (pos) > BEGV
            && IT_CHARPOS (it) < ZV)
           /* rms: considering make_cursor_line_fully_visible_p here