Make `gnus-msg-mail' warn about Gnus not running

[gnus] / lisp / shr.el

diff --git a/lisp/shr.el b/lisp/shr.el
index 3ca7f1c..ce98ab8 100644 (file)
--- a/lisp/shr.el
+++ b/lisp/shr.el
@@ -368,6 +368,7 @@ size, and full-buffer size."
       (unless shr-start
        (setq shr-start (point)))
       (insert elem)
+      (setq shr-state nil)
       (let (found)
        (while (and (> (current-column) shr-width)
                    (progn
@@ -443,32 +444,29 @@ size, and full-buffer size."
                         (shr-char-kinsoku-eol-p (following-char)))))
           (goto-char bp)))
        ((shr-char-kinsoku-eol-p (preceding-char))
-        (if (shr-char-kinsoku-eol-p (following-char))
-            ;; There are consecutive kinsoku-eol characters.
-            (setq failed t)
-          (let ((count 4))
-            (while
-                (progn
-                  (backward-char 1)
-                  (and (> (setq count (1- count)) 0)
-                       (not (memq (preceding-char) (list ?\C-@ ?\n ? )))
-                       (or (shr-char-kinsoku-eol-p (preceding-char))
-                           (shr-char-kinsoku-bol-p (following-char)))))))
-          (if (setq failed (= (current-column) shr-indentation))
-              ;; There's no breakable point that doesn't violate kinsoku,
-              ;; so we go to the second best position.
-              (if (looking-at "\\(\\c<+\\)\\c<")
-                  (goto-char (match-end 1))
-                (forward-char 1)))))
-       (t
-        (if (shr-char-kinsoku-bol-p (preceding-char))
-            ;; There are consecutive kinsoku-bol characters.
-            (setq failed t)
-          (let ((count 4))
-            (while (and (>= (setq count (1- count)) 0)
+        ;; Find backward the point where kinsoku-eol characters begin.
+        (let ((count 4))
+          (while
+              (progn
+                (backward-char 1)
+                (and (> (setq count (1- count)) 0)
+                     (not (memq (preceding-char) (list ?\C-@ ?\n ? )))
+                     (or (shr-char-kinsoku-eol-p (preceding-char))
+                         (shr-char-kinsoku-bol-p (following-char)))))))
+        (if (setq failed (= (current-column) shr-indentation))
+            ;; There's no breakable point that doesn't violate kinsoku,
+            ;; so we go to the second best position.
+            (if (looking-at "\\(\\c<+\\)\\c<")
+                (goto-char (match-end 1))
+              (forward-char 1))))
+       ((shr-char-kinsoku-bol-p (following-char))
+        ;; Find forward the point where kinsoku-bol characters end.
+        (let ((count 4))
+          (while (progn
+                   (forward-char 1)
+                   (and (>= (setq count (1- count)) 0)
                         (shr-char-kinsoku-bol-p (following-char))
-                        (shr-char-breakable-p (following-char)))
-              (forward-char 1))))))
+                        (shr-char-breakable-p (following-char))))))))
        (when (eq (following-char) ? )
         (forward-char 1))))
     (not failed)))
@@ -500,7 +498,7 @@ size, and full-buffer size."
       (if (save-excursion
            (beginning-of-line)
            (looking-at " *$"))
-         (insert "\n")
+         (delete-region (match-beginning 0) (match-end 0))
        (insert "\n\n")))))
 
 (defun shr-indent ()
@@ -1043,7 +1041,12 @@ ones, in case fg and bg are nil."
     (shr-generic cont)))
 
 (defun shr-tag-br (cont)
-  (unless (bolp)
+  (when (and (not (bobp))
+            ;; Only add a newline if we break the current line, or
+            ;; the previous line isn't a blank line.
+            (or (not (bolp))
+                (and (> (- (point) 2) (point-min))
+                     (not (= (char-after (- (point) 2)) ?\n)))))
     (insert "\n")
     (shr-indent))
   (shr-generic cont))