X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=emacs%2Fnotmuch-hello.el;h=d17a30f91e0c830dc3e394c97ff48b666401936d;hp=936d5466cad153c8462122b551ac353157d16c1e;hb=d0a048f8561f63de5e30cb23dec6b6facb79c851;hpb=7df0e611df9275bf2330bc73895e2d729a157adc

diff --git a/emacs/notmuch-hello.el b/emacs/notmuch-hello.el
index 936d5466..d17a30f9 100644
--- a/emacs/notmuch-hello.el
+++ b/emacs/notmuch-hello.el
@@ -19,48 +19,79 @@
 ;;
 ;; Authors: David Edmondson <dme@dme.org>
 
+(eval-when-compile (require 'cl))
 (require 'widget)
 (require 'wid-edit) ; For `widget-forward'.
-(require 'cl)
 
 (require 'notmuch-lib)
 (require 'notmuch-mua)
 
 (declare-function notmuch-search "notmuch" (query &optional oldest-first target-thread target-line continuation))
-(declare-function notmuch-folder-count "notmuch" (search))
-
-(defvar notmuch-hello-search-bar-marker nil
-  "The position of the search bar within the notmuch-hello buffer.")
+(declare-function notmuch-poll "notmuch" ())
 
 (defcustom notmuch-hello-recent-searches-max 10
-  "The number of recent searches to store and display."
+  "The number of recent searches to display."
   :type 'integer
-  :group 'notmuch)
+  :group 'notmuch-hello)
 
-(defcustom notmuch-hello-show-empty-saved-searches nil
+(defcustom notmuch-show-empty-saved-searches nil
   "Should saved searches with no messages be listed?"
   :type 'boolean
-  :group 'notmuch)
-
-(defcustom notmuch-hello-indent 4
-  "How much to indent non-headers."
-  :type 'integer
-  :group 'notmuch)
-
-(defcustom notmuch-hello-saved-searches notmuch-folders
-  "A list of saved searches to display."
-  :type '(alist :key-type string :value-type string)
-  :group 'notmuch)
-
-(defcustom notmuch-hello-show-logo t
+  :group 'notmuch-hello)
+
+(defun notmuch-sort-saved-searches (alist)
+  "Generate an alphabetically sorted saved searches alist."
+  (sort alist (lambda (a b) (string< (car a) (car b)))))
+
+(defcustom notmuch-saved-search-sort-function nil
+  "Function used to sort the saved searches for the notmuch-hello view.
+
+This variable controls how saved searches should be sorted. No
+sorting (nil) displays the saved searches in the order they are
+stored in `notmuch-saved-searches'. Sort alphabetically sorts the
+saved searches in alphabetical order. Custom sort function should
+be a function or a lambda expression that takes the saved
+searches alist as a parameter, and returns a new saved searches
+alist to be used."
+  :type '(choice (const :tag "No sorting" nil)
+		 (const :tag "Sort alphabetically" notmuch-sort-saved-searches)
+		 (function :tag "Custom sort function"
+			   :value notmuch-sort-saved-searches))
+  :group 'notmuch-hello)
+
+(defvar notmuch-hello-indent 4
+  "How much to indent non-headers.")
+
+(defcustom notmuch-show-logo t
   "Should the notmuch logo be shown?"
   :type 'boolean
-  :group 'notmuch)
+  :group 'notmuch-hello)
 
-(defcustom notmuch-hello-show-tags nil
+(defcustom notmuch-show-all-tags-list nil
   "Should all tags be shown in the notmuch-hello view?"
   :type 'boolean
-  :group 'notmuch)
+  :group 'notmuch-hello)
+
+(defcustom notmuch-hello-tag-list-make-query nil
+  "Function or string to generate queries for the all tags list.
+
+This variable controls which query results are shown for each tag
+in the \"all tags\" list. If nil, it will use all messages with
+that tag. If this is set to a string, it is used as a filter for
+messages having that tag (equivalent to \"tag:TAG and (THIS-VARIABLE)\").
+Finally this can be a function that will be called for each tag and
+should return a filter for that tag, or nil to hide the tag."
+  :type '(choice (const :tag "All messages" nil)
+		 (const :tag "Unread messages" "tag:unread")
+		 (string :tag "Custom filter"
+			 :value "tag:unread")
+		 (function :tag "Custom filter function"))
+  :group 'notmuch-hello)
+
+(defcustom notmuch-hello-hide-tags nil
+  "List of tags to be hidden in the \"all tags\"-section."
+  :type '(repeat string)
+  :group 'notmuch-hello)
 
 (defface notmuch-hello-logo-background
   '((((class color)
@@ -70,19 +101,70 @@
       (background light))
      (:background "white")))
   "Background colour for the notmuch logo."
-  :group 'notmuch)
+  :group 'notmuch-hello
+  :group 'notmuch-faces)
+
+(defcustom notmuch-column-control t
+  "Controls the number of columns for saved searches/tags in notmuch view.
+
+This variable has three potential sets of values:
+
+- t: automatically calculate the number of columns possible based
+  on the tags to be shown and the window width,
+- an integer: a lower bound on the number of characters that will
+  be used to display each column,
+- a float: a fraction of the window width that is the lower bound
+  on the number of characters that should be used for each
+  column.
+
+So:
+- if you would like two columns of tags, set this to 0.5.
+- if you would like a single column of tags, set this to 1.0.
+- if you would like tags to be 30 characters wide, set this to
+  30.
+- if you don't want to worry about all of this nonsense, leave
+  this set to `t'."
+  :type '(choice
+	  (const :tag "Automatically calculated" t)
+	  (integer :tag "Number of characters")
+	  (float :tag "Fraction of window"))
+  :group 'notmuch-hello)
+
+(defcustom notmuch-hello-thousands-separator " "
+  "The string used as a thousands separator.
+
+Typically \",\" in the US and UK and \".\" or \" \" in Europe.
+The latter is recommended in the SI/ISO 31-0 standard and by the
+International Bureau of Weights and Measures."
+  :type 'string
+  :group 'notmuch-hello)
+
+(defcustom notmuch-hello-mode-hook nil
+  "Functions called after entering `notmuch-hello-mode'."
+  :type 'hook
+  :group 'notmuch-hello
+  :group 'notmuch-hooks)
+
+(defcustom notmuch-hello-refresh-hook nil
+  "Functions called after updating a `notmuch-hello' buffer."
+  :type 'hook
+  :group 'notmuch-hello
+  :group 'notmuch-hooks)
 
 (defvar notmuch-hello-url "http://notmuchmail.org"
   "The `notmuch' web site.")
 
-(defvar notmuch-hello-recent-searches nil)
-
-(defun notmuch-hello-remember-search (search)
-  (if (not (member search notmuch-hello-recent-searches))
-      (push search notmuch-hello-recent-searches))
-  (if (> (length notmuch-hello-recent-searches)
-	 notmuch-hello-recent-searches-max)
-      (setq notmuch-hello-recent-searches (butlast notmuch-hello-recent-searches))))
+(defun notmuch-hello-nice-number (n)
+  (let (result)
+    (while (> n 0)
+      (push (% n 1000) result)
+      (setq n (/ n 1000)))
+    (setq result (or result '(0)))
+    (apply #'concat
+     (number-to-string (car result))
+     (mapcar (lambda (elem)
+	      (format "%s%03d" notmuch-hello-thousands-separator elem))
+	     (cdr result)))))
 
 (defun notmuch-hello-trim (search)
   "Trim whitespace."
@@ -90,10 +172,14 @@
       (match-string 1 search)
     search))
 
-(defun notmuch-hello-search (search)
-  (let ((search (notmuch-hello-trim search)))
-    (notmuch-hello-remember-search search)
-    (notmuch-search search notmuch-search-oldest-first nil nil #'notmuch-hello-search-continuation)))
+(defun notmuch-hello-search (&optional search)
+  (interactive)
+  (unless (null search)
+    (setq search (notmuch-hello-trim search))
+    (let ((history-delete-duplicates t))
+      (add-to-history 'notmuch-search-history search)))
+  (notmuch-search search notmuch-search-oldest-first nil nil
+		  #'notmuch-hello-search-continuation))
 
 (defun notmuch-hello-add-saved-search (widget)
   (interactive)
@@ -101,17 +187,17 @@
 		 (symbol-value
 		  (widget-get widget :notmuch-saved-search-widget))))
 	(name (completing-read "Name for saved search: "
-			       notmuch-hello-saved-searches)))
+			       notmuch-saved-searches)))
     ;; If an existing saved search with this name exists, remove it.
-    (setq notmuch-hello-saved-searches
-	  (loop for elem in notmuch-hello-saved-searches
+    (setq notmuch-saved-searches
+	  (loop for elem in notmuch-saved-searches
 		if (not (equal name
 			       (car elem)))
 		collect elem))
     ;; Add the new one.
-    (customize-save-variable 'notmuch-hello-saved-searches
-			     (push (cons name search)
-				   notmuch-hello-saved-searches))
+    (customize-save-variable 'notmuch-saved-searches
+			     (add-to-list 'notmuch-saved-searches
+					  (cons name search) t))
     (message "Saved '%s' as '%s'." search name)
     (notmuch-hello-update)))
 
@@ -120,28 +206,24 @@
 	    maximize (length (car elem)))
       0))
 
-(defun notmuch-hello-roundup (dividend divisor)
-  "Return the rounded up value of dividing `dividend' by `divisor'."
-  (+ (/ dividend divisor)
-     (if (> (% dividend divisor) 0) 1 0)))
-
-(defun notmuch-hello-reflect (list width)
-  "Reflect a `width' wide matrix represented by `list' along the
+(defun notmuch-hello-reflect-generate-row (ncols nrows row list)
+  (let ((len (length list)))
+    (loop for col from 0 to (- ncols 1)
+	  collect (let ((offset (+ (* nrows col) row)))
+		    (if (< offset len)
+			(nth offset list)
+		      ;; Don't forget to insert an empty slot in the
+		      ;; output matrix if there is no corresponding
+		      ;; value in the input matrix.
+		      nil)))))
+
+(defun notmuch-hello-reflect (list ncols)
+  "Reflect a `ncols' wide matrix represented by `list' along the
 diagonal."
   ;; Not very lispy...
-  (let* ((len (length list))
-	 (nrows (notmuch-hello-roundup len width)))
+  (let ((nrows (ceiling (length list) ncols)))
     (loop for row from 0 to (- nrows 1)
-	  append (loop for col from 0 to (- width 1)
-		       ;; How could we calculate the offset just once
-		       ;; per inner-loop?
-		       if (< (+ (* nrows col) row) len)
-		       collect (nth (+ (* nrows col) row) list)
-		       else
-		       ;; Don't forget to insert an empty slot in the
-		       ;; output matrix if there is no corresponding
-		       ;; value in the input matrix.
-		       collect nil))))
+	  append (notmuch-hello-reflect-generate-row ncols nrows row list))))
 
 (defun notmuch-hello-widget-search (widget &rest ignore)
   (notmuch-search (widget-get widget
@@ -149,12 +231,45 @@ diagonal."
 		  notmuch-search-oldest-first
 		  nil nil #'notmuch-hello-search-continuation))
 
+(defun notmuch-saved-search-count (search)
+  (car (process-lines notmuch-command "count" search)))
+
+(defun notmuch-hello-tags-per-line (widest)
+  "Determine how many tags to show per line and how wide they
+should be. Returns a cons cell `(tags-per-line width)'."
+  (let ((tags-per-line
+	 (cond
+	  ((integerp notmuch-column-control)
+	   (max 1
+		(/ (- (window-width) notmuch-hello-indent)
+		   ;; Count is 9 wide (8 digits plus space), 1 for the space
+		   ;; after the name.
+		   (+ 9 1 (max notmuch-column-control widest)))))
+
+	  ((floatp notmuch-column-control)
+	   (let* ((available-width (- (window-width) notmuch-hello-indent))
+		  (proposed-width (max (* available-width notmuch-column-control) widest)))
+	     (floor available-width proposed-width)))
+
+	  (t
+	   (max 1
+		(/ (- (window-width) notmuch-hello-indent)
+		   ;; Count is 9 wide (8 digits plus space), 1 for the space
+		   ;; after the name.
+		   (+ 9 1 widest)))))))
+
+    (cons tags-per-line (/ (max 1
+				(- (window-width) notmuch-hello-indent
+				   ;; Count is 9 wide (8 digits plus
+				   ;; space), 1 for the space after the
+				   ;; name.
+				   (* tags-per-line (+ 9 1))))
+			   tags-per-line))))
+
 (defun notmuch-hello-insert-tags (tag-alist widest target)
-  (let* ((tags-per-line (max 1
-			     (/ (- (window-width) notmuch-hello-indent)
-				;; Count is 7 wide, 1 for the space
-				;; after the name.
-				(+ 7 1 widest))))
+  (let* ((tags-and-width (notmuch-hello-tags-per-line widest))
+	 (tags-per-line (car tags-and-width))
+	 (widest (cdr tags-and-width))
 	 (count 0)
 	 (reordered-list (notmuch-hello-reflect tag-alist tags-per-line))
 	 ;; Hack the display of the buttons used.
@@ -163,47 +278,121 @@ diagonal."
 	 (found-target-pos nil))
     ;; dme: It feels as though there should be a better way to
     ;; implement this loop than using an incrementing counter.
-    (loop for elem in reordered-list
-	  do (progn
-	       ;; (not elem) indicates an empty slot in the matrix.
-	       (when elem
-		 (widget-insert (format "%6s " (notmuch-folder-count (cdr elem))))
-		 (if (string= (car elem) target)
-		     (progn
-		       (setq found-target-pos (point-marker))))
-		 (widget-create 'push-button
-				:notify #'notmuch-hello-widget-search
-				:notmuch-search-terms (cdr elem)
-				(car elem))
-		 (insert (make-string (- widest (length (car elem))) ? )))
-	       (setq count (1+ count))
-	       (if (eq (% count tags-per-line) 0)
-		   (widget-insert "\n"))))
+    (mapc (lambda (elem)
+	    ;; (not elem) indicates an empty slot in the matrix.
+	    (when elem
+	      (let* ((name (car elem))
+		     (query (cdr elem))
+		     (formatted-name (format "%s " name)))
+		(widget-insert (format "%8s "
+				       (notmuch-hello-nice-number
+					(string-to-number (notmuch-saved-search-count query)))))
+		(if (string= formatted-name target)
+		    (setq found-target-pos (point-marker)))
+		(widget-create 'push-button
+			       :notify #'notmuch-hello-widget-search
+			       :notmuch-search-terms query
+			       formatted-name)
+		(unless (eq (% count tags-per-line) (1- tags-per-line))
+		  ;; If this is not the last tag on the line, insert
+		  ;; enough space to consume the rest of the column.
+		  ;; Because the button for the name is `(1+ (length
+		  ;; name))' long (due to the trailing space) we can
+		  ;; just insert `(- widest (length name))' spaces - the
+		  ;; column separator is included in the button if
+		  ;; `(equal widest (length name)'.
+		  (widget-insert (make-string (max 1
+						   (- widest (length name)))
+					      ? )))))
+	    (setq count (1+ count))
+	    (if (eq (% count tags-per-line) 0)
+		(widget-insert "\n")))
+	  reordered-list)
 
     ;; If the last line was not full (and hence did not include a
     ;; carriage return), insert one now.
-    (if (not (eq (% count tags-per-line) 0))
-	(widget-insert "\n"))
+    (unless (eq (% count tags-per-line) 0)
+      (widget-insert "\n"))
     found-target-pos))
 
-(defun notmuch-hello-goto-search ()
-  "Put point inside the `search' widget."
-  (interactive)
-  (goto-char notmuch-hello-search-bar-marker))
-
 (defimage notmuch-hello-logo ((:type png :file "notmuch-logo.png")))
 
 (defun notmuch-hello-search-continuation()
   (notmuch-hello-update t))
 
 (defun notmuch-hello-update (&optional no-display)
+  "Update the current notmuch view."
   ;; Lazy - rebuild everything.
   (interactive)
   (notmuch-hello no-display))
 
+(defun notmuch-hello-poll-and-update ()
+  "Invoke `notmuch-poll' to import mail, then refresh the current view."
+  (interactive)
+  (notmuch-poll)
+  (notmuch-hello-update))
+
+
+(defvar notmuch-hello-mode-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map widget-keymap)
+    (define-key map "v" (lambda () "Display the notmuch version" (interactive)
+			  (message "notmuch version %s" (notmuch-version))))
+    (define-key map "?" 'notmuch-help)
+    (define-key map "q" 'notmuch-kill-this-buffer)
+    (define-key map "=" 'notmuch-hello-update)
+    (define-key map "G" 'notmuch-hello-poll-and-update)
+    (define-key map (kbd "<C-tab>") 'widget-backward)
+    (define-key map "m" 'notmuch-mua-new-mail)
+    (define-key map "s" 'notmuch-hello-search)
+    map)
+  "Keymap for \"notmuch hello\" buffers.")
+(fset 'notmuch-hello-mode-map notmuch-hello-mode-map)
+
+(defun notmuch-hello-mode ()
+ "Major mode for convenient notmuch navigation. This is your entry portal into notmuch.
+
+Complete list of currently available key bindings:
+
+\\{notmuch-hello-mode-map}"
+ (interactive)
+ (kill-all-local-variables)
+ (use-local-map notmuch-hello-mode-map)
+ (setq major-mode 'notmuch-hello-mode
+       mode-name "notmuch-hello")
+ (run-mode-hooks 'notmuch-hello-mode-hook)
+ ;;(setq buffer-read-only t)
+)
+
+(defun notmuch-hello-generate-tag-alist ()
+  "Return an alist from tags to queries to display in the all-tags section."
+  (notmuch-remove-if-not
+   #'cdr
+   (mapcar (lambda (tag)
+	     (cons tag
+		   (cond
+		    ((functionp notmuch-hello-tag-list-make-query)
+		     (concat "tag:" tag " and ("
+			     (funcall notmuch-hello-tag-list-make-query tag) ")"))
+		    ((stringp notmuch-hello-tag-list-make-query)
+		     (concat "tag:" tag " and ("
+			     notmuch-hello-tag-list-make-query ")"))
+		    (t (concat "tag:" tag)))))
+	   (notmuch-remove-if-not
+	    (lambda (tag)
+	      (not (member tag notmuch-hello-hide-tags)))
+	    (process-lines notmuch-command "search-tags")))))
+
+;;;###autoload
 (defun notmuch-hello (&optional no-display)
+  "Run notmuch and display saved searches, known tags, etc."
   (interactive)
 
+  ;; Jump through a hoop to get this value from the deprecated variable
+  ;; name (`notmuch-folders') or from the default value.
+  (unless notmuch-saved-searches
+    (setq notmuch-saved-searches (notmuch-saved-searches)))
+
   (if no-display
       (set-buffer "*notmuch-hello*")
     (switch-to-buffer "*notmuch-hello*"))
@@ -214,18 +403,26 @@ diagonal."
 		     (progn
 		       (widget-forward 1)
 		       (widget-value (widget-at)))
-		   (error nil)))))
+		   (error nil))))
+	(inhibit-read-only t))
+
+    ;; Delete all editable widget fields.  Editable widget fields are
+    ;; tracked in a buffer local variable `widget-field-list' (and
+    ;; others).  If we do `erase-buffer' without properly deleting the
+    ;; widgets, some widget-related functions are confused later.
+    (mapc 'widget-delete widget-field-list)
+
+    (erase-buffer)
 
-    (kill-all-local-variables)
-    (let ((inhibit-read-only t))
-      (erase-buffer))
+    (unless (eq major-mode 'notmuch-hello-mode)
+      (notmuch-hello-mode))
 
     (let ((all (overlay-lists)))
       ;; Delete all the overlays.
       (mapc 'delete-overlay (car all))
       (mapc 'delete-overlay (cdr all)))
 
-    (when notmuch-hello-show-logo
+    (when notmuch-show-logo
       (let ((image notmuch-hello-logo))
 	;; The notmuch logo uses transparency. That can display poorly
 	;; when inserting the image into an emacs buffer (black logo on
@@ -255,29 +452,34 @@ diagonal."
 		     :notify (lambda (&rest ignore)
 			       (notmuch-hello-update))
 		     :help-echo "Refresh"
-		     (car (process-lines notmuch-command "count")))
-      (widget-insert " messages (that's not much mail).\n\n"))
+		     (notmuch-hello-nice-number
+		      (string-to-number (car (process-lines notmuch-command "count")))))
+      (widget-insert " messages.\n"))
 
     (let ((found-target-pos nil)
-	  (final-target-pos nil))
+	  (final-target-pos nil)
+	  (default-pos))
       (let* ((saved-alist
-	      ;; Filter out empty saved seaches if required.
-	      (if notmuch-hello-show-empty-saved-searches
-		  notmuch-hello-saved-searches
-		(loop for elem in notmuch-hello-saved-searches
-		      if (> (string-to-number (notmuch-folder-count (cdr elem))) 0)
+	      ;; Filter out empty saved searches if required.
+	      (if notmuch-show-empty-saved-searches
+		  notmuch-saved-searches
+		(loop for elem in notmuch-saved-searches
+		      if (> (string-to-number (notmuch-saved-search-count (cdr elem))) 0)
 		      collect elem)))
 	     (saved-widest (notmuch-hello-longest-label saved-alist))
-	     (alltags-alist (mapcar '(lambda (tag) (cons tag (concat "tag:" tag)))
-				    (process-lines notmuch-command "search-tags")))
+	     (alltags-alist (if notmuch-show-all-tags-list (notmuch-hello-generate-tag-alist)))
 	     (alltags-widest (notmuch-hello-longest-label alltags-alist))
 	     (widest (max saved-widest alltags-widest)))
 
 	(when saved-alist
-	  (widget-insert "Saved searches: ")
+	  ;; Sort saved searches if required.
+	  (when notmuch-saved-search-sort-function
+	    (setq saved-alist
+		  (funcall notmuch-saved-search-sort-function saved-alist)))
+	  (widget-insert "\nSaved searches: ")
 	  (widget-create 'push-button
 			 :notify (lambda (&rest ignore)
-				   (customize-variable 'notmuch-hello-saved-searches))
+				   (customize-variable 'notmuch-saved-searches))
 			 "edit")
 	  (widget-insert "\n\n")
 	  (setq final-target-pos (point-marker))
@@ -287,110 +489,117 @@ diagonal."
 		(setq final-target-pos found-target-pos))
 	    (indent-rigidly start (point) notmuch-hello-indent)))
 
-	(let ((start (point)))
-	  (widget-insert "\nSearch: ")
-	  (setq notmuch-hello-search-bar-marker (point-marker))
-	  (widget-create 'editable-field
-			 ;; Leave some space at the start and end of the
-			 ;; search boxes.
-			 :size (max 8 (- (window-width) (* 2 notmuch-hello-indent)
-					 (length "Search: ")))
-			 :action (lambda (widget &rest ignore)
-				   (notmuch-hello-search (widget-value widget))))
-	  (widget-insert "\n")
-	  (indent-rigidly start (point) notmuch-hello-indent))
-
-	(when notmuch-hello-recent-searches
+	(widget-insert "\nSearch: ")
+	(setq default-pos (point-marker))
+	(widget-create 'editable-field
+		       ;; Leave some space at the start and end of the
+		       ;; search boxes.
+		       :size (max 8 (- (window-width) notmuch-hello-indent
+				       (length "Search: ")))
+		       :action (lambda (widget &rest ignore)
+				 (notmuch-hello-search (widget-value widget))))
+	;; Add an invisible dot to make `widget-end-of-line' ignore
+	;; trailing spaces in the search widget field.  A dot is used
+	;; instead of a space to make `show-trailing-whitespace'
+	;; happy, i.e. avoid it marking the whole line as trailing
+	;; spaces.
+	(widget-insert ".")
+	(put-text-property (1- (point)) (point) 'invisible t)
+	(widget-insert "\n")
+
+	(when notmuch-search-history
 	  (widget-insert "\nRecent searches: ")
 	  (widget-create 'push-button
 			 :notify (lambda (&rest ignore)
-				   (setq notmuch-hello-recent-searches nil)
+				   (setq notmuch-search-history nil)
 				   (notmuch-hello-update))
 			 "clear")
 	  (widget-insert "\n\n")
-	  (let ((start (point))
-		(nth 0))
-	    (mapc '(lambda (search)
-		     (let ((widget-symbol (intern (format "notmuch-hello-search-%d" nth))))
-		       (set widget-symbol
-			    (widget-create 'editable-field
-				       ;; Don't let the search boxes be
-				       ;; less than 8 characters wide.
-				       :size (max 8
-						  (- (window-width)
-						     ;; Leave some space
-						     ;; at the start and
-						     ;; end of the
-						     ;; boxes.
-						     (* 2 notmuch-hello-indent)
-						     ;; 1 for the space
-						     ;; before the
-						     ;; `[save]' button. 6
-						     ;; for the `[save]'
-						     ;; button.
-						     1 6))
-				       :action (lambda (widget &rest ignore)
-						 (notmuch-hello-search (widget-value widget)))
-				       search))
-		       (widget-insert " ")
-		       (widget-create 'push-button
-				      :notify (lambda (widget &rest ignore)
-						(notmuch-hello-add-saved-search widget))
-				      :notmuch-saved-search-widget widget-symbol
-				      "save"))
-		     (widget-insert "\n")
-		     (setq nth (1+ nth)))
-		  notmuch-hello-recent-searches)
+	  (let ((start (point)))
+	    (loop for i from 1 to notmuch-hello-recent-searches-max
+		  for search in notmuch-search-history do
+		    (let ((widget-symbol (intern (format "notmuch-hello-search-%d" i))))
+		      (set widget-symbol
+			   (widget-create 'editable-field
+					  ;; Don't let the search boxes be
+					  ;; less than 8 characters wide.
+					  :size (max 8
+						     (- (window-width)
+							;; Leave some space
+							;; at the start and
+							;; end of the
+							;; boxes.
+							(* 2 notmuch-hello-indent)
+							;; 1 for the space
+							;; before the
+							;; `[save]' button. 6
+							;; for the `[save]'
+							;; button.
+							1 6))
+					  :action (lambda (widget &rest ignore)
+						    (notmuch-hello-search (widget-value widget)))
+					  search))
+		      (widget-insert " ")
+		      (widget-create 'push-button
+				     :notify (lambda (widget &rest ignore)
+					       (notmuch-hello-add-saved-search widget))
+				     :notmuch-saved-search-widget widget-symbol
+				     "save"))
+		    (widget-insert "\n"))
 	    (indent-rigidly start (point) notmuch-hello-indent)))
 
 	(when alltags-alist
-	  (if notmuch-hello-show-tags
-	      (progn
-		(widget-insert "\nAll tags: ")
-		(widget-create 'push-button
-			       :notify (lambda (widget &rest ignore)
-					 (setq notmuch-hello-show-tags nil)
-					 (notmuch-hello-update))
-			       "hide")
-		(widget-insert "\n\n")
-		(let ((start (point)))
-		  (setq found-target-pos (notmuch-hello-insert-tags alltags-alist widest target))
-		  (if (not final-target-pos)
-		      (setq final-target-pos found-target-pos))
-		  (indent-rigidly start (point) notmuch-hello-indent)))
-	    (widget-insert "\n")
-	    (widget-create 'push-button
-			   :notify (lambda (widget &rest ignore)
-				     (setq notmuch-hello-show-tags t)
-				     (notmuch-hello-update))
-			   "Show all tags"))))
+	  (widget-insert "\nAll tags: ")
+	  (widget-create 'push-button
+			 :notify (lambda (widget &rest ignore)
+				   (setq notmuch-show-all-tags-list nil)
+				   (notmuch-hello-update))
+			 "hide")
+	  (widget-insert "\n\n")
+	  (let ((start (point)))
+	    (setq found-target-pos (notmuch-hello-insert-tags alltags-alist widest target))
+	    (unless final-target-pos
+	      (setq final-target-pos found-target-pos))
+	    (indent-rigidly start (point) notmuch-hello-indent)))
+
+	(widget-insert "\n")
+
+	(unless notmuch-show-all-tags-list
+	  (widget-create 'push-button
+			 :notify (lambda (widget &rest ignore)
+				   (setq notmuch-show-all-tags-list t)
+				   (notmuch-hello-update))
+			 "Show all tags")))
 
       (let ((start (point)))
 	(widget-insert "\n\n")
 	(widget-insert "Type a search query and hit RET to view matching threads.\n")
-	(when notmuch-hello-recent-searches
+	(when notmuch-search-history
 	  (widget-insert "Hit RET to re-submit a previous search. Edit it first if you like.\n")
 	  (widget-insert "Save recent searches with the `save' button.\n"))
-	(when notmuch-hello-saved-searches
+	(when notmuch-saved-searches
 	  (widget-insert "Edit saved searches with the `edit' button.\n"))
 	(widget-insert "Hit RET or click on a saved search or tag name to view matching threads.\n")
-	(widget-insert "`=' refreshes this screen. `s' jumps to the search box. `q' to quit.\n")
+	(widget-insert "`=' to refresh this screen. `s' to search messages. `q' to quit.\n")
 	(let ((fill-column (- (window-width) notmuch-hello-indent)))
 	  (center-region start (point))))
 
-      (use-local-map widget-keymap)
-      (local-set-key "=" 'notmuch-hello-update)
-      (local-set-key "m" 'notmuch-mua-mail)
-      (local-set-key "q" '(lambda () (interactive) (kill-buffer (current-buffer))))
-      (local-set-key "s" 'notmuch-hello-goto-search)
-      (local-set-key "v" '(lambda () (interactive)
-			    (message "notmuch version %s" (notmuch-version))))
-
       (widget-setup)
 
-      (goto-char final-target-pos)
-      (if (not (widget-at))
-	  (widget-forward 1)))))
+      (when final-target-pos
+	(goto-char final-target-pos)
+	(unless (widget-at)
+	  (widget-forward 1)))
+
+      (unless (widget-at)
+	(goto-char default-pos))))
+
+  (run-hooks 'notmuch-hello-refresh-hook))
+
+(defun notmuch-folder ()
+  "Deprecated function for invoking notmuch---calling `notmuch' is preferred now."
+  (interactive)
+  (notmuch-hello))
 
 ;;