2002-01-02 ShengHuo ZHU <zsh@cs.rochester.edu>

[gnus] / lisp / mml.el

diff --git a/lisp/mml.el b/lisp/mml.el
index 6af6b1d..af9b23c 100644 (file)
--- a/lisp/mml.el
+++ b/lisp/mml.el
@@ -1,5 +1,5 @@
 ;;; mml.el --- A package for parsing and validating MML documents
 ;;; mml.el --- A package for parsing and validating MML documents

-;; Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+;; Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;; This file is part of GNU Emacs.
 
 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
 ;; This file is part of GNU Emacs.


@@ -33,13 +33,51 @@
 (eval-and-compile
   (autoload 'message-make-message-id "message")
   (autoload 'gnus-setup-posting-charset "gnus-msg")
 (eval-and-compile
   (autoload 'message-make-message-id "message")
   (autoload 'gnus-setup-posting-charset "gnus-msg")

+  (autoload 'gnus-add-minor-mode "gnus-ems")

   (autoload 'message-fetch-field "message")
   (autoload 'message-posting-charset "message"))
 
   (autoload 'message-fetch-field "message")
   (autoload 'message-posting-charset "message"))
 

+(defcustom mml-content-type-parameters
+  '(name access-type expiration size permission format)
+  "*A list of acceptable parameters in MML tag.
+These parameters are generated in Content-Type header if exists."
+  :type '(repeat (symbol :tag "Parameter"))
+  :group 'message)
+
+(defcustom mml-content-disposition-parameters
+  '(filename creation-date modification-date read-date)
+  "*A list of acceptable parameters in MML tag.
+These parameters are generated in Content-Disposition header if exists."
+  :type '(repeat (symbol :tag "Parameter"))
+  :group 'message)
+
+(defvar mml-tweak-type-alist nil
+  "A list of (TYPE . FUNCTION) for tweaking MML parts.
+TYPE is a string containing a regexp to match the MIME type.  FUNCTION
+is a Lisp function which is called with the MML handle to tweak the
+part.  This variable is used only when no TWEAK parameter exists in
+the MML handle.")
+
+(defvar mml-tweak-function-alist nil
+  "A list of (NAME . FUNCTION) for tweaking MML parts.
+NAME is a string containing the name of the TWEAK parameter in the MML
+handle.  FUNCTION is a Lisp function which is called with the MML
+handle to tweak the part.")
+
+(defvar mml-tweak-sexp-alist 
+  '((mml-externalize-attachments . mml-tweak-externalize-attachments))
+  "A list of (SEXP . FUNCTION) for tweaking MML parts.
+SEXP is a s-expression. If the evaluation of SEXP is non-nil, FUNCTION
+is called.  FUNCTION is a Lisp function which is called with the MML
+handle to tweak the part.")
+
+(defvar mml-externalize-attachments nil
+  "*If non-nil, local-file attachments are generated as external parts.")
+

 (defvar mml-generate-multipart-alist nil
   "*Alist of multipart generation functions.
 Each entry has the form (NAME . FUNCTION), where
 (defvar mml-generate-multipart-alist nil
   "*Alist of multipart generation functions.
 Each entry has the form (NAME . FUNCTION), where

-NAME is a string containing the name of the part (without the 
+NAME is a string containing the name of the part (without the

 leading \"/multipart/\"),
 FUNCTION is a Lisp function which is called to generate the part.
 
 leading \"/multipart/\"),
 FUNCTION is a Lisp function which is called to generate the part.
 


@@ -77,7 +115,7 @@ one charsets.")
 
 (defvar mml-buffer-list nil)
 
 
 (defvar mml-buffer-list nil)
 

-(defun mml-generate-new-buffer (name) 
+(defun mml-generate-new-buffer (name)

   (let ((buf (generate-new-buffer name)))
     (push buf mml-buffer-list)
     buf))
   (let ((buf (generate-new-buffer name)))
     (push buf mml-buffer-list)
     buf))


@@ -89,13 +127,14 @@ one charsets.")
 
 (defun mml-parse ()
   "Parse the current buffer as an MML document."
 
 (defun mml-parse ()
   "Parse the current buffer as an MML document."

-  (goto-char (point-min))
-  (let ((table (syntax-table)))
-    (unwind-protect
-       (progn
-         (set-syntax-table mml-syntax-table)
-         (mml-parse-1))
-      (set-syntax-table table))))
+  (save-excursion
+    (goto-char (point-min))
+    (let ((table (syntax-table)))
+      (unwind-protect
+         (progn
+           (set-syntax-table mml-syntax-table)
+           (mml-parse-1))
+       (set-syntax-table table)))))

 
 (defun mml-parse-1 ()
   "Parse the current buffer as an MML document."
 
 (defun mml-parse-1 ()
   "Parse the current buffer as an MML document."


@@ -119,15 +158,25 @@ one charsets.")
        (setq raw (cdr (assq 'raw tag))
              point (point)
              contents (mml-read-part (eq 'mml (car tag)))
        (setq raw (cdr (assq 'raw tag))
              point (point)
              contents (mml-read-part (eq 'mml (car tag)))

-             charsets (if raw nil 
-                        (mm-find-mime-charset-region point (point))))
+             charsets (cond
+                       (raw nil)
+                       ((assq 'charset tag)
+                        (list
+                         (intern (downcase (cdr (assq 'charset tag))))))
+                       (t
+                        (mm-find-mime-charset-region point (point) 
+                                                     mm-hack-charsets))))

        (when (and (not raw) (memq nil charsets))
          (if (or (memq 'unknown-encoding mml-confirmation-set)
        (when (and (not raw) (memq nil charsets))
          (if (or (memq 'unknown-encoding mml-confirmation-set)

-                 (y-or-n-p
-                  "Message contains characters with unknown encoding.  Really send?"))
-             (if (setq use-ascii 
+                 (message-options-get 'unknown-encoding)
+                 (and (y-or-n-p "\
+Message contains characters with unknown encoding.  Really send?")
+                      (message-options-set 'unknown-encoding t)))
+             (if (setq use-ascii

                        (or (memq 'use-ascii mml-confirmation-set)
                        (or (memq 'use-ascii mml-confirmation-set)

-                           (y-or-n-p "Use ASCII as charset?")))
+                           (message-options-get 'use-ascii)
+                           (and (y-or-n-p "Use ASCII as charset?")
+                                (message-options-set 'use-ascii t))))

                  (setq charsets (delq nil charsets))
                (setq warn nil))
            (error "Edit your message to remove those characters")))
                  (setq charsets (delq nil charsets))
                (setq warn nil))
            (error "Edit your message to remove those characters")))


@@ -143,18 +192,18 @@ one charsets.")
                          tag point (point) use-ascii)))
            (when (and warn
                       (not (memq 'multipart mml-confirmation-set))
                          tag point (point) use-ascii)))
            (when (and warn
                       (not (memq 'multipart mml-confirmation-set))

-                      (not
-                       (y-or-n-p
-                        (format
-                         "Warning: Your message contains more than %d parts.  Really send? "
-                         (length nstruct)))))
+                      (not (message-options-get 'multipart))
+                      (not (and (y-or-n-p (format "\
+A message part needs to be split into %d charset parts.  Really send? "
+                                                  (length nstruct)))
+                                (message-options-set 'multipart t))))

              (error "Edit your message to use only one charset"))
            (setq struct (nconc nstruct struct)))))))
     (unless (eobp)
       (forward-line 1))
     (nreverse struct)))
 
              (error "Edit your message to use only one charset"))
            (setq struct (nconc nstruct struct)))))))
     (unless (eobp)
       (forward-line 1))
     (nreverse struct)))
 

-(defun mml-parse-singlepart-with-multiple-charsets 
+(defun mml-parse-singlepart-with-multiple-charsets

   (orig-tag beg end &optional use-ascii)
   (save-excursion
     (save-restriction
   (orig-tag beg end &optional use-ascii)
   (save-excursion
     (save-restriction


@@ -214,7 +263,8 @@ one charsets.")
 
 (defun mml-read-tag ()
   "Read a tag and return the contents."
 
 (defun mml-read-tag ()
   "Read a tag and return the contents."

-  (let (contents name elem val)
+  (let ((orig-point (point))
+       contents name elem val)

     (forward-char 2)
     (setq name (buffer-substring-no-properties
                (point) (progn (forward-sexp 1) (point))))
     (forward-char 2)
     (setq name (buffer-substring-no-properties
                (point) (progn (forward-sexp 1) (point))))


@@ -232,13 +282,15 @@ one charsets.")
     (goto-char (match-end 0))
     ;; Don't skip the leading space.
     ;;(skip-chars-forward " \t\n")
     (goto-char (match-end 0))
     ;; Don't skip the leading space.
     ;;(skip-chars-forward " \t\n")

+    ;; Put the tag location into the returned contents
+    (setq contents (append (list (cons 'tag-location orig-point)) contents))

     (cons (intern name) (nreverse contents))))
 
 (defun mml-read-part (&optional mml)
   "Return the buffer up till the next part, multipart or closing part or multipart.
 If MML is non-nil, return the buffer up till the correspondent mml tag."
   (let ((beg (point)) (count 1))
     (cons (intern name) (nreverse contents))))
 
 (defun mml-read-part (&optional mml)
   "Return the buffer up till the next part, multipart or closing part or multipart.
 If MML is non-nil, return the buffer up till the correspondent mml tag."
   (let ((beg (point)) (count 1))

-    ;; If the tag ended at the end of the line, we go to the next line.
+   ;; If the tag ended at the end of the line, we go to the next line.

     (when (looking-at "[ \t]*\n")
       (forward-line 1))
     (if mml
     (when (looking-at "[ \t]*\n")
       (forward-line 1))
     (if mml


@@ -247,7 +299,7 @@ If MML is non-nil, return the buffer up till the correspondent mml tag."
            (if (re-search-forward "<#\\(/\\)?mml." nil t)
                (setq count (+ count (if (match-beginning 1) -1 1)))
              (goto-char (point-max))))
            (if (re-search-forward "<#\\(/\\)?mml." nil t)
                (setq count (+ count (if (match-beginning 1) -1 1)))
              (goto-char (point-max))))

-         (buffer-substring-no-properties beg (if (> count 0) 
+         (buffer-substring-no-properties beg (if (> count 0)

                                                  (point)
                                                (match-beginning 0))))
       (if (re-search-forward
                                                  (point)
                                                (match-beginning 0))))
       (if (re-search-forward


@@ -280,10 +332,11 @@ If MML is non-nil, return the buffer up till the correspondent mml tag."
        (buffer-string)))))
 
 (defun mml-generate-mime-1 (cont)
        (buffer-string)))))
 
 (defun mml-generate-mime-1 (cont)

-  (let ((mm-use-ultra-safe-encoding 
+  (let ((mm-use-ultra-safe-encoding

         (or mm-use-ultra-safe-encoding (assq 'sign cont))))
     (save-restriction
       (narrow-to-region (point) (point))
         (or mm-use-ultra-safe-encoding (assq 'sign cont))))
     (save-restriction
       (narrow-to-region (point) (point))

+      (mml-tweak-part cont)

       (cond
        ((or (eq (car cont) 'part) (eq (car cont) 'mml))
        (let ((raw (cdr (assq 'raw cont)))
       (cond
        ((or (eq (car cont) 'part) (eq (car cont) 'mml))
        (let ((raw (cdr (assq 'raw cont)))


@@ -291,47 +344,53 @@ If MML is non-nil, return the buffer up till the correspondent mml tag."
          (setq type (or (cdr (assq 'type cont)) "text/plain"))
          (if (and (not raw)
                   (member (car (split-string type "/")) '("text" "message")))
          (setq type (or (cdr (assq 'type cont)) "text/plain"))
          (if (and (not raw)
                   (member (car (split-string type "/")) '("text" "message")))

-             (with-temp-buffer
-               (setq charset (mm-charset-to-coding-system 
-                              (cdr (assq 'charset cont))))
-               (if (eq charset 'ascii) (setq charset nil))
-               (cond
-                ((cdr (assq 'buffer cont))
-                 (insert-buffer-substring (cdr (assq 'buffer cont))))
-                ((and (setq filename (cdr (assq 'filename cont)))
-                      (not (equal (cdr (assq 'nofile cont)) "yes")))
-                 (let ((coding-system-for-read charset))
-                   (mm-insert-file-contents filename)))
-                ((eq 'mml (car cont))
-                 (insert (cdr (assq 'contents cont))))
-                (t
-                 (save-restriction
-                   (narrow-to-region (point) (point))
-                   (insert (cdr (assq 'contents cont)))
-                   ;; Remove quotes from quoted tags.
-                   (goto-char (point-min))
-                   (while (re-search-forward
-                           "<#!+/?\\(part\\|multipart\\|external\\|mml\\)" nil t)
-                     (delete-region (+ (match-beginning 0) 2)
-                                    (+ (match-beginning 0) 3))))))
-               (cond 
-                ((eq (car cont) 'mml)
-                 (let ((mml-boundary (funcall mml-boundary-function
-                                              (incf mml-multipart-number)))
-                       (mml-generate-default-type "text/plain"))
-                   (mml-to-mime))
-                 (let ((mm-7bit-chars (concat mm-7bit-chars "\x1b")))
-                   ;; ignore 0x1b, it is part of iso-2022-jp
-                   (setq encoding (mm-body-7-or-8))))
-                ((string= (car (split-string type "/")) "message")
-                 (let ((mm-7bit-chars (concat mm-7bit-chars "\x1b")))
-                   ;; ignore 0x1b, it is part of iso-2022-jp
-                   (setq encoding (mm-body-7-or-8))))
-                (t 
-                 (setq charset (mm-encode-body charset))
-                 (setq encoding (mm-body-encoding
-                                 charset (cdr (assq 'encoding cont))))))
-               (setq coded (buffer-string)))
+             (progn
+               (with-temp-buffer
+                 (setq charset (mm-charset-to-coding-system
+                                (cdr (assq 'charset cont))))
+                 (when (eq charset 'ascii)
+                   (setq charset nil))
+                 (cond
+                  ((cdr (assq 'buffer cont))
+                   (insert-buffer-substring (cdr (assq 'buffer cont))))
+                  ((and (setq filename (cdr (assq 'filename cont)))
+                        (not (equal (cdr (assq 'nofile cont)) "yes")))
+                   (let ((coding-system-for-read charset))
+                     (mm-insert-file-contents filename)))
+                  ((eq 'mml (car cont))
+                   (insert (cdr (assq 'contents cont))))
+                  (t
+                   (save-restriction
+                     (narrow-to-region (point) (point))
+                     (insert (cdr (assq 'contents cont)))
+                     ;; Remove quotes from quoted tags.
+                     (goto-char (point-min))
+                     (while (re-search-forward
+                             "<#!+/?\\(part\\|multipart\\|external\\|mml\\)"
+                             nil t)
+                       (delete-region (+ (match-beginning 0) 2)
+                                      (+ (match-beginning 0) 3))))))
+                 (cond
+                  ((eq (car cont) 'mml)
+                   (let ((mml-boundary (funcall mml-boundary-function
+                                                (incf mml-multipart-number)))
+                         (mml-generate-default-type "text/plain"))
+                     (mml-to-mime))
+                   (let ((mm-7bit-chars (concat mm-7bit-chars "\x1b")))
+                     ;; ignore 0x1b, it is part of iso-2022-jp
+                     (setq encoding (mm-body-7-or-8))))
+                  ((string= (car (split-string type "/")) "message")
+                   (let ((mm-7bit-chars (concat mm-7bit-chars "\x1b")))
+                     ;; ignore 0x1b, it is part of iso-2022-jp
+                     (setq encoding (mm-body-7-or-8))))
+                  (t
+                   (setq charset (mm-encode-body charset))
+                   (setq encoding (mm-body-encoding
+                                   charset (cdr (assq 'encoding cont))))))
+                 (setq coded (buffer-string)))
+               (mml-insert-mime-headers cont type charset encoding)
+               (insert "\n")
+               (insert coded))

            (mm-with-unibyte-buffer
              (cond
               ((cdr (assq 'buffer cont))
            (mm-with-unibyte-buffer
              (cond
               ((cdr (assq 'buffer cont))


@@ -343,10 +402,11 @@ If MML is non-nil, return the buffer up till the correspondent mml tag."
               (t
                (insert (cdr (assq 'contents cont)))))
              (setq encoding (mm-encode-buffer type)
               (t
                (insert (cdr (assq 'contents cont)))))
              (setq encoding (mm-encode-buffer type)

-                   coded (buffer-string))))
-         (mml-insert-mime-headers cont type charset encoding)
-         (insert "\n")
-         (insert coded)))
+                   coded (mm-string-as-multibyte (buffer-string))))
+           (mml-insert-mime-headers cont type charset encoding)
+           (insert "\n")
+           (mm-with-unibyte-current-buffer
+             (insert coded)))))

        ((eq (car cont) 'external)
        (insert "Content-Type: message/external-body")
        (let ((parameters (mml-parameter-string
        ((eq (car cont) 'external)
        (insert "Content-Type: message/external-body")
        (let ((parameters (mml-parameter-string


@@ -369,7 +429,7 @@ If MML is non-nil, return the buffer up till the correspondent mml tag."
               (concat "access-type="
                       (if (member (nth 0 name) '("ftp@" "anonymous@"))
                           "anon-ftp"
               (concat "access-type="
                       (if (member (nth 0 name) '("ftp@" "anonymous@"))
                           "anon-ftp"

-                        "ftp")))))      
+                        "ftp")))))

          (when url
            (mml-insert-parameter
             (mail-header-encode-parameter "url" url)
          (when url
            (mml-insert-parameter
             (mail-header-encode-parameter "url" url)


@@ -467,7 +527,7 @@ If MML is non-nil, return the buffer up till the correspondent mml tag."
   (let (parameters disposition description)
     (setq parameters
          (mml-parameter-string
   (let (parameters disposition description)
     (setq parameters
          (mml-parameter-string

-          cont '(name access-type expiration size permission)))
+          cont mml-content-type-parameters))

     (when (or charset
              parameters
              (not (equal type mml-generate-default-type)))
     (when (or charset
              parameters
              (not (equal type mml-generate-default-type)))


@@ -480,17 +540,17 @@ If MML is non-nil, return the buffer up till the correspondent mml tag."
                      "charset" (symbol-name charset))))
       (when parameters
        (mml-insert-parameter-string
                      "charset" (symbol-name charset))))
       (when parameters
        (mml-insert-parameter-string

-        cont '(name access-type expiration size permission)))
+        cont mml-content-type-parameters))

       (insert "\n"))
     (setq parameters
          (mml-parameter-string
       (insert "\n"))
     (setq parameters
          (mml-parameter-string

-          cont '(filename creation-date modification-date read-date)))
+          cont mml-content-disposition-parameters))

     (when (or (setq disposition (cdr (assq 'disposition cont)))
              parameters)
       (insert "Content-Disposition: " (or disposition "inline"))
       (when parameters
        (mml-insert-parameter-string
     (when (or (setq disposition (cdr (assq 'disposition cont)))
              parameters)
       (insert "Content-Disposition: " (or disposition "inline"))
       (when parameters
        (mml-insert-parameter-string

-        cont '(filename creation-date modification-date read-date)))
+        cont mml-content-disposition-parameters))

       (insert "\n"))
     (unless (eq encoding '7bit)
       (insert (format "Content-Transfer-Encoding: %s\n" encoding)))
       (insert "\n"))
     (unless (eq encoding '7bit)
       (insert (format "Content-Transfer-Encoding: %s\n" encoding)))


@@ -568,6 +628,7 @@ If HANDLES is non-nil, use it instead reparsing the buffer."
     ;; Remove them, they are confusing.
     (message-remove-header "Content-Type")
     (message-remove-header "MIME-Version")
     ;; Remove them, they are confusing.
     (message-remove-header "Content-Type")
     (message-remove-header "MIME-Version")

+    (message-remove-header "Content-Disposition")

     (message-remove-header "Content-Transfer-Encoding")))
 
 (defun mml-to-mime ()
     (message-remove-header "Content-Transfer-Encoding")))
 
 (defun mml-to-mime ()


@@ -586,7 +647,7 @@ If HANDLES is non-nil, use it instead reparsing the buffer."
        (save-excursion
          (set-buffer (setq buffer (mml-generate-new-buffer " *mml*")))
          (mm-insert-part handle)
        (save-excursion
          (set-buffer (setq buffer (mml-generate-new-buffer " *mml*")))
          (mm-insert-part handle)

-         (if (setq mmlp (equal (mm-handle-media-type handle) 
+         (if (setq mmlp (equal (mm-handle-media-type handle)

                                "message/rfc822"))
              (mime-to-mml)))))
     (if mmlp
                                "message/rfc822"))
              (mime-to-mml)))))
     (if mmlp


@@ -595,7 +656,7 @@ If HANDLES is non-nil, use it instead reparsing the buffer."
                   (equal (mm-handle-media-type handle) "text/plain"))
        (mml-insert-mml-markup handle buffer textp)))
     (cond
                   (equal (mm-handle-media-type handle) "text/plain"))
        (mml-insert-mml-markup handle buffer textp)))
     (cond

-     (mmlp 
+     (mmlp

       (insert-buffer buffer)
       (goto-char (point-max))
       (insert "<#/mml>\n"))
       (insert-buffer buffer)
       (goto-char (point-max))
       (insert "<#/mml>\n"))


@@ -655,8 +716,10 @@ If HANDLES is non-nil, use it instead reparsing the buffer."
        (map (make-sparse-keymap))
        (main (make-sparse-keymap)))
     (define-key sign "p" 'mml-secure-sign-pgpmime)
        (map (make-sparse-keymap))
        (main (make-sparse-keymap)))
     (define-key sign "p" 'mml-secure-sign-pgpmime)

+    (define-key sign "o" 'mml-secure-sign-pgp)

     (define-key sign "s" 'mml-secure-sign-smime)
     (define-key encrypt "p" 'mml-secure-encrypt-pgpmime)
     (define-key sign "s" 'mml-secure-sign-smime)
     (define-key encrypt "p" 'mml-secure-encrypt-pgpmime)

+    (define-key encrypt "o" 'mml-secure-encrypt-pgp)

     (define-key encrypt "s" 'mml-secure-encrypt-smime)
     (define-key map "f" 'mml-attach-file)
     (define-key map "b" 'mml-attach-buffer)
     (define-key encrypt "s" 'mml-secure-encrypt-smime)
     (define-key map "f" 'mml-attach-file)
     (define-key map "b" 'mml-attach-buffer)


@@ -675,32 +738,33 @@ If HANDLES is non-nil, use it instead reparsing the buffer."
     main))
 
 (easy-menu-define
     main))
 
 (easy-menu-define

- mml-menu mml-mode-map ""
- '("MML"
-   ("Attach"
-    ["File" mml-attach-file t]
-    ["Buffer" mml-attach-buffer t]
-    ["External" mml-attach-external t])
-   ("Insert"
-    ["Multipart" mml-insert-multipart t]
-    ["Part" mml-insert-part t])
-   ("Security"
-    ("Sign"
-     ["PGP/MIME" mml-secure-sign-pgpmime t]
-     ["S/MIME" mml-secure-sign-smime t])
-    ("Encrypt"
-     ["PGP/MIME" mml-secure-encrypt-pgpmime t]
-     ["S/MIME" mml-secure-encrypt-smime t]))
-   ;;["Narrow" mml-narrow-to-part t]
-   ["Quote" mml-quote-region t]
-   ["Validate" mml-validate t]
-   ["Preview" mml-preview t]))
+  mml-menu mml-mode-map ""
+  `("Attachments"
+    ["Attach File" mml-attach-file
+     ,@(if (featurep 'xemacs) '(t)
+        '(:help "Attach a file at point"))]
+    ["Attach Buffer" mml-attach-buffer t]
+    ["Attach External" mml-attach-external t]
+    ["Insert Part" mml-insert-part t]
+    ["Insert Multipart" mml-insert-multipart t]
+    ["PGP/MIME Sign" mml-secure-sign-pgpmime t]
+    ["PGP/MIME Encrypt" mml-secure-encrypt-pgpmime t]
+    ["PGP Sign" mml-secure-sign-pgp t]
+    ["PGP Encrypt" mml-secure-encrypt-pgp t]
+    ["S/MIME Sign" mml-secure-sign-smime t]
+    ["S/MIME Encrypt" mml-secure-encrypt-smime t]
+    ;;["Narrow" mml-narrow-to-part t]
+    ["Quote MML" mml-quote-region t]
+    ["Validate MML" mml-validate t]
+    ["Preview" mml-preview t]))

 
 (defvar mml-mode nil
   "Minor mode for editing MML.")
 
 (defun mml-mode (&optional arg)
   "Minor mode for editing MML.
 
 (defvar mml-mode nil
   "Minor mode for editing MML.")
 
 (defun mml-mode (&optional arg)
   "Minor mode for editing MML.

+MML is the MIME Meta Language, a minor mode for composing MIME articles.
+See Info node `(emacs-mime)Composing'.

 
 \\{mml-mode-map}"
   (interactive "P")
 
 \\{mml-mode-map}"
   (interactive "P")


@@ -718,7 +782,7 @@ If HANDLES is non-nil, use it instead reparsing the buffer."
 
 (defun mml-minibuffer-read-file (prompt)
   (let ((file (read-file-name prompt nil nil t)))
 
 (defun mml-minibuffer-read-file (prompt)
   (let ((file (read-file-name prompt nil nil t)))

-    ;; Prevent some common errors.  This is inspired by similar code in
+   ;; Prevent some common errors.  This is inspired by similar code in

     ;; VM.
     (when (file-directory-p file)
       (error "%s is a directory, cannot attach" file))
     ;; VM.
     (when (file-directory-p file)
       (error "%s is a directory, cannot attach" file))


@@ -848,13 +912,14 @@ TYPE is the MIME type to use."
   "Display current buffer with Gnus, in a new buffer.
 If RAW, don't highlight the article."
   (interactive "P")
   "Display current buffer with Gnus, in a new buffer.
 If RAW, don't highlight the article."
   (interactive "P")

-  (let ((buf (current-buffer))
-       (message-options message-options)
-       (message-posting-charset (or (gnus-setup-posting-charset 
-                                     (save-restriction
-                                       (message-narrow-to-headers-or-head)
-                                       (message-fetch-field "Newsgroups")))
-                                    message-posting-charset)))
+  (let* ((buf (current-buffer))
+        (message-options message-options)
+        (message-this-is-news (message-news-p))
+        (message-posting-charset (or (gnus-setup-posting-charset
+                                      (save-restriction
+                                        (message-narrow-to-headers-or-head)
+                                        (message-fetch-field "Newsgroups")))
+                                     message-posting-charset)))

     (message-options-set-recipient)
     (switch-to-buffer (generate-new-buffer
                       (concat (if raw "*Raw MIME preview of "
     (message-options-set-recipient)
     (switch-to-buffer (generate-new-buffer
                       (concat (if raw "*Raw MIME preview of "


@@ -864,7 +929,8 @@ If RAW, don't highlight the article."
     (if (re-search-forward
         (concat "^" (regexp-quote mail-header-separator) "\n") nil t)
        (replace-match "\n"))
     (if (re-search-forward
         (concat "^" (regexp-quote mail-header-separator) "\n") nil t)
        (replace-match "\n"))

-    (mml-to-mime)
+    (let ((mail-header-separator "")) ;; mail-header-separator is removed.
+      (mml-to-mime))

     (if raw
        (when (fboundp 'set-buffer-multibyte)
          (let ((s (buffer-string)))
     (if raw
        (when (fboundp 'set-buffer-multibyte)
          (let ((s (buffer-string)))


@@ -876,8 +942,10 @@ If RAW, don't highlight the article."
        (run-hooks 'gnus-article-decode-hook)
        (let ((gnus-newsgroup-name "dummy"))
          (gnus-article-prepare-display))))
        (run-hooks 'gnus-article-decode-hook)
        (let ((gnus-newsgroup-name "dummy"))
          (gnus-article-prepare-display))))

-    (fundamental-mode)
+    ;; Disable article-mode-map.
+    (use-local-map nil)

     (setq buffer-read-only t)
     (setq buffer-read-only t)

+    (local-set-key "q" (lambda () (interactive) (kill-buffer nil)))

     (goto-char (point-min))))
 
 (defun mml-validate ()
     (goto-char (point-min))))
 
 (defun mml-validate ()


@@ -885,6 +953,43 @@ If RAW, don't highlight the article."
   (interactive)
   (mml-parse))
 
   (interactive)
   (mml-parse))
 

+(defun mml-tweak-part (cont)
+  "Tweak a MML part."
+  (let ((tweak (cdr (assq 'tweak cont)))
+       func)
+    (cond
+     (tweak
+      (setq func
+           (or (cdr (assoc tweak mml-tweak-function-alist))
+               (intern tweak))))
+     (mml-tweak-type-alist
+      (let ((alist mml-tweak-type-alist)
+           (type (or (cdr (assq 'type cont)) "text/plain")))
+       (while alist
+         (if (string-match (caar alist) type)
+             (setq func (cdar alist)
+                   alist nil)
+           (setq alist (cdr alist)))))))
+    (if func
+       (funcall func cont)
+      cont)
+    (let ((alist mml-tweak-sexp-alist))
+      (while alist
+       (if (eval (caar alist))
+           (funcall (cdar alist) cont))
+       (setq alist (cdr alist)))))
+  cont)
+
+(defun mml-tweak-externalize-attachments (cont)
+  "Tweak attached files as external parts."
+  (let (filename-cons)
+    (when (and (eq (car cont) 'part) 
+              (not (cdr (assq 'buffer cont)))
+              (and (setq filename-cons (assq 'filename cont))
+                   (not (equal (cdr (assq 'nofile cont)) "yes"))))
+      (setcar cont 'external)
+      (setcar filename-cons 'name))))
+

 (provide 'mml)
 
 ;;; mml.el ends here
 (provide 'mml)
 
 ;;; mml.el ends here