Dear all,

Sending email in emacs message-mode is great, but the handling of
(outgoing) attachments leaves a lot to be desired. MML's markup can be
confusing, and can easily be edited by mistake.

Thus: tach.el. Tach is a minor mode that adds mutt-like attachment
handling to message mode. It's not notmuch specific, but I wrote it to
use with notmuch, and I thought it might be of use to some on the

You can get tach by typing:

git clone

Also, because the server has been a bit spotty recently, I've put the
current version of the file at the end of this message.

To use tach, put tach.el in your load-path, and add the following to
your .emacs:

(require 'tach)
(add-hook 'message-mode-hook 'tach-minor-mode)

Now when you type "C-c C-a" in message-mode, you should get a new window
with an attachment list. In that window, you can add and delete
attachments using `+' and `-', and scroll through them using the arrow
keys or the emacs direction commands.

tach.el will convert the attachments into MML markup as a last
step before sending. Hopefully you should never have to deal with it by

Some details: tach actually makes a numerical list at the bottom of the
message itself, separated by a custom separator. The message is narrowed
to above this separator, and the attachment window is an indirect buffer
narrowed to the region below the separator. The separator is erased when
the messages are translated to mml markup at the end.

This is still a work in its earliest stages, and the usual disclaimers
apply. It certainly needs more a lot more commenting and
documentation. But I thought it might be useful, or at least fun to play
around with, and I'd love to hear any feedback. As I said, it's not
notmuch-specific, so I'm not sending it as a patch, but if people like
it, we might also consider making it part of the notmuch emacs bundle,
at some point in its future development.


;; tach.el -- Interface for handling attachments in message-mode

;; Filename: tach.el
;; Copyright (C) 2010 Jesse Rosenthal
;; Author: Jesse Rosenthal <>
;; Maintainer: Jesse Rosenthal <>
;; Created: 18 Feb 2010
;; Description: Handles attachments for message mode
;; Version 0.01alpha

;; This file is not part of GNU Emacs.

;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published
;; by the Free Software Foundation; either version 2, or (at your
;; option) any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; Commentary:

;; To use: add the following to your .emacs: 
;;   (require 'tach)
;;   (add-hook 'message-mode-hook 'tach-minor-mode)
;; Pressing `C-cC-a' in message mode will open up an attachment
;; window. The first time you open it, it will prompt for a file name.
;; In the attachment window, you can press `+' to add a file, or `-'
;; to remove one.
;; Note that the attachment window is actually a different view of the
;; message buffer, so that if there is some failure, the attachment
;; list will be saved at the bottom of the message, as a numerical
;; list under a customizable separator.
;; The files will be added to the outgoing message by mml before it is
;; sent.

(require 'message)
(require 'mml)

(defconst tach-sep  "--attachments follow this line--")

(defconst tach-line-regexp "^\\([0-9]+.\\) +\\(.+?\\) +\\(\\[.+, 

(defvar tach-send-confirmation nil)

(defvar tach-buffer-name)
(make-variable-buffer-local 'tach-buffer-name)

(defvar tach-mode-hooks 'nil)
(make-variable-buffer-local 'tach-mode-hooks)

(defvar tach-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "+" 'tach-add-file)
    (define-key map "-" 'tach-delete-file)
    (define-key map "\C-c\C-c" 'tach-send-from-attach-buffer)
    (define-key map [up] 'tach-prev-entry)
    (define-key map [down] 'tach-next-entry)
    (define-key map "n" 'tach-next-entry)
    (define-key map "p" 'tach-prev-entry)
    (define-key map "\C-n" 'tach-next-entry)
    (define-key map "\C-p" 'tach-prev-entry)
  "Keymap for attachment mode")
(fset 'tach-mode-map tach-mode-map)

(defvar tach-minor-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-c\C-a"  'tach-goto)
  "Keymap for attachment minor mode")
(fset 'tach-minor-mode-map tach-minor-mode-map)

(defun tach-mode ()
  (use-local-map 'tach-mode-map)
  (hl-line-mode 1)
  (setq major-mode 'tach-mode
        mode-name "attachment")
  (run-hooks 'tach-mode-hooks)
  (narrow-to-region (tach-buffer-point-min) (point-max))
  (setq buffer-read-only t))

(defun tach-buffer-point-min ()
    (goto-char (point-max))
    (search-backward-regexp tach-sep)
    (search-forward-regexp (concat tach-sep "\n"))

(defun tach-message-point-max ()
    (goto-char (point-max))
    (search-backward-regexp tach-sep)

(defun tach-first-entry-p ()
      (forward-line -1)
      (looking-at (concat "^" tach-sep "%")))))

(defun tach-last-entry-p ()
    (looking-at "^\s*$")))

(defun tach-next-entry ()
  (unless (tach-last-entry-p)
    (forward-line 1)))

(defun tach-prev-entry ()
  (unless (tach-first-entry-p)
    (forward-line -1)))

(defun tach-has-attachments-p ()
  (goto-char (point-max))
  (cond ((re-search-backward (concat "^" tach-sep "$")  nil t)
         (while (looking-at tach-line-regexp)
         (let ((remaining 
                (buffer-substring-no-properties (point) (point-max))))
           (if (string-match "[^\s\n]" remaining)

(defun tach-message-initialize ()
   (unless (tach-has-attachments-p)
     (goto-char (point-max))
     (insert (concat "\n" tach-sep "\n")))
    (narrow-to-region (point-min) (tach-message-point-max))))

(defun tach-goto ()
  (if (get-buffer tach-buffer-name)
      (pop-to-buffer tach-buffer-name)
    (pop-to-buffer (make-indirect-buffer 

(defun tach-read-list ()
    (let ((output nil))
      (goto-char (point-max))
      (re-search-backward (concat "^" tach-sep "$"))
      (while (and (looking-at tach-line-regexp)
                  (not (= (line-end-position) (point-max))))
        (setq output (cons (replace-regexp-in-string
                            tach-line-regexp "\\2"
(line-beginning-position) (line-end-position)))
      (reverse output))))

(defun tach-delete-list ()
    (goto-char (point-max))
    (re-search-backward (concat "^" tach-sep "$"))
    (delete-region (point) (point-max))))

(defun tach-write-list (lst)
    (goto-char (point-max))
    (re-search-backward (concat "^" tach-sep "$"))
    (let ((counter 1))
      (dolist (elt lst)
        (insert (concat (int-to-string counter) ". " elt
                        "  ["
                        (if (mm-default-file-encoding elt)
                            (mm-default-file-encoding elt)
                          "(type unknown)")
                        ", "
                        (tach-format-file-size (nth 7 (file-attributes elt)))
        (setq counter (+ counter 1))))))

(defun tach-format-file-size (bytes)
  (let ((kbytes (fceiling (/ bytes 1024.0))))
    (cond ((< kbytes 1)p
           (format "%.1fK" kbytes))
          ((< kbytes 1000) 
           (format "%.0fK" kbytes))
           (format "%.1fM" (/ kbytes 1000.0))))))

(defun tach-first-n-items (lst n)
  (let ((x 0)
    (if (> n (length lst))
        (setq y lst)
      (while (< x n)
        (setq y (nconc y (list (nth x lst)))
              x (1+ x))))

(defun tach-insert-item-at-idx (item idx lst)
  (append (tach-first-n-items lst idx) (cons item (nthcdr idx lst))))

(defun tach-remove-item-at-idx (idx lst)
  (append (tach-first-n-items lst idx) (nthcdr (+ 1 idx) lst)))

(defun tach-add-file (f &optional idx)
  (interactive "fFile to attach: ")
  (if (file-directory-p f)
      (error "Cannot attach a directory")
    (when buffer-read-only
      (setq buffer-read-only nil))
    (let ((file-lst (tach-read-list))
          (orig-line (line-number-at-pos))
          (orig-point (point)))
      (when (null idx)
        (cond ((= (length file-lst) 0)
               (setq idx 0))
               (setq idx (- orig-line (line-number-at-pos))))))
       (tach-insert-item-at-idx f idx file-lst)))
      (narrow-to-region (tach-buffer-point-min) (point-max))
      (forward-line idx)
      (when (null buffer-read-only)
        (setq buffer-read-only t))))

(defun tach-delete-file (&optional idx)
    (when buffer-read-only
      (setq buffer-read-only nil))
    (let ((file-lst (tach-read-list))
          (orig-line (line-number-at-pos))
          (orig-point (point)))
      (when (null idx)
        (setq idx (- (- orig-line (line-number-at-pos)) 1)))
      (tach-write-list (tach-remove-item-at-idx idx file-lst)))
    (narrow-to-region (tach-buffer-point-min) (point-max))
    (unless (= idx 0)
      (forward-line (- idx 1)))
    (when (null buffer-read-only)
      (setq buffer-read-only t)))

(defun tach-mml-files ()
  (when (tach-has-attachments-p)
  (let ((file-lst (tach-read-list)))
    (goto-char (point-max))
    (re-search-backward (concat "^" tach-sep "$"))
    (delete-region (point) (point-max))
    (dolist (f file-lst)
      (mml-attach-file f)
      (goto-char (point-max))))))

(defun tach-kill-buffer ()
  (when (get-buffer tach-buffer-name)
    (delete-windows-on tach-buffer-name)
    (kill-buffer tach-buffer-name)))

(defun tach-send-from-attach-buffer ()
  (when (buffer-base-buffer tach-buffer-name)
    (with-current-buffer (buffer-base-buffer tach-buffer-name)

(define-minor-mode tach-minor-mode ()
  " Tach"
  (if tach-minor-mode
        ;; set the attachment buffer local variable
        (setq tach-buffer-name
                 "^\\(\**\\)\\(.*?\\)\\(\**\\)$" "\\2" (buffer-name))
        ;; add the send hook
        (add-hook 'message-send-hook '(lambda ()
    ;; remove the send hook
    (remove-hook 'message-send-hook '(lambda ()


(provide 'tach)


notmuch mailing list

Reply via email to