shr.el (shr-insert): Revert last change.

shr.el (shr-find-fill-point): Never leave point being at bol; relax the kinsoku limitation when rendering tables.

diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 2a4b97bd8d2cb5f88b3246a58527103ac7eb95a9..01e9d74a5818b5826aa43fced3a8f72a971083ee 100644 (file)
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,9 @@
+2010-11-26  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+       * shr.el (shr-insert): Revert last change.
+       (shr-find-fill-point): Never leave point being at bol;
+       relax the kinsoku limitation when rendering tables.
+
 2010-11-26  Lars Magne Ingebrigtsen  <larsi@gnus.org>
 
        * nnmail.el (nnmail-expiry-target-group): Protect against degenerate

diff --git a/lisp/gnus/shr.el b/lisp/gnus/shr.el
index 1746c9aee4b01a723cefb9400621370618840dbf..69973fbfb5028b90c476eafe165e66d9f80415ba 100644 (file)
--- a/lisp/gnus/shr.el
+++ b/lisp/gnus/shr.el
@@ -254,7 +254,7 @@ redirects somewhere else."
        (while (and (> (current-column) shr-width)
                    (progn
                      (setq found (shr-find-fill-point))
-                     (not (or (bolp) (eolp)))))
+                     (not (eolp))))
          (when (eq (preceding-char) ? )
            (delete-char -1))
          (insert "\n")
@@ -278,7 +278,8 @@ redirects somewhere else."
            (or (setq failed (= (current-column) shr-indentation))
                (eq (preceding-char) ? )
                (eq (following-char) ? )
-               (aref fill-find-break-point-function-table (preceding-char))))
+               (aref fill-find-break-point-function-table (preceding-char))
+               (aref (char-category-set (preceding-char)) ?>)))
       (backward-char 1))
     (if failed
        ;; There's no breakable point, so we give it up.
@@ -287,30 +288,52 @@ redirects somewhere else."
          (while (aref fill-find-break-point-function-table (preceding-char))
            (backward-char 1))
          nil)
-      (or (eolp)
-         ;; Don't put kinsoku-bol characters at the beginning of a line,
-         ;; or kinsoku-eol characters at the end of a line,
-         (let ((count 4))
-           (if (or shr-kinsoku-shorten
-                   (and (aref (char-category-set (preceding-char)) ?<)
-                        (progn
-                          (setq count (1- count))
-                          (backward-char 1)
-                          t)))
-               (while (and
-                       (>= (setq count (1- count)) 0)
-                       (not (memq (preceding-char) (list ?\C-@ ?\n ? )))
-                       (or (aref (char-category-set (preceding-char)) ?<)
-                           (aref (char-category-set (following-char)) ?>)))
-                 (backward-char 1))
-             (while (and (>= (setq count (1- count)) 0)
-                         (aref (char-category-set (following-char)) ?>)
-                         (aref fill-find-break-point-function-table
-                               (following-char)))
-               (forward-char 1)))
-           (when (eq (following-char) ? )
-             (forward-char 1))
-           t)))))
+      (or
+       (eolp)
+       (progn
+        ;; Don't put kinsoku-bol characters at the beginning of a line,
+        ;; or kinsoku-eol characters at the end of a line.
+        (cond
+         (shr-kinsoku-shorten
+          (while (and
+                  (not (memq (preceding-char) (list ?\C-@ ?\n ? )))
+                  (not (or (aref (char-category-set (preceding-char)) ?>)
+                           (aref (char-category-set (following-char)) ?<)))
+                  (or (aref (char-category-set (preceding-char)) ?<)
+                      (aref (char-category-set (following-char)) ?>)))
+            (backward-char 1)))
+         ((aref (char-category-set (preceding-char)) ?<)
+          (let ((count 3))
+            (while (progn
+                     (backward-char 1)
+                     (and
+                      (> (setq count (1- count)) 0)
+                      (not (memq (preceding-char) (list ?\C-@ ?\n ? )))
+                      (or (aref (char-category-set (preceding-char)) ?<)
+                          (aref (char-category-set (following-char)) ?>))))))
+          (if (and (setq failed (= (current-column) shr-indentation))
+                   (re-search-forward "\\c|" (line-end-position) 'move))
+              ;; There's no breakable point that doesn't violate kinsoku,
+              ;; so we look for the second best position.
+              (let (bp)
+                (while (and (<= (current-column) shr-width)
+                            (progn
+                              (setq bp (point))
+                              (not (eolp)))
+                            (aref fill-find-break-point-function-table
+                                  (following-char)))
+                  (forward-char 1))
+                (goto-char (or bp (line-end-position))))))
+         (t
+          (let ((count 4))
+            (while (and (>= (setq count (1- count)) 0)
+                        (aref (char-category-set (following-char)) ?>)
+                        (aref fill-find-break-point-function-table
+                              (following-char)))
+              (forward-char 1)))))
+        (when (eq (following-char) ? )
+          (forward-char 1))
+        (not failed))))))
 
 (defun shr-ensure-newline ()
   (unless (zerop (current-column))