mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-11-25 07:28:20 +00:00
952 lines
30 KiB
EmacsLisp
952 lines
30 KiB
EmacsLisp
;;; mairix.el --- Mairix interface for Emacs
|
|
|
|
;; Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
|
|
|
|
;; Author: David Engster <dengste@eml.cc>
|
|
;; Keywords: mail searching
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;; GNU Emacs 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 3 of the License, or
|
|
;; (at your option) any later version.
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful,
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
;; GNU General Public License for more details.
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
|
|
;; This is an interface to the mairix mail search engine. Mairix is
|
|
;; written by Richard Curnow and is licensed under the GPL. See the
|
|
;; home page for details:
|
|
;;
|
|
;; http://www.rpcurnow.force9.co.uk/mairix/
|
|
;;
|
|
;; Features of mairix.el:
|
|
;;
|
|
;; * Query mairix with a search term.
|
|
;; * Currently supported Emacs mail programs: RMail, Gnus (mbox only),
|
|
;; and VM.
|
|
;; * Generate search queries using graphical widgets.
|
|
;; * Generate search queries based on currently displayed mail.
|
|
;; * Save regularly used searches in your .emacs customize section.
|
|
;; * Major mode for viewing, editing and querying saved searches.
|
|
;; * Update mairix database.
|
|
;;
|
|
;; Please note: There are currently no pre-defined key bindings, since
|
|
;; I guess these would depend on the used mail program. See the docs
|
|
;; for an overview of the provided interactive functions.
|
|
;;
|
|
;; Attention Gnus users: If you use Gnus with maildir or nnml, you
|
|
;; should use the native Gnus back end nnmairix.el instead, since it
|
|
;; has more features and is better integrated with Gnus. This
|
|
;; interface is essentially a stripped down version of nnmairix.el.
|
|
;;
|
|
;; Currently, RMail, Gnus (with mbox files), and VM are supported as
|
|
;; mail programs, but it is pretty easy to interface it with other
|
|
;; ones as well. Please see the docs and the source for details.
|
|
;; In a nutshell: include your favourite mail program in
|
|
;; `mairix-mail-program' and write functions for
|
|
;; `mairix-display-functions' and `mairix-get-mail-header-functions'.
|
|
;; If you have written such functions for your Emacs mail program of
|
|
;; choice, please let me know, so that I can eventually include them
|
|
;; in future version of mairix.el.
|
|
|
|
;;; History:
|
|
|
|
;; 07/28/2008: version 0.2. Added VM interface, written by Ulrich
|
|
;; Mueller.
|
|
|
|
;; 07/14/2008: Initial release
|
|
|
|
;;; Code:
|
|
|
|
(require 'widget)
|
|
(require 'cus-edit)
|
|
|
|
(eval-when-compile
|
|
(require 'cl))
|
|
|
|
;;; Keymappings
|
|
|
|
;; (currently none - please create them yourself)
|
|
|
|
;;; Customizable variables
|
|
|
|
(defgroup mairix nil
|
|
"Mairix interface for Emacs."
|
|
:group 'mail)
|
|
|
|
(defcustom mairix-file-path "~/"
|
|
"Path where output files produced by Mairix should be stored."
|
|
:type 'directory
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-search-file "mairixsearch.mbox"
|
|
"Name of the default file for storing the searches.
|
|
Note that this will be prefixed by `mairix-file-path'."
|
|
:type 'string
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-command "mairix"
|
|
"Command for calling mairix.
|
|
You can add further options here if you want to, but better use
|
|
`mairix-update-options' instead."
|
|
:type 'string
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-output-buffer "*mairix output*"
|
|
"Name of the buffer for the output of the mairix binary."
|
|
:type 'string
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-customize-query-buffer "*mairix query*"
|
|
"Name of the buffer for customizing a search query."
|
|
:type 'string
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-saved-searches-buffer "*mairix searches*"
|
|
"Name of the buffer for displaying saved searches."
|
|
:type 'string
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-update-options '("-F" "-Q")
|
|
"Options when calling mairix for updating the database.
|
|
The default is '-F' and '-Q' for making updates faster. You
|
|
should call mairix without these options from time to
|
|
time (e.g. via cron job)."
|
|
:type '(repeat string)
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-search-options '("-Q")
|
|
"Options when calling mairix for searching.
|
|
The default is '-Q' for making searching faster."
|
|
:type '(repeat string)
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-synchronous-update nil
|
|
"Defines if Emacs should wait for the mairix database update."
|
|
:type 'boolean
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-saved-searches nil
|
|
"Saved mairix searches.
|
|
The entries are: Name of the search, Mairix query string, Name of
|
|
the file (nil: use `mairix-search-file' as default), Search whole
|
|
threads (nil or t). Note that the file will be prefixed by
|
|
`mairix-file-path'."
|
|
:type '(repeat (list (string :tag "Name")
|
|
(string :tag "Query")
|
|
(choice :tag "File"
|
|
(const :tag "default")
|
|
file)
|
|
(boolean :tag "Threads")))
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-mail-program 'rmail
|
|
"Mail program used to display search results.
|
|
Currently RMail, Gnus (mbox), and VM are supported. If you use Gnus
|
|
with maildir, use nnmairix.el instead."
|
|
:type '(choice (const :tag "RMail" rmail)
|
|
(const :tag "Gnus mbox" gnus)
|
|
(const :tag "VM" vm))
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-display-functions
|
|
'((rmail mairix-rmail-display)
|
|
(gnus mairix-gnus-ephemeral-nndoc)
|
|
(vm mairix-vm-display))
|
|
"Specifies which function should be called for displaying search results.
|
|
This is an alist where each entry consists of a symbol from
|
|
`mairix-mail-program' and the corresponding function for
|
|
displaying the search results. The function will be called with
|
|
the mailbox file produced by mairix as the single argument."
|
|
:type '(repeat (list (symbol :tag "Mail program")
|
|
(function)))
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-get-mail-header-functions
|
|
'((rmail mairix-rmail-fetch-field)
|
|
(gnus mairix-gnus-fetch-field)
|
|
(vm mairix-vm-fetch-field))
|
|
"Specifies function for obtaining a header field from the current mail.
|
|
This is an alist where each entry consists of a symbol from
|
|
`mairix-mail-program' and the corresponding function for
|
|
obtaining a header field from the current displayed mail. The
|
|
function will be called with the mail header string as single
|
|
argument. You can use nil if you do not have such a function for
|
|
your mail program, but then searches based on the current mail
|
|
won't work."
|
|
:type '(repeat (list (symbol :tag "Mail program")
|
|
(choice :tag "Header function"
|
|
(const :tag "none")
|
|
function)))
|
|
:group 'mairix)
|
|
|
|
(defcustom mairix-widget-select-window-function
|
|
(lambda () (select-window (get-largest-window)))
|
|
"Function for selecting the window for customizing the mairix query.
|
|
The default chooses the largest window in the current frame."
|
|
:type 'function
|
|
:group 'mairix)
|
|
|
|
;; Other variables
|
|
|
|
(defvar mairix-widget-fields-list
|
|
'(("from" "f" "From") ("to" "t" "To") ("cc" "c" "Cc")
|
|
("subject" "s" "Subject") ("to" "tc" "To or Cc")
|
|
("from" "a" "Address") (nil "b" "Body") (nil "n" "Attachment")
|
|
("Message-ID" "m" "Message ID") (nil "s" "Size") (nil "d" "Date"))
|
|
"Fields that should be editable during interactive query customization.
|
|
Header, corresponding mairix command and description for editable
|
|
fields in interactive query customization. The header specifies
|
|
which header contents should be inserted into the editable field
|
|
when creating a Mairix query based on the current message (can be
|
|
nil for disabling this).")
|
|
|
|
(defvar mairix-widget-other
|
|
'(threads flags)
|
|
"Other editable mairix commands when using customization widgets.
|
|
Currently there are 'threads and 'flags.")
|
|
|
|
;;;; Internal variables
|
|
|
|
(defvar mairix-last-search nil)
|
|
(defvar mairix-searches-changed nil)
|
|
|
|
;;;; Interface functions for Emacs mail programs
|
|
|
|
;;; RMail
|
|
|
|
;; Display function:
|
|
(autoload 'rmail "rmail")
|
|
(autoload 'rmail-summary-displayed "rmail")
|
|
(autoload 'rmail-summary "rmailsum")
|
|
(defvar rmail-buffer)
|
|
|
|
(defun mairix-rmail-display (folder)
|
|
"Display mbox file FOLDER with RMail."
|
|
(let (show-summary)
|
|
;; If it exists, select existing RMail window
|
|
(when (and (boundp 'rmail-buffer)
|
|
rmail-buffer)
|
|
(set-buffer rmail-buffer)
|
|
(when (get-buffer-window rmail-buffer)
|
|
(select-window (get-buffer-window rmail-buffer))
|
|
(setq show-summary (rmail-summary-displayed))))
|
|
;; check if folder is already open and if so, kill it
|
|
(when (get-buffer (file-name-nondirectory folder))
|
|
(set-buffer
|
|
(get-buffer (file-name-nondirectory folder)))
|
|
(set-buffer-modified-p nil)
|
|
(kill-buffer nil))
|
|
(rmail folder)
|
|
;; Update summary if necessary
|
|
(when show-summary
|
|
(rmail-summary))))
|
|
|
|
;; Fetching mail header field:
|
|
(defun mairix-rmail-fetch-field (field)
|
|
"Get mail header FIELD for current message using RMail."
|
|
(unless (and (boundp 'rmail-buffer)
|
|
rmail-buffer)
|
|
(error "No RMail buffer available"))
|
|
;; At this point, we are in rmail mode, so the rmail funcs are loaded.
|
|
(if (fboundp 'rmail-get-header) ; Emacs 23
|
|
(rmail-get-header field)
|
|
(with-current-buffer rmail-buffer
|
|
(save-restriction
|
|
;; Don't warn about this when compiling Emacs 23.
|
|
(with-no-warnings (rmail-narrow-to-non-pruned-header))
|
|
(mail-fetch-field field)))))
|
|
|
|
;;; Gnus
|
|
(eval-when-compile
|
|
(defvar gnus-article-buffer)
|
|
(autoload 'gnus-summary-toggle-header "gnus-sum")
|
|
(autoload 'gnus-buffer-exists-p "gnus-util")
|
|
(autoload 'message-field-value "message")
|
|
(autoload 'gnus-group-read-ephemeral-group "gnus-group")
|
|
(autoload 'gnus-alive-p "gnus-util"))
|
|
|
|
;; Display function:
|
|
(defun mairix-gnus-ephemeral-nndoc (folder)
|
|
"Create ephemeral nndoc group for reading mbox file FOLDER in Gnus."
|
|
(unless (gnus-alive-p)
|
|
(error "Gnus is not running"))
|
|
(gnus-group-read-ephemeral-group
|
|
;; add randomness to group string to prevent Gnus from using a
|
|
;; cached version
|
|
(format "mairix.%s" (number-to-string (random 10000)))
|
|
`(nndoc "mairix"
|
|
(nndoc-address ,folder)
|
|
(nndoc-article-type mbox))))
|
|
|
|
;; Fetching mail header field:
|
|
(defun mairix-gnus-fetch-field (field)
|
|
"Get mail header FIELD for current message using Gnus."
|
|
(unless (gnus-alive-p)
|
|
(error "Gnus is not running"))
|
|
(unless (gnus-buffer-exists-p gnus-article-buffer)
|
|
(error "No article buffer available"))
|
|
(with-current-buffer gnus-article-buffer
|
|
(gnus-summary-toggle-header 1)
|
|
(message-field-value field)))
|
|
|
|
;;; VM
|
|
;;; written by Ulrich Mueller
|
|
|
|
(eval-when-compile
|
|
(autoload 'vm-quit "vm-folder")
|
|
(autoload 'vm-visit-folder "vm")
|
|
(autoload 'vm-select-folder-buffer "vm-macro")
|
|
(autoload 'vm-check-for-killed-summary "vm-misc")
|
|
(autoload 'vm-get-header-contents "vm-summary")
|
|
(autoload 'vm-check-for-killed-summary "vm-misc")
|
|
(autoload 'vm-error-if-folder-empty "vm-misc")
|
|
(autoload 'vm-select-marked-or-prefixed-messages "vm-folder"))
|
|
|
|
;; Display function
|
|
(defun mairix-vm-display (folder)
|
|
"Display mbox file FOLDER with VM."
|
|
(require 'vm)
|
|
;; check if folder is already open and if so, kill it
|
|
(let ((buf (get-file-buffer folder)))
|
|
(when buf
|
|
(set-buffer buf)
|
|
(set-buffer-modified-p nil)
|
|
(condition-case nil
|
|
(vm-quit t)
|
|
(error nil))
|
|
(kill-buffer buf)))
|
|
(vm-visit-folder folder t))
|
|
|
|
;; Fetching mail header field
|
|
(defun mairix-vm-fetch-field (field)
|
|
"Get mail header FIELD for current message using VM."
|
|
(save-excursion
|
|
(vm-select-folder-buffer)
|
|
(vm-check-for-killed-summary)
|
|
(vm-error-if-folder-empty)
|
|
(vm-get-header-contents
|
|
(car (vm-select-marked-or-prefixed-messages 1)) field)))
|
|
|
|
;;;; Main interactive functions
|
|
|
|
(defun mairix-search (search threads)
|
|
"Call Mairix with SEARCH.
|
|
If THREADS is non-nil, also display whole threads of found
|
|
messages. Results will be put into the default search file."
|
|
(interactive
|
|
(list
|
|
(read-string "Query: ")
|
|
(y-or-n-p "Include threads? ")))
|
|
(when (mairix-call-mairix
|
|
(split-string search)
|
|
nil
|
|
threads)
|
|
(mairix-show-folder mairix-search-file)))
|
|
|
|
(defun mairix-use-saved-search ()
|
|
"Use a saved search for querying Mairix."
|
|
(interactive)
|
|
(let* ((completions
|
|
(mapcar (lambda (el) (list (car el))) mairix-saved-searches))
|
|
(search (completing-read "Name of search: " completions))
|
|
(query (assoc search mairix-saved-searches))
|
|
(folder (nth 2 query)))
|
|
(when (not folder)
|
|
(setq folder mairix-search-file))
|
|
(when query
|
|
(mairix-call-mairix
|
|
(split-string (nth 1 query))
|
|
folder
|
|
(car (last query)))
|
|
(mairix-show-folder folder))))
|
|
|
|
(defun mairix-save-search ()
|
|
"Save the last search."
|
|
(interactive)
|
|
(let* ((name (read-string "Name of the search: "))
|
|
(exist (assoc name mairix-saved-searches)))
|
|
(if (not exist)
|
|
(add-to-list 'mairix-saved-searches
|
|
(append (list name) mairix-last-search))
|
|
(when
|
|
(y-or-n-p
|
|
"There is already a search with this name. \
|
|
Overwrite existing entry? ")
|
|
(setcdr (assoc name mairix-saved-searches) mairix-last-search))))
|
|
(mairix-select-save))
|
|
|
|
(defun mairix-edit-saved-searches-customize ()
|
|
"Edit the list of saved searches in a customization buffer."
|
|
(interactive)
|
|
(custom-buffer-create (list (list 'mairix-saved-searches 'custom-variable))
|
|
"*Customize Mairix Query*"
|
|
(concat "\n\n" (make-string 65 ?=)
|
|
"\nYou can now customize your saved Mairix searches by modifying\n\
|
|
the variable mairix-saved-searches. Don't forget to save your\nchanges \
|
|
in your .emacs by pressing 'Save for Future Sessions'.\n"
|
|
(make-string 65 ?=) "\n")))
|
|
|
|
(autoload 'mail-strip-quoted-names "mail-utils")
|
|
(defun mairix-search-from-this-article (threads)
|
|
"Search messages from sender of the current article.
|
|
This is effectively a shortcut for calling `mairix-search' with
|
|
f:current_from. If prefix THREADS is non-nil, include whole
|
|
threads."
|
|
(interactive "P")
|
|
(let ((get-mail-header
|
|
(cadr (assq mairix-mail-program mairix-get-mail-header-functions))))
|
|
(if get-mail-header
|
|
(mairix-search
|
|
(format "f:%s"
|
|
(mail-strip-quoted-names
|
|
(funcall get-mail-header "from")))
|
|
threads)
|
|
(error "No function for obtaining mail header specified"))))
|
|
|
|
(defun mairix-search-thread-this-article ()
|
|
"Search thread for the current article.
|
|
This is effectively a shortcut for calling `mairix-search'
|
|
with m:msgid of the current article and enabled threads."
|
|
(interactive)
|
|
(let ((get-mail-header
|
|
(cadr (assq mairix-mail-program mairix-get-mail-header-functions)))
|
|
mid)
|
|
(unless get-mail-header
|
|
(error "No function for obtaining mail header specified"))
|
|
(setq mid (funcall get-mail-header "message-id"))
|
|
(while (string-match "[<>]" mid)
|
|
(setq mid (replace-match "" t t mid)))
|
|
;; mairix somehow does not like '$' in message-id
|
|
(when (string-match "\\$" mid)
|
|
(setq mid (concat mid "=")))
|
|
(while (string-match "\\$" mid)
|
|
(setq mid (replace-match "=," t t mid)))
|
|
(mairix-search
|
|
(format "m:%s" mid) t)))
|
|
|
|
(defun mairix-widget-search-based-on-article ()
|
|
"Create mairix query based on current article using widgets."
|
|
(interactive)
|
|
(mairix-widget-search
|
|
(mairix-widget-get-values)))
|
|
|
|
(defun mairix-edit-saved-searches ()
|
|
"Edit current mairix searches."
|
|
(interactive)
|
|
(switch-to-buffer mairix-saved-searches-buffer)
|
|
(erase-buffer)
|
|
(setq mairix-searches-changed nil)
|
|
(mairix-build-search-list)
|
|
(mairix-searches-mode)
|
|
(hl-line-mode))
|
|
|
|
(defvar mairix-widgets)
|
|
|
|
(defun mairix-widget-search (&optional mvalues)
|
|
"Create mairix query interactively using graphical widgets.
|
|
MVALUES may contain values from current article."
|
|
(interactive)
|
|
;; Select window for mairix customization
|
|
(funcall mairix-widget-select-window-function)
|
|
;; generate widgets
|
|
(mairix-widget-create-query mvalues)
|
|
;; generate Buttons
|
|
(widget-create 'push-button
|
|
:notify
|
|
(lambda (&rest ignore)
|
|
(mairix-widget-send-query mairix-widgets))
|
|
"Send Query")
|
|
(widget-insert " ")
|
|
(widget-create 'push-button
|
|
:notify
|
|
(lambda (&rest ignore)
|
|
(mairix-widget-save-search mairix-widgets))
|
|
"Save search")
|
|
(widget-insert " ")
|
|
(widget-create 'push-button
|
|
:notify (lambda (&rest ignore)
|
|
(kill-buffer mairix-customize-query-buffer))
|
|
"Cancel")
|
|
(use-local-map widget-keymap)
|
|
(widget-setup)
|
|
(goto-char (point-min)))
|
|
|
|
(defun mairix-update-database ()
|
|
"Call mairix for updating the database for SERVERS.
|
|
Mairix will be called asynchronously unless
|
|
`mairix-synchronous-update' is t. Mairix will be called with
|
|
`mairix-update-options'."
|
|
(interactive)
|
|
(let ((commandsplit (split-string mairix-command))
|
|
args)
|
|
(if mairix-synchronous-update
|
|
(progn
|
|
(setq args (append (list (car commandsplit) nil
|
|
(get-buffer-create mairix-output-buffer)
|
|
nil)))
|
|
(if (> (length commandsplit) 1)
|
|
(setq args (append args
|
|
(cdr commandsplit)
|
|
mairix-update-options))
|
|
(setq args (append args mairix-update-options)))
|
|
(apply 'call-process args))
|
|
(progn
|
|
(message "Updating mairix database...")
|
|
(setq args (append (list "mairixupdate" (get-buffer-create mairix-output-buffer)
|
|
(car commandsplit))))
|
|
(if (> (length commandsplit) 1)
|
|
(setq args (append args (cdr commandsplit) mairix-update-options))
|
|
(setq args (append args mairix-update-options)))
|
|
(set-process-sentinel
|
|
(apply 'start-process args)
|
|
'mairix-sentinel-mairix-update-finished)))))
|
|
|
|
|
|
;;;; Helper functions
|
|
|
|
(defun mairix-show-folder (folder)
|
|
"Display mail FOLDER with mail program.
|
|
The mail program is given by `mairix-mail-program'."
|
|
(let ((display-function
|
|
(cadr (assq mairix-mail-program mairix-display-functions))))
|
|
(if display-function
|
|
(funcall display-function
|
|
(concat
|
|
(file-name-as-directory
|
|
(expand-file-name mairix-file-path))
|
|
folder))
|
|
(error "No mail program set"))))
|
|
|
|
(defun mairix-call-mairix (query file threads)
|
|
"Call Mairix with QUERY and output FILE.
|
|
If FILE is nil, use default. If THREADS is non-nil, also return
|
|
whole threads. Function returns t if messages were found."
|
|
(let* ((commandsplit (split-string mairix-command))
|
|
(args (cons (car commandsplit)
|
|
`(nil ,(get-buffer-create mairix-output-buffer) nil)))
|
|
rval)
|
|
(with-current-buffer mairix-output-buffer
|
|
(erase-buffer))
|
|
(when (> (length commandsplit) 1)
|
|
(setq args (append args (cdr commandsplit))))
|
|
(when threads
|
|
(setq args (append args '("-t"))))
|
|
(when (stringp query)
|
|
(setq query (split-string query)))
|
|
(setq mairix-last-search (list (mapconcat 'identity query " ")
|
|
file threads))
|
|
(when (not file)
|
|
(setq file mairix-search-file))
|
|
(setq file
|
|
(concat
|
|
(file-name-as-directory
|
|
(expand-file-name
|
|
mairix-file-path))
|
|
file))
|
|
(setq rval
|
|
(apply 'call-process
|
|
(append args (list "-o" file) query)))
|
|
(if (zerop rval)
|
|
(with-current-buffer mairix-output-buffer
|
|
(goto-char (point-min))
|
|
(re-search-forward "^Matched.*messages")
|
|
(message (match-string 0)))
|
|
(if (and (= rval 1)
|
|
(with-current-buffer mairix-output-buffer
|
|
(goto-char (point-min))
|
|
(looking-at "^Matched 0 messages")))
|
|
(message "No messages found")
|
|
(error "Error running Mairix. See buffer %s for details"
|
|
mairix-output-buffer)))
|
|
(zerop rval)))
|
|
|
|
(defun mairix-replace-illegal-chars (header)
|
|
"Replace illegal characters in HEADER for mairix query."
|
|
(when header
|
|
(while (string-match "[^-.@/,& [:alnum:]]" header)
|
|
(setq header (replace-match "" t t header)))
|
|
(while (string-match "[& ]" header)
|
|
(setq header (replace-match "," t t header)))
|
|
header))
|
|
|
|
(defun mairix-sentinel-mairix-update-finished (proc status)
|
|
"Sentinel for mairix update process PROC with STATUS."
|
|
(if (equal status "finished\n")
|
|
(message "Updating mairix database... done")
|
|
(error "There was an error updating the mairix database. \
|
|
See %s for details" mairix-output-buffer)))
|
|
|
|
|
|
;;;; Widget stuff
|
|
|
|
|
|
|
|
(defun mairix-widget-send-query (widgets)
|
|
"Send query from WIDGETS to mairix binary."
|
|
(mairix-search
|
|
(mairix-widget-make-query-from-widgets widgets)
|
|
(if (widget-value (cadr (assoc "Threads" widgets))) t))
|
|
(kill-buffer mairix-customize-query-buffer))
|
|
|
|
(defun mairix-widget-save-search (widgets)
|
|
"Save search based on WIDGETS for future use."
|
|
(let ((mairix-last-search
|
|
`( ,(mairix-widget-make-query-from-widgets widgets)
|
|
nil
|
|
,(widget-value (cadr (assoc "Threads" widgets))))))
|
|
(mairix-save-search)
|
|
(kill-buffer mairix-customize-query-buffer)))
|
|
|
|
(defun mairix-widget-make-query-from-widgets (widgets)
|
|
"Create mairix query from widget values WIDGETS."
|
|
(let (query temp flag)
|
|
;; first we do the editable fields
|
|
(dolist (cur mairix-widget-fields-list)
|
|
;; See if checkbox is checked
|
|
(when (widget-value
|
|
(cadr (assoc (concat "c" (car (cddr cur))) widgets)))
|
|
;; create query for the field
|
|
(push
|
|
(concat
|
|
(nth 1 cur)
|
|
":"
|
|
(mairix-replace-illegal-chars
|
|
(widget-value
|
|
(cadr (assoc (concat "e" (car (cddr cur))) widgets)))))
|
|
query)))
|
|
;; Flags
|
|
(when (member 'flags mairix-widget-other)
|
|
(setq flag
|
|
(mapconcat
|
|
(function
|
|
(lambda (flag)
|
|
(setq temp
|
|
(widget-value (cadr (assoc (car flag) mairix-widgets))))
|
|
(if (string= "yes" temp)
|
|
(cadr flag)
|
|
(if (string= "no" temp)
|
|
(concat "-" (cadr flag))))))
|
|
'(("seen" "s") ("replied" "r") ("flagged" "f")) ""))
|
|
(when (not (zerop (length flag)))
|
|
(push (concat "F:" flag) query)))
|
|
;; return query string
|
|
(mapconcat 'identity query " ")))
|
|
|
|
(defun mairix-widget-create-query (&optional values)
|
|
"Create widgets for creating mairix queries.
|
|
Fill in VALUES if based on an article."
|
|
(let (allwidgets)
|
|
(when (get-buffer mairix-customize-query-buffer)
|
|
(kill-buffer mairix-customize-query-buffer))
|
|
(switch-to-buffer mairix-customize-query-buffer)
|
|
(kill-all-local-variables)
|
|
(erase-buffer)
|
|
(widget-insert
|
|
"Specify your query for Mairix (check boxes for activating fields):\n\n")
|
|
(widget-insert
|
|
"(Whitespaces will be converted to ',' (i.e. AND). Use '/' for OR.)\n\n")
|
|
(setq mairix-widgets (mairix-widget-build-editable-fields values))
|
|
(when (member 'flags mairix-widget-other)
|
|
(widget-insert "\nFlags:\n Seen: ")
|
|
(mairix-widget-add "seen"
|
|
'menu-choice
|
|
:value "ignore"
|
|
'(item "yes") '(item "no") '(item "ignore"))
|
|
(widget-insert " Replied: ")
|
|
(mairix-widget-add "replied"
|
|
'menu-choice
|
|
:value "ignore"
|
|
'(item "yes") '(item "no") '(item "ignore"))
|
|
(widget-insert " Ticked: ")
|
|
(mairix-widget-add "flagged"
|
|
'menu-choice
|
|
:value "ignore"
|
|
'(item "yes") '(item "no") '(item "ignore")))
|
|
(when (member 'threads mairix-widget-other)
|
|
(widget-insert "\n")
|
|
(mairix-widget-add "Threads" 'checkbox nil))
|
|
(widget-insert " Show full threads\n\n")))
|
|
|
|
(defun mairix-widget-build-editable-fields (values)
|
|
"Build editable field widgets in `nnmairix-widget-fields-list'.
|
|
VALUES may contain values for editable fields from current article."
|
|
(let ((ret))
|
|
(mapc
|
|
(function
|
|
(lambda (field)
|
|
(setq field (car (cddr field)))
|
|
(setq
|
|
ret
|
|
(nconc
|
|
(list
|
|
(list
|
|
(concat "c" field)
|
|
(widget-create 'checkbox
|
|
:tag field
|
|
:notify (lambda (widget &rest ignore)
|
|
(mairix-widget-toggle-activate widget))
|
|
nil)))
|
|
(list
|
|
(list
|
|
(concat "e" field)
|
|
(widget-create 'editable-field
|
|
:size 60
|
|
:format (concat " " field ":"
|
|
(make-string
|
|
(- 11 (length field)) ?\ )
|
|
"%v")
|
|
:value (or (cadr (assoc field values)) ""))))
|
|
ret))
|
|
(widget-insert "\n")
|
|
;; Deactivate editable field
|
|
(widget-apply (cadr (nth 1 ret)) :deactivate)))
|
|
mairix-widget-fields-list)
|
|
ret))
|
|
|
|
(defun mairix-widget-add (name &rest args)
|
|
"Add a widget NAME with optional ARGS."
|
|
(push
|
|
(list name
|
|
(apply 'widget-create args))
|
|
mairix-widgets))
|
|
|
|
(defun mairix-widget-toggle-activate (widget)
|
|
"Toggle activation status of WIDGET depending on checkbox value."
|
|
(let ((field (widget-get widget :tag)))
|
|
(if (widget-value widget)
|
|
(widget-apply
|
|
(cadr (assoc (concat "e" field) mairix-widgets))
|
|
:activate)
|
|
(widget-apply
|
|
(cadr (assoc (concat "e" field) mairix-widgets))
|
|
:deactivate)))
|
|
(widget-setup))
|
|
|
|
|
|
;;;; Major mode for editing/deleting/saving searches
|
|
|
|
(defvar mairix-searches-mode-map nil "'mairix-searches-mode' keymap.")
|
|
|
|
;; Keymap
|
|
(if (not mairix-searches-mode-map)
|
|
(let ((map (make-keymap)))
|
|
(define-key map [(return)] 'mairix-select-search)
|
|
(define-key map [(down)] 'mairix-next-search)
|
|
(define-key map [(up)] 'mairix-previous-search)
|
|
(define-key map [(right)] 'mairix-next-search)
|
|
(define-key map [(left)] 'mairix-previous-search)
|
|
(define-key map "\C-p" 'mairix-previous-search)
|
|
(define-key map "\C-n" 'mairix-next-search)
|
|
(define-key map [(q)] 'mairix-select-quit)
|
|
(define-key map [(e)] 'mairix-select-edit)
|
|
(define-key map [(d)] 'mairix-select-delete)
|
|
(define-key map [(s)] 'mairix-select-save)
|
|
(setq mairix-searches-mode-map map)))
|
|
|
|
(defvar mairix-searches-mode-font-lock-keywords)
|
|
|
|
(defun mairix-searches-mode ()
|
|
"Major mode for editing mairix searches."
|
|
(interactive)
|
|
(kill-all-local-variables)
|
|
(setq major-mode 'mairix-searches-mode)
|
|
(setq mode-name "mairix-searches")
|
|
(set-syntax-table text-mode-syntax-table)
|
|
(use-local-map mairix-searches-mode-map)
|
|
(make-local-variable 'font-lock-defaults)
|
|
(setq mairix-searches-mode-font-lock-keywords
|
|
(list (list "^\\([0-9]+\\)"
|
|
'(1 font-lock-constant-face))
|
|
(list "^[0-9 ]+\\(Name:\\) \\(.*\\)"
|
|
'(1 font-lock-keyword-face) '(2 font-lock-string-face))
|
|
(list "^[ ]+\\(Query:\\) \\(.*\\) , "
|
|
'(1 font-lock-keyword-face) '(2 font-lock-string-face))
|
|
(list ", \\(Threads:\\) \\(.*\\)"
|
|
'(1 font-lock-keyword-face) '(2 font-lock-constant-face))
|
|
(list "^\\([A-Z].*\\)$"
|
|
'(1 font-lock-comment-face))
|
|
(list "^[ ]+\\(Folder:\\) \\(.*\\)"
|
|
'(1 font-lock-keyword-face) '(2 font-lock-string-face))))
|
|
(setq font-lock-defaults '(mairix-searches-mode-font-lock-keywords)))
|
|
|
|
(defun mairix-build-search-list ()
|
|
"Display saved searches in current buffer."
|
|
(insert "These are your current saved mairix searches.\n\
|
|
You may use the following keys in this buffer: \n\
|
|
Return: execute search, e: edit, d: delete, s: save, q: quit\n\
|
|
Use cursor keys or C-n,C-p to select next/previous search.\n\n")
|
|
(let ((num 0)
|
|
(beg (point))
|
|
current)
|
|
(while (< num (length mairix-saved-searches))
|
|
(setq current (nth num mairix-saved-searches))
|
|
(setq num (1+ num))
|
|
(mairix-insert-search-line num current)
|
|
(insert "\n"))
|
|
(goto-char beg)))
|
|
|
|
(defun mairix-insert-search-line (number field)
|
|
"Insert new mairix query with NUMBER and values FIELD in buffer."
|
|
(insert
|
|
(format "%d Name: %s\n Query: %s , Threads: %s\n Folder: %s\n"
|
|
number
|
|
(car field)
|
|
(nth 1 field)
|
|
(if (nth 3 field)
|
|
"Yes"
|
|
"No")
|
|
(if (nth 2 field)
|
|
(nth 2 field)
|
|
"Default"))))
|
|
|
|
(defun mairix-select-search ()
|
|
"Call mairix with currently selected search."
|
|
(interactive)
|
|
(beginning-of-line)
|
|
(if (not (looking-at "[0-9]+ Name"))
|
|
(progn
|
|
(ding)
|
|
(message "Put cursor on a line with a search name first"))
|
|
(progn
|
|
(let* ((query (nth
|
|
(1- (read (current-buffer)))
|
|
mairix-saved-searches))
|
|
(folder (nth 2 query)))
|
|
(when (not folder)
|
|
(setq folder mairix-search-file))
|
|
(mairix-call-mairix
|
|
(split-string (nth 1 query))
|
|
folder
|
|
(car (last query)))
|
|
(mairix-select-quit)
|
|
(mairix-show-folder folder)))))
|
|
|
|
(defun mairix-next-search ()
|
|
"Jump to next search."
|
|
(interactive)
|
|
(if (search-forward-regexp "^[0-9]+"
|
|
(point-max)
|
|
t
|
|
2)
|
|
(beginning-of-line)
|
|
(ding)))
|
|
|
|
(defun mairix-previous-search ()
|
|
"Jump to previous search."
|
|
(interactive)
|
|
(if (search-backward-regexp "^[0-9]+"
|
|
(point-min)
|
|
t)
|
|
(beginning-of-line)
|
|
(ding)))
|
|
|
|
(defun mairix-select-quit ()
|
|
"Quit mairix search mode."
|
|
(interactive)
|
|
(when mairix-searches-changed
|
|
(mairix-select-save))
|
|
(kill-buffer nil))
|
|
|
|
(defun mairix-select-save ()
|
|
"Save current mairix searches."
|
|
(interactive)
|
|
(when (y-or-n-p "Save mairix searches permanently in your .emacs? ")
|
|
(customize-save-variable 'mairix-saved-searches mairix-saved-searches)))
|
|
|
|
(defun mairix-select-edit ()
|
|
"Edit currently selected mairix search."
|
|
(interactive)
|
|
(beginning-of-line)
|
|
(if (not (looking-at "[0-9]+ Name"))
|
|
(error "Put cursor on a line with a search name first")
|
|
(progn
|
|
(let* ((number (1- (read (current-buffer))))
|
|
(query (nth number mairix-saved-searches))
|
|
(folder (nth 2 query))
|
|
newname newquery newfolder threads)
|
|
(backward-char)
|
|
(setq newname (read-string "Name of the search: " (car query)))
|
|
(when (assoc newname (remq (nth number mairix-saved-searches)
|
|
mairix-saved-searches))
|
|
(error "This name does already exist"))
|
|
(setq newquery (read-string "Query: " (nth 1 query)))
|
|
(setq threads (y-or-n-p "Include whole threads? "))
|
|
(setq newfolder
|
|
(read-string "Mail folder (use empty string for default): "
|
|
folder))
|
|
(when (zerop (length newfolder))
|
|
(setq newfolder nil))
|
|
;; set new values
|
|
(setcar (nth number mairix-saved-searches) newname)
|
|
(setcdr (nth number mairix-saved-searches)
|
|
(list newquery newfolder threads))
|
|
(setq mairix-searches-changed t)
|
|
(let ((beg (point)))
|
|
(forward-line 3)
|
|
(end-of-line)
|
|
(delete-region beg (point))
|
|
(mairix-insert-search-line (1+ number)
|
|
(nth number mairix-saved-searches))
|
|
(goto-char beg))))))
|
|
|
|
(defun mairix-select-delete ()
|
|
"Delete currently selected mairix search."
|
|
(interactive)
|
|
(if (not (looking-at "[0-9]+ Name"))
|
|
(error "Put cursor on a line with a search name first")
|
|
(progn
|
|
(let* ((number (1- (read (current-buffer))))
|
|
(query (nth number mairix-saved-searches))
|
|
beg)
|
|
(backward-char)
|
|
(when (y-or-n-p (format "Delete search %s ? " (car query)))
|
|
(setq mairix-saved-searches
|
|
(delq query mairix-saved-searches))
|
|
(setq mairix-searches-changed t)
|
|
(setq beg (point))
|
|
(forward-line 4)
|
|
(beginning-of-line)
|
|
(delete-region beg (point))
|
|
(while (search-forward-regexp "^[0-9]+"
|
|
(point-max)
|
|
t
|
|
1)
|
|
(replace-match (number-to-string
|
|
(setq number (1+ number)))))))
|
|
(beginning-of-line))))
|
|
|
|
(defun mairix-widget-get-values ()
|
|
"Create values for editable fields from current article."
|
|
(let ((get-mail-header
|
|
(cadr (assq mairix-mail-program mairix-get-mail-header-functions))))
|
|
(if get-mail-header
|
|
(save-excursion
|
|
(save-restriction
|
|
(mapcar
|
|
(function
|
|
(lambda (field)
|
|
(list (car (cddr field))
|
|
(if (car field)
|
|
(mairix-replace-illegal-chars
|
|
(funcall get-mail-header (car field)))
|
|
nil))))
|
|
mairix-widget-fields-list)))
|
|
(error "No function for obtaining mail header specified"))))
|
|
|
|
|
|
(provide 'mairix)
|
|
|
|
;;; mairix.el ends here
|
|
|
|
;; arch-tag: 787ab678-fcd5-4c50-9295-01c2ee5124a6
|