(shr-insert): Only insert a blank line if we're starting from an image.

[gnus] / lisp / shr.el

diff --git a/lisp/shr.el b/lisp/shr.el
index 5021eab..3ca7f1c 100644 (file)
--- a/lisp/shr.el
+++ b/lisp/shr.el
@@ -333,6 +333,7 @@ size, and full-buffer size."
 
 (defun shr-insert (text)
   (when (and (eq shr-state 'image)
+            (not (bolp))
             (not (string-match "\\`[ \t\n]+\\'" text)))
     (insert "\n")
     (setq shr-state nil))
@@ -340,11 +341,11 @@ size, and full-buffer size."
    ((eq shr-folding-mode 'none)
     (insert text))
    (t
-    (when (and (string-match "\\`[ \t\n]" text)
+    (when (and (string-match "\\`[ \t\n ]" text)
               (not (bolp))
               (not (eq (char-after (1- (point))) ? )))
       (insert " "))
-    (dolist (elem (split-string text))
+    (dolist (elem (split-string text "[ \f\t\n\r\v ]+" t))
       (when (and (bolp)
                 (> shr-indentation 0))
        (shr-indent))
@@ -375,7 +376,6 @@ size, and full-buffer size."
          (when (eq (preceding-char) ? )
            (delete-char -1))
          (insert "\n")
-         (put-text-property (1- (point)) (point) 'shr-break t)
          (unless found
            ;; No space is needed at the beginning of a line.
            (when (eq (following-char) ? )
@@ -384,7 +384,7 @@ size, and full-buffer size."
            (shr-indent))
          (end-of-line))
        (insert " ")))
-    (unless (string-match "[ \t\n]\\'" text)
+    (unless (string-match "[ \t\n ]\\'" text)
       (delete-char -1)))))
 
 (defun shr-find-fill-point ()
@@ -770,7 +770,7 @@ ones, in case fg and bg are nil."
     (forward-line 1)
     (setq end (point))
     (narrow-to-region start end)
-    (let ((width (shr-natural-width))
+    (let ((width (shr-buffer-width))
          column)
       (goto-char (point-min))
       (while (not (eobp))
@@ -1043,7 +1043,7 @@ ones, in case fg and bg are nil."
     (shr-generic cont)))
 
 (defun shr-tag-br (cont)
-  (unless (bobp)
+  (unless (bolp)
     (insert "\n")
     (shr-indent))
   (shr-generic cont))
@@ -1107,7 +1107,10 @@ ones, in case fg and bg are nil."
         ;; be smaller (if there's little text) or bigger (if there's
         ;; unbreakable text).
         (sketch (shr-make-table cont suggested-widths))
-        (sketch-widths (shr-table-widths sketch suggested-widths)))
+        ;; Compute the "natural" width by setting each column to 500
+        ;; characters and see how wide they really render.
+        (natural (shr-make-table cont (make-vector (length columns) 500)))
+        (sketch-widths (shr-table-widths sketch natural suggested-widths)))
     ;; This probably won't work very well.
     (when (> (+ (loop for width across sketch-widths
                      summing (1+ width))
@@ -1245,38 +1248,37 @@ ones, in case fg and bg are nil."
            shr-table-corner))
   (insert "\n"))
 
-(defun shr-table-widths (table suggested-widths)
+(defun shr-table-widths (table natural-table suggested-widths)
   (let* ((length (length suggested-widths))
         (widths (make-vector length 0))
         (natural-widths (make-vector length 0)))
     (dolist (row table)
       (let ((i 0))
        (dolist (column row)
-         (aset widths i (max (aref widths i)
-                             (car column)))
-         (aset natural-widths i (max (aref natural-widths i)
-                                     (cadr column)))
+         (aset widths i (max (aref widths i) column))
+         (setq i (1+ i)))))
+    (dolist (row natural-table)
+      (let ((i 0))
+       (dolist (column row)
+         (aset natural-widths i (max (aref natural-widths i) column))
          (setq i (1+ i)))))
-    (let* ((total-suggested (apply '+ (append suggested-widths nil)))
-          (total-actual (apply '+ (append widths nil)))
-          (extra (- total-suggested
-                    total-actual
-                    ;; TD separators.
-                    (length widths)
-                    ;; Table separators + fence.
-                    3
-                    (* 2 shr-table-depth)))
-          (expanded-columns 0))
+    (let ((extra (- (apply '+ (append suggested-widths nil))
+                   (apply '+ (append widths nil))))
+         (expanded-columns 0))
       ;; We have extra, unused space, so divide this space amongst the
       ;; columns.
       (when (> extra 0)
        ;; If the natural width is wider than the rendered width, we
        ;; want to allow the column to expand.
        (dotimes (i length)
-         (when (> (aref natural-widths i) 0)
-           (aset widths i (+ (truncate (* (/ extra (* 1.0 total-actual))
-                                          (aref widths i)))
-                             (aref widths i)))))))
+         (when (> (aref natural-widths i) (aref widths i))
+           (setq expanded-columns (1+ expanded-columns))))
+       (dotimes (i length)
+         (when (> (aref natural-widths i) (aref widths i))
+           (aset widths i (min
+                           (aref natural-widths i)
+                           (+ (/ extra expanded-columns)
+                              (aref widths i))))))))
     widths))
 
 (defun shr-make-table (cont widths &optional fill)
@@ -1369,20 +1371,14 @@ ones, in case fg and bg are nil."
                  (split-string (buffer-string) "\n")
                  (shr-collect-overlays)
                  (car actual-colors))
-         (list max
-               (shr-natural-width)))))))
+         max)))))
 
-(defun shr-natural-width ()
+(defun shr-buffer-width ()
   (goto-char (point-min))
-  (let ((current 0)
-       (max 0))
+  (let ((max 0))
     (while (not (eobp))
       (end-of-line)
-      (setq current (+ current (current-column)))
-      (if (get-text-property (point) 'shr-break)
-         (incf current)
-       (setq max (max max current)
-             current 0))
+      (setq max (max max (current-column)))
       (forward-line 1))
     max))