unofficial mirror of notmuch@notmuchmail.org
 help / color / mirror / code / Atom feed
blob 1042f31ca881f47d194179c89f35fcb5a2210c04 15251 bytes (raw)
name: emacs/notmuch-hello.el 	 # note: path name is non-authoritative(*)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
 
;; notmuch-hello.el --- welcome to notmuch, a frontend
;;
;; Copyright © David Edmondson
;;
;; This file is part of Notmuch.
;;
;; Notmuch 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.
;;
;; Notmuch 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 Notmuch.  If not, see <http://www.gnu.org/licenses/>.
;;
;; Authors: David Edmondson <dme@dme.org>

(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-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."
  :type 'integer
  :group 'notmuch)

(defcustom notmuch-show-empty-saved-searches nil
  "Should saved searches with no messages be listed?"
  :type 'boolean
  :group 'notmuch)

(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)

(defcustom notmuch-show-all-tags-list nil
  "Should all tags be shown in the notmuch-hello view?"
  :type 'boolean
  :group 'notmuch)

(defface notmuch-hello-logo-background
  '((((class color)
      (background dark))
     (:background "#5f5f5f"))
    (((class color)
      (background light))
     (:background "white")))
  "Background colour for the notmuch logo."
  :group 'notmuch)

(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))))

(defun notmuch-hello-trim (search)
  "Trim whitespace."
  (if (string-match "^[[:space:]]*\\(.*[^[:space:]]\\)[[:space:]]*$" search)
      (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-add-saved-search (widget)
  (interactive)
  (let ((search (widget-value
		 (symbol-value
		  (widget-get widget :notmuch-saved-search-widget))))
	(name (completing-read "Name for saved search: "
			       notmuch-saved-searches)))
    ;; If an existing saved search with this name exists, remove it.
    (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-saved-searches
			     (push (cons name search)
				   notmuch-saved-searches))
    (message "Saved '%s' as '%s'." search name)
    (notmuch-hello-update)))

(defun notmuch-hello-longest-label (tag-alist)
  (or (loop for elem in tag-alist
	    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-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 ((nrows (notmuch-hello-roundup (length list) ncols)))
    (loop for row from 0 to (- nrows 1)
	  append (notmuch-hello-reflect-generate-row ncols nrows row list))))

(defun notmuch-hello-widget-search (widget &rest ignore)
  (notmuch-search (widget-get widget
			      :notmuch-search-terms)
		  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-insert-tags (tag-alist widest target)
  (let* ((tags-per-line (max 1
			     (/ (- (window-width) notmuch-hello-indent)
				;; Count is 7 wide (6 digits plus
				;; space), 1 for the space after the
				;; name.
				(+ 7 1 widest))))
	 (count 0)
	 (reordered-list (notmuch-hello-reflect tag-alist tags-per-line))
	 ;; Hack the display of the buttons used.
	 (widget-push-button-prefix "")
	 (widget-push-button-suffix "")
	 (found-target-pos nil))
    ;; 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)))
		(widget-insert (format "%6s " (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)
		;; 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 (- 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"))
    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)
  ;; 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 (copy-keymap 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" 'kill-this-buffer)
    (define-key map "=" 'notmuch-hello-update)
    (define-key map "G" 'notmuch-hello-poll-and-update)
    (define-key map "m" 'notmuch-mua-mail)
    (define-key map "s" 'notmuch-hello-goto-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")
 ;;(setq buffer-read-only t)
)

(defun notmuch-hello (&optional no-display)
  (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)))))

    (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-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"
		     (car (process-lines notmuch-command "count")))
      (widget-insert " messages (that's not much mail).\n\n"))

    (let ((found-target-pos nil)
	  (final-target-pos nil))
      (let* ((saved-alist
	      ;; Filter out empty saved seaches 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
				(mapcar '(lambda (tag) (cons tag (concat "tag:" tag)))
					(process-lines notmuch-command "search-tags"))))
	     (alltags-widest (notmuch-hello-longest-label alltags-alist))
	     (widest (max saved-widest alltags-widest)))

	(when saved-alist
	  (widget-insert "Saved 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)))

	(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 "\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)

      (goto-char final-target-pos)
      (if (not (widget-at))
	  (widget-forward 1)))))

;;;###autoload
(defun notmuch-folder ()
  "Deprecated function for invoking notmuch---calling `notmuch' is preferred now."
  (interactive)
  (notmuch-hello))

;;

(provide 'notmuch-hello)

debug log:

solving 1042f31 ...
found 1042f31 in https://yhetil.org/notmuch/1272882573-9864-1-git-send-email-Sebastian@SSpaeth.de/
found 6a1c56e in https://yhetil.org/notmuch.git/
preparing index
index prepared:
100644 6a1c56e52b341c045a5ff038da79dbf556dd1ecb	emacs/notmuch-hello.el

applying [1/1] https://yhetil.org/notmuch/1272882573-9864-1-git-send-email-Sebastian@SSpaeth.de/
diff --git a/emacs/notmuch-hello.el b/emacs/notmuch-hello.el
index 6a1c56e..1042f31 100644

Checking patch emacs/notmuch-hello.el...
Applied patch emacs/notmuch-hello.el cleanly.

index at:
100644 1042f31ca881f47d194179c89f35fcb5a2210c04	emacs/notmuch-hello.el

(*) Git path names are given by the tree(s) the blob belongs to.
    Blobs themselves have no identifier aside from the hash of its contents.^

Code repositories for project(s) associated with this public inbox

	https://yhetil.org/notmuch.git/

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).