X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=emacs%2Fnotmuch-hello.el;h=6db62a01c46b09e7851c9259552c13d7a7574c6b;hp=0582cae76f492fc1ab349ab4458e889b2ea576ae;hb=d273ed6cf1bdaa2d644cec4909cbf415ff4d257b;hpb=a467c5f071a1a730adc2bd84635dfc608c26ace9

diff --git a/emacs/notmuch-hello.el b/emacs/notmuch-hello.el
index 0582cae7..6db62a01 100644
--- a/emacs/notmuch-hello.el
+++ b/emacs/notmuch-hello.el
@@ -29,22 +29,19 @@
 (declare-function notmuch-search "notmuch" (query &optional oldest-first target-thread target-line continuation))
 (declare-function notmuch-poll "notmuch" ())
 
-(defvar notmuch-hello-search-bar-marker nil
-  "The position of the search bar within the notmuch-hello buffer.")
-
-(defcustom notmuch-recent-searches-max 10
-  "The number of recent searches to store and display."
+(defcustom notmuch-hello-recent-searches-max 10
+  "The number of recent searches to display."
   :type 'integer
-  :group 'notmuch)
+  :group 'notmuch-hello)
 
 (defcustom notmuch-show-empty-saved-searches nil
   "Should saved searches with no messages be listed?"
   :type 'boolean
-  :group 'notmuch)
+  :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)))))
+  (sort (copy-sequence 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.
@@ -60,7 +57,7 @@ alist to be used."
 		 (const :tag "Sort alphabetically" notmuch-sort-saved-searches)
 		 (function :tag "Custom sort function"
 			   :value notmuch-sort-saved-searches))
-  :group 'notmuch)
+  :group 'notmuch-hello)
 
 (defvar notmuch-hello-indent 4
   "How much to indent non-headers.")
@@ -68,12 +65,12 @@ alist to be used."
 (defcustom notmuch-show-logo t
   "Should the notmuch logo be shown?"
   :type 'boolean
-  :group 'notmuch)
+  :group 'notmuch-hello)
 
 (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.
@@ -86,14 +83,15 @@ 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")
-		 (const :tag "Custom filter" string)
-		 (const :tag "Custom filter function" function))
-  :group 'notmuch)
+		 (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)
+  :group 'notmuch-hello)
 
 (defface notmuch-hello-logo-background
   '((((class color)
@@ -103,7 +101,8 @@ should return a filter for that tag, or nil to hide the tag."
       (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.
@@ -125,30 +124,120 @@ So:
   30.
 - if you don't want to worry about all of this nonsense, leave
   this set to `t'."
-  :group 'notmuch
   :type '(choice
 	  (const :tag "Automatically calculated" t)
 	  (integer :tag "Number of characters")
-	  (float :tag "Fraction of window")))
-
-(defcustom notmuch-decimal-separator ","
-  "The string used as a decimal separator.
-
-Typically \",\" in the US and UK and \".\" in Europe."
-  :group 'notmuch
-  :type 'string)
+	  (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-recent-searches-max)
-      (setq notmuch-hello-recent-searches (butlast notmuch-hello-recent-searches))))
+(defvar notmuch-hello-custom-section-options
+  '((:filter (string :tag "Filter for each tag"))
+    (:filter-count (string :tag "Different filter to generate message counts"))
+    (:initially-hidden (const :tag "Hide this section on startup" t))
+    (:show-empty-searches (const :tag "Show queries with no matching messages" t))
+    (:hide-if-empty (const :tag "Hide this section if all queries are empty
+\(and not shown by show-empty-searches)" t)))
+  "Various customization-options for notmuch-hello-tags/query-section.")
+
+(define-widget 'notmuch-hello-tags-section 'lazy
+  "Customize-type for notmuch-hello tag-list sections."
+  :tag "Customized tag-list section (see docstring for details)"
+  :type
+  `(list :tag ""
+	 (const :tag "" notmuch-hello-insert-tags-section)
+	 (string :tag "Title for this section")
+	 (plist
+	  :inline t
+	  :options
+	  ,(append notmuch-hello-custom-section-options
+		   '((:hide-tags (repeat :tag "Tags that will be hidden"
+					 string)))))))
+
+(define-widget 'notmuch-hello-query-section 'lazy
+  "Customize-type for custom saved-search-like sections"
+  :tag "Customized queries section (see docstring for details)"
+  :type
+  `(list :tag ""
+	 (const :tag "" notmuch-hello-insert-searches)
+	 (string :tag "Title for this section")
+	 (repeat :tag "Queries"
+		 (cons (string :tag "Name") (string :tag "Query")))
+	 (plist :inline t :options ,notmuch-hello-custom-section-options)))
+
+(defcustom notmuch-hello-sections
+  (list #'notmuch-hello-insert-header
+	#'notmuch-hello-insert-saved-searches
+	#'notmuch-hello-insert-search
+	#'notmuch-hello-insert-recent-searches
+	#'notmuch-hello-insert-alltags
+	#'notmuch-hello-insert-footer)
+  "Sections for notmuch-hello.
+
+The list contains functions which are used to construct sections in
+notmuch-hello buffer.  When notmuch-hello buffer is constructed,
+these functions are run in the order they appear in this list.  Each
+function produces a section simply by adding content to the current
+buffer.  A section should not end with an empty line, because a
+newline will be inserted after each section by `notmuch-hello'.
+
+Each function should take no arguments. The return value is
+ignored.
+
+For convenience an element can also be a list of the form (FUNC ARG1
+ARG2 .. ARGN) in which case FUNC will be applied to the rest of the
+list.
+
+A \"Customized tag-list section\" item in the customize-interface
+displays a list of all tags, optionally hiding some of them. It
+is also possible to filter the list of messages matching each tag
+by an additional filter query. Similarly, the count of messages
+displayed next to the buttons can be generated by applying a
+different filter to the tag query. These filters are also
+supported for \"Customized queries section\" items."
+  :group 'notmuch-hello
+  :type
+  '(repeat
+    (choice (function-item notmuch-hello-insert-header)
+	    (function-item notmuch-hello-insert-saved-searches)
+	    (function-item notmuch-hello-insert-search)
+	    (function-item notmuch-hello-insert-recent-searches)
+	    (function-item notmuch-hello-insert-alltags)
+	    (function-item notmuch-hello-insert-footer)
+	    (function-item notmuch-hello-insert-inbox)
+	    notmuch-hello-tags-section
+	    notmuch-hello-query-section
+	    (function :tag "Custom section"))))
+
+(defvar notmuch-hello-hidden-sections nil
+  "List of sections titles whose contents are hidden")
+
+(defvar notmuch-hello-first-run t
+  "True if `notmuch-hello' is run for the first time, set to nil
+afterwards.")
 
 (defun notmuch-hello-nice-number (n)
   (let (result)
@@ -159,7 +248,7 @@ Typically \",\" in the US and UK and \".\" in Europe."
     (apply #'concat
      (number-to-string (car result))
      (mapcar (lambda (elem)
-	      (format "%s%03d" notmuch-decimal-separator elem))
+	      (format "%s%03d" notmuch-hello-thousands-separator elem))
 	     (cdr result)))))
 
 (defun notmuch-hello-trim (search)
@@ -168,10 +257,14 @@ Typically \",\" in the US and UK and \".\" in Europe."
       (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)
@@ -193,8 +286,8 @@ Typically \",\" in the US and UK and \".\" in Europe."
     (message "Saved '%s' as '%s'." search name)
     (notmuch-hello-update)))
 
-(defun notmuch-hello-longest-label (tag-alist)
-  (or (loop for elem in tag-alist
+(defun notmuch-hello-longest-label (searches-alist)
+  (or (loop for elem in searches-alist
 	    maximize (length (car elem)))
       0))
 
@@ -258,57 +351,102 @@ should be. Returns a cons cell `(tags-per-line width)'."
 				   (* tags-per-line (+ 9 1))))
 			   tags-per-line))))
 
-(defun notmuch-hello-insert-tags (tag-alist widest target)
-  (let* ((tags-and-width (notmuch-hello-tags-per-line widest))
+(defun notmuch-hello-filtered-query (query filter)
+  "Constructs a query to search all messages matching QUERY and FILTER.
+
+If FILTER is a string, it is directly used in the returned query.
+
+If FILTER is a function, it is called with QUERY as a parameter and
+the string it returns is used as the query. If nil is returned,
+the entry is hidden.
+
+Otherwise, FILTER is ignored.
+"
+  (cond
+   ((functionp filter) (funcall filter query))
+   ((stringp filter)
+    (concat "(" query ") and (" filter ")"))
+   (t query)))
+
+(defun notmuch-hello-query-counts (query-alist &rest options)
+  "Compute list of counts of matched messages from QUERY-ALIST.
+
+QUERY-ALIST must be a list containing elements of the form (NAME . QUERY)
+or (NAME QUERY COUNT-QUERY). If the latter form is used,
+COUNT-QUERY specifies an alternate query to be used to generate
+the count for the associated query.
+
+The result is the list of elements of the form (NAME QUERY COUNT).
+
+The values :show-empty-searches, :filter and :filter-count from
+options will be handled as specified for
+`notmuch-hello-insert-searches'."
+  (notmuch-remove-if-not
+   #'identity
+   (mapcar
+    (lambda (elem)
+      (let* ((name (car elem))
+	     (query-and-count (if (consp (cdr elem))
+				  ;; do we have a different query for the message count?
+				  (cons (second elem) (third elem))
+				(cons (cdr elem) (cdr elem))))
+	     (message-count
+	      (string-to-number
+	       (notmuch-saved-search-count
+		(notmuch-hello-filtered-query (cdr query-and-count)
+					      (or (plist-get options :filter-count)
+						 (plist-get options :filter)))))))
+	(and (or (plist-get options :show-empty-searches) (> message-count 0))
+	     (list name (notmuch-hello-filtered-query
+			 (car query-and-count) (plist-get options :filter))
+		   message-count))))
+    query-alist)))
+
+(defun notmuch-hello-insert-buttons (searches)
+  "Insert buttons for SEARCHES.
+
+SEARCHES must be a list containing lists of the form (NAME QUERY COUNT), where
+QUERY is the query to start when the button for the corresponding entry is
+activated. COUNT should be the number of messages matching the query.
+Such a list can be computed with `notmuch-hello-query-counts'."
+  (let* ((widest (notmuch-hello-longest-label searches))
+	 (tags-and-width (notmuch-hello-tags-per-line widest))
 	 (tags-per-line (car tags-and-width))
-	 (widest (cdr tags-and-width))
+	 (column-width (cdr tags-and-width))
+	 (column-indent 0)
 	 (count 0)
-	 (reordered-list (notmuch-hello-reflect tag-alist tags-per-line))
+	 (reordered-list (notmuch-hello-reflect searches tags-per-line))
 	 ;; Hack the display of the buttons used.
 	 (widget-push-button-prefix "")
-	 (widget-push-button-suffix "")
-	 (found-target-pos nil))
+	 (widget-push-button-suffix ""))
     ;; dme: It feels as though there should be a better way to
     ;; implement this loop than using an incrementing counter.
     (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)))
+	      (if (> column-indent 0)
+		  (widget-insert (make-string column-indent ? )))
+	      (let* ((name (first elem))
+		     (query (second elem))
+		     (msg-count (third elem)))
 		(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)))
+				       (notmuch-hello-nice-number msg-count)))
 		(widget-create 'push-button
 			       :notify #'notmuch-hello-widget-search
 			       :notmuch-search-terms query
-			       formatted-name)
-		;; 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)))
-					    ? ))))
+			       name)
+		(setq column-indent
+		      (1+ (max 0 (- column-width (length name)))))))
 	    (setq count (1+ count))
-	    (if (eq (% count tags-per-line) 0)
-		(widget-insert "\n")))
+	    (when (eq (% count tags-per-line) 0)
+	      (setq column-indent 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"))
-    found-target-pos))
-
-(defun notmuch-hello-goto-search ()
-  "Put point inside the `search' widget."
-  (interactive)
-  (goto-char notmuch-hello-search-bar-marker))
+    (unless (eq (% count tags-per-line) 0)
+      (widget-insert "\n"))))
 
 (defimage notmuch-hello-logo ((:type png :file "notmuch-logo.png")))
 
@@ -331,15 +469,15 @@ should be. Returns a cons cell `(tags-per-line width)'."
 (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 "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-goto-search)
+    (define-key map "s" 'notmuch-hello-search)
     map)
   "Keymap for \"notmuch hello\" buffers.")
 (fset 'notmuch-hello-mode-map notmuch-hello-mode-map)
@@ -354,54 +492,255 @@ Complete list of currently available key bindings:
  (kill-all-local-variables)
  (use-local-map notmuch-hello-mode-map)
  (setq major-mode 'notmuch-hello-mode
-       mode-name "notmuch-hello")
+	mode-name "notmuch-hello")
+ (run-mode-hooks 'notmuch-hello-mode-hook)
  ;;(setq buffer-read-only t)
 )
 
-(defun notmuch-hello-generate-tag-alist ()
+(defun notmuch-hello-generate-tag-alist (&optional hide-tags)
   "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")))))
+  (mapcar (lambda (tag)
+	    (cons tag (concat "tag:" (notmuch-escape-boolean-term tag))))
+	  (notmuch-remove-if-not
+	   (lambda (tag)
+	     (not (member tag hide-tags)))
+	   (process-lines notmuch-command "search-tags"))))
+
+(defun notmuch-hello-insert-header ()
+  "Insert the default notmuch-hello header."
+  (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
+      ;; a black background), so force the background colour of the
+      ;; image. We use a face to represent the colour so that
+      ;; `defface' can be used to declare the different possible
+      ;; colours, which depend on whether the frame has a light or
+      ;; dark background.
+      (setq image (cons 'image
+			(append (cdr image)
+				(list :background (face-background 'notmuch-hello-logo-background)))))
+      (insert-image image))
+    (widget-insert "  "))
+
+  (widget-insert "Welcome to ")
+  ;; Hack the display of the links used.
+  (let ((widget-link-prefix "")
+	(widget-link-suffix ""))
+    (widget-create 'link
+		   :notify (lambda (&rest ignore)
+			     (browse-url notmuch-hello-url))
+		   :help-echo "Visit the notmuch website."
+		   "notmuch")
+    (widget-insert ". ")
+    (widget-insert "You have ")
+    (widget-create 'link
+		   :notify (lambda (&rest ignore)
+			     (notmuch-hello-update))
+		   :help-echo "Refresh"
+		   (notmuch-hello-nice-number
+		    (string-to-number (car (process-lines notmuch-command "count")))))
+    (widget-insert " messages.\n")))
+
+
+(defun notmuch-hello-insert-saved-searches ()
+  "Insert the saved-searches section."
+  (let ((searches (notmuch-hello-query-counts
+		   (if notmuch-saved-search-sort-function
+		       (funcall notmuch-saved-search-sort-function
+				notmuch-saved-searches)
+		     notmuch-saved-searches)
+		   :show-empty-searches notmuch-show-empty-saved-searches)))
+    (when searches
+      (widget-insert "Saved searches: ")
+      (widget-create 'push-button
+		     :notify (lambda (&rest ignore)
+			       (customize-variable 'notmuch-saved-searches))
+		     "edit")
+      (widget-insert "\n\n")
+      (let ((start (point)))
+	(notmuch-hello-insert-buttons searches)
+	(indent-rigidly start (point) notmuch-hello-indent)))))
+
+(defun notmuch-hello-insert-search ()
+  "Insert a search widget."
+  (widget-insert "Search: ")
+  (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"))
+
+(defun notmuch-hello-insert-recent-searches ()
+  "Insert recent searches."
+  (when notmuch-search-history
+    (widget-insert "Recent searches: ")
+    (widget-create 'push-button
+		   :notify (lambda (&rest ignore)
+			     (setq notmuch-search-history nil)
+			     (notmuch-hello-update))
+		   "clear")
+    (widget-insert "\n\n")
+    (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))
+    nil))
+
+(defun notmuch-hello-insert-searches (title query-alist &rest options)
+  "Insert a section with TITLE showing a list of buttons made from QUERY-ALIST.
+
+QUERY-ALIST must be a list containing elements of the form (NAME . QUERY)
+or (NAME QUERY COUNT-QUERY). If the latter form is used,
+COUNT-QUERY specifies an alternate query to be used to generate
+the count for the associated item.
+
+Supports the following entries in OPTIONS as a plist:
+:initially-hidden - if non-nil, section will be hidden on startup
+:show-empty-searches - show buttons with no matching messages
+:hide-if-empty - hide if no buttons would be shown
+   (only makes sense without :show-empty-searches)
+:filter - This can be a function that takes the search query as its argument and
+   returns a filter to be used in conjuction with the query for that search or nil
+   to hide the element. This can also be a string that is used as a combined with
+   each query using \"and\".
+:filter-count - Separate filter to generate the count displayed each search. Accepts
+   the same values as :filter. If :filter and :filter-count are specified, this
+   will be used instead of :filter, not in conjunction with it."
+  (widget-insert title ": ")
+  (if (and notmuch-hello-first-run (plist-get options :initially-hidden))
+      (add-to-list 'notmuch-hello-hidden-sections title))
+  (let ((is-hidden (member title notmuch-hello-hidden-sections))
+	(start (point)))
+    (if is-hidden
+	(widget-create 'push-button
+		       :notify `(lambda (widget &rest ignore)
+				  (setq notmuch-hello-hidden-sections
+					(delete ,title notmuch-hello-hidden-sections))
+				  (notmuch-hello-update))
+		       "show")
+      (widget-create 'push-button
+		     :notify `(lambda (widget &rest ignore)
+				(add-to-list 'notmuch-hello-hidden-sections
+					     ,title)
+				(notmuch-hello-update))
+		     "hide"))
+    (widget-insert "\n")
+    (when (not is-hidden)
+      (let ((searches (apply 'notmuch-hello-query-counts query-alist options)))
+	(when (or (not (plist-get options :hide-if-empty))
+		  searches)
+	  (widget-insert "\n")
+	  (notmuch-hello-insert-buttons searches)
+	  (indent-rigidly start (point) notmuch-hello-indent))))))
+
+(defun notmuch-hello-insert-tags-section (&optional title &rest options)
+  "Insert a section displaying all tags with message counts.
+
+TITLE defaults to \"All tags\".
+Allowed options are those accepted by `notmuch-hello-insert-searches' and the
+following:
+
+:hide-tags - List of tags that should be excluded."
+  (apply 'notmuch-hello-insert-searches
+	 (or title "All tags")
+	 (notmuch-hello-generate-tag-alist (plist-get options :hide-tags))
+	 options))
+
+(defun notmuch-hello-insert-inbox ()
+  "Show an entry for each saved search and inboxed messages for each tag"
+  (notmuch-hello-insert-searches "What's in your inbox"
+				 (append
+				  notmuch-saved-searches
+				  (notmuch-hello-generate-tag-alist))
+				 :filter "tag:inbox"))
+
+(defun notmuch-hello-insert-alltags ()
+  "Insert a section displaying all tags and associated message counts"
+  (notmuch-hello-insert-tags-section
+   nil
+   :initially-hidden (not notmuch-show-all-tags-list)
+   :hide-tags notmuch-hello-hide-tags
+   :filter notmuch-hello-tag-list-make-query))
+
+(defun notmuch-hello-insert-footer ()
+  "Insert the notmuch-hello footer."
+  (let ((start (point)))
+    (widget-insert "Type a search query and hit RET to view matching threads.\n")
+    (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-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 "`=' to refresh this screen. `s' to search messages. `q' to quit.\n")
+    (widget-create 'link
+		   :notify (lambda (&rest ignore)
+			     (customize-variable 'notmuch-hello-sections))
+		   :button-prefix "" :button-suffix ""
+		   "Customize")
+    (widget-insert " this page.")
+    (let ((fill-column (- (window-width) notmuch-hello-indent)))
+      (center-region start (point)))))
 
 ;;;###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.
-  (if (not notmuch-saved-searches)
-    (setq notmuch-saved-searches (notmuch-saved-searches)))
-
   (if no-display
       (set-buffer "*notmuch-hello*")
     (switch-to-buffer "*notmuch-hello*"))
 
-  (let ((target (if (widget-at)
-		   (widget-value (widget-at))
-		 (condition-case nil
-		     (progn
-		       (widget-forward 1)
-		       (widget-value (widget-at)))
-		   (error nil)))))
+  (let ((target-line (line-number-at-pos))
+	(target-column (current-column))
+	(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)
 
-    (kill-all-local-variables)
-    (let ((inhibit-read-only t))
-      (erase-buffer))
+    (erase-buffer)
 
     (unless (eq major-mode 'notmuch-hello-mode)
       (notmuch-hello-mode))
@@ -411,175 +750,27 @@ Complete list of currently available key bindings:
       (mapc 'delete-overlay (car all))
       (mapc 'delete-overlay (cdr all)))
 
-    (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
-	;; a black background), so force the background colour of the
-	;; image. We use a face to represent the colour so that
-	;; `defface' can be used to declare the different possible
-	;; colours, which depend on whether the frame has a light or
-	;; dark background.
-	(setq image (cons 'image
-			  (append (cdr image)
-				  (list :background (face-background 'notmuch-hello-logo-background)))))
-	(insert-image image))
-      (widget-insert "  "))
-
-    (widget-insert "Welcome to ")
-    ;; Hack the display of the links used.
-    (let ((widget-link-prefix "")
-	  (widget-link-suffix ""))
-      (widget-create 'link
-		     :notify (lambda (&rest ignore)
-			       (browse-url notmuch-hello-url))
-		     :help-echo "Visit the notmuch website."
-		     "notmuch")
-      (widget-insert ". ")
-      (widget-insert "You have ")
-      (widget-create 'link
-		     :notify (lambda (&rest ignore)
-			       (notmuch-hello-update))
-		     :help-echo "Refresh"
-		     (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))
-      (let* ((saved-alist
-	      ;; 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 (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
-	  ;; 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-saved-searches))
-			 "edit")
-	  (widget-insert "\n\n")
-	  (setq final-target-pos (point-marker))
-	  (let ((start (point)))
-	    (setq found-target-pos (notmuch-hello-insert-tags saved-alist widest target))
-	    (if found-target-pos
-		(setq final-target-pos found-target-pos))
-	    (indent-rigidly start (point) notmuch-hello-indent)))
-
-	(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) notmuch-hello-indent
-				       (length "Search: ")))
-		       :action (lambda (widget &rest ignore)
-				 (notmuch-hello-search (widget-value widget))))
-	;; add an invisible space to make `widget-end-of-line' ignore
-	;; trailine spaces in the search widget field
-	(widget-insert " ")
-	(put-text-property (1- (point)) (point) 'invisible t)
-	(widget-insert "\n")
-
-	(when notmuch-hello-recent-searches
-	  (widget-insert "\nRecent searches: ")
-	  (widget-create 'push-button
-			 :notify (lambda (&rest ignore)
-				   (setq notmuch-hello-recent-searches 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)
-	    (indent-rigidly start (point) notmuch-hello-indent)))
-
-	(when alltags-alist
-	  (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))
-	    (if (not final-target-pos)
-		(setq final-target-pos found-target-pos))
-	    (indent-rigidly start (point) notmuch-hello-indent)))
-
-	(widget-insert "\n")
-
-	(if (not 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
-	  (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-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")
-	(let ((fill-column (- (window-width) notmuch-hello-indent)))
-	  (center-region start (point))))
-
-      (widget-setup)
-
-      (when final-target-pos
-	(goto-char final-target-pos)
-	(unless (widget-at)
-	  (widget-forward 1)))
-
-      (unless (widget-at)
-	(notmuch-hello-goto-search)))))
+    (mapc
+     (lambda (section)
+       (let ((point-before (point)))
+	 (if (functionp section)
+	     (funcall section)
+	   (apply (car section) (cdr section)))
+	 ;; don't insert a newline when the previous section didn't
+	 ;; show anything.
+	 (unless (eq (point) point-before)
+	   (widget-insert "\n"))))
+     notmuch-hello-sections)
+    (widget-setup)
+
+    ;; Move point back to where it was before refresh. Use line and
+    ;; column instead of point directly to be insensitive to additions
+    ;; and removals of text within earlier lines.
+    (goto-char (point-min))
+    (forward-line (1- target-line))
+    (move-to-column target-column))
+  (run-hooks 'notmuch-hello-refresh-hook)
+  (setq notmuch-hello-first-run nil))
 
 (defun notmuch-folder ()
   "Deprecated function for invoking notmuch---calling `notmuch' is preferred now."