OSDN Git Service

update autotools
[howm/howm.git] / howm-view.el
1 ;;; howm-view.el --- Wiki-like note-taking tool
2 ;;; Copyright (C) 2002, 2003, 2004, 2005-2018
3 ;;;   HIRAOKA Kazuyuki <khi@users.osdn.me>
4 ;;;
5 ;;; This program is free software; you can redistribute it and/or modify
6 ;;; it under the terms of the GNU General Public License as published by
7 ;;; the Free Software Foundation; either version 1, or (at your option)
8 ;;; any later version.
9 ;;;
10 ;;; This program is distributed in the hope that it will be useful,
11 ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 ;;; GNU General Public License for more details.
14 ;;;
15 ;;; The GNU General Public License is available by anonymouse ftp from
16 ;;; prep.ai.mit.edu in pub/gnu/COPYING.  Alternately, you can write to
17 ;;; the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
18 ;;; USA.
19 ;;--------------------------------------------------------------------
20
21 (provide 'howm-view)
22 (require 'howm)
23
24 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
25 ;;; variables
26
27 ;; customize
28 (defvar howm-view-summary-sep "|")
29 (defvar howm-view-summary-format
30   (let* ((path (format-time-string howm-file-name-format))
31          (width (length (file-name-nondirectory path))))
32     (concat "%-" (format "%s" (1+ width)) "s" howm-view-summary-sep " ")))
33 (defvar howm-view-header-format
34   "\n==========================>>> %s\n"
35   "Format string of header for howm-view-contents.
36 %s is replaced with file name. See `format'.")
37 (defvar howm-view-header-regexp "^==========================>>> .*$")
38 (defvar howm-view-open-recenter howm-view-search-recenter)
39 (defvar howm-view-title-header "=")
40 ;; howm-view-title-regexp is assumed to have a form "^xxxxxxx$"
41 (defvar howm-view-title-regexp (format "^%s\\( +\\(.*\\)\\|\\)$"
42                                      (regexp-quote howm-view-title-header)))
43 (defvar howm-view-title-regexp-pos 2)
44 (defvar howm-view-title-regexp-grep (format "^%s +"
45                                      (regexp-quote howm-view-title-header)))
46 (defun howm-view-title-regexp-grep ()
47   (if howm-view-use-grep
48       howm-view-title-regexp-grep
49     howm-view-title-regexp))
50
51 (howm-defvar-risky howm-view-sort-methods
52   '(("random" . howm-view-sort-by-random)
53     ("name" . howm-view-sort-by-name)
54     ("name-match" . howm-view-lift-by-name)
55     ("numerical-name" . howm-view-sort-by-numerical-name)
56     ("summary" . howm-view-sort-by-summary)
57     ("summary-match" . howm-view-lift-by-summary)
58     ("summary-match-string" . howm-view-lift-by-summary-substring)
59 ;     ("atime" . howm-view-sort-by-atime) ;; nonsense
60 ;     ("ctime" . howm-view-sort-by-ctime) ;; needless
61     ("mtime" . howm-view-sort-by-mtime)
62     ("date" . howm-view-sort-by-reverse-date)
63     ("reminder" . howm-view-sort-by-reminder)
64     ("reverse" . howm-view-sort-reverse)))
65
66 (howm-defvar-risky howm-view-filter-methods
67   '(("name" . howm-view-filter-by-name)
68     ("summary" . howm-view-filter-by-summary)
69     ("mtime" . howm-view-filter-by-mtime)
70 ;     ("ctime" . howm-view-filter-by-ctime) ;; needless
71     ("date" . howm-view-filter-by-date)
72     ("reminder" . howm-view-filter-by-reminder)
73     ("contents" . howm-view-filter-by-contents)
74     ("Region" . howm-view-filter-by-region)
75     ("Around" . howm-view-filter-by-around)
76 ;     ("uniq" . howm-view-filter-uniq))
77   ))
78
79 ;; referred only when howm-view-use-grep is nil
80 (defvar howm-view-watch-modified-buffer t)
81
82 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
83 ;;; item
84
85 (defun howm-view-item-basename (item &optional nonempty)
86   (let* ((f (howm-item-name item))
87          (b (file-name-nondirectory f)))
88     (if (and (string= b "") nonempty)
89         f
90       b)))
91
92 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
93 ;;; riffle
94
95 (defalias 'riffle-home:howm              'howm-view-item-home)
96 (defalias 'riffle-summary-item:howm      'howm-view-summary-item)
97 (defalias 'riffle-contents-item:howm     'howm-view-contents-item)
98 (defalias 'riffle-summary-set-mode:howm  'howm-view-summary-mode)
99 (defalias 'riffle-contents-set-mode:howm 'howm-view-contents-mode)
100
101 (defun riffle-summary-name-format:howm ()
102   howm-view-summary-name)
103 (defun riffle-contents-name-format:howm ()
104   howm-view-contents-name)
105 (defun riffle-post-update:howm (item)
106   (howm-message-nolog "View: %s" (howm-view-item-filename item)))
107
108 ;;; aliases
109
110 ;; Only howm-view.el should call riffle-xxx.
111 ;; Define alias if it is used in howm-xxx besides howm-view.el.
112 (defalias 'howm-view-name          #'riffle-name)          
113 (defalias 'howm-view-item-list     #'riffle-item-list)     
114 (defalias 'howm-view-line-number   #'riffle-line-number)   
115 (defalias 'howm-view-summary-check #'riffle-summary-check) 
116 (defalias 'howm-view-persistent-p  #'riffle-persistent-p)  
117 (defalias 'howm-view-kill-buffer   #'riffle-kill-buffer)   
118 (defalias 'howm-view-set-place     #'riffle-set-place)     
119 (defalias 'howm-view-get-place     #'riffle-get-place)     
120 (defalias 'howm-view-summary-current-item  #'riffle-summary-current-item)
121 (defalias 'howm-view-contents-current-item #'riffle-contents-current-item)
122 (defalias 'howm-view-summary-to-contents   #'riffle-summary-to-contents)
123 (defalias 'howm-view-restore-window-configuration #'riffle-restore-window-configuration)
124
125 ;; for howmoney.el
126 ;; https://howm.osdn.jp/cgi-bin/hiki/hiki.cgi?howmoney
127 (defun howm-view-get-buffer (name-format &optional name new)
128   (let ((riffle-type ':howm)) ;; cheat
129     (riffle-get-buffer name-format name new)))
130 (defun howm-view-summary-buffer (&optional new)
131   (let ((riffle-type ':howm)) ;; cheat
132     (riffle-summary-buffer new)))
133 (defalias 'howm-view-summary-show 'riffle-summary-show)
134 (defalias 'howm-view-set-item-list 'riffle-set-item-list)
135
136 ;; for howmz
137 ;; http://noir.s7.xrea.com/archives/000136.html
138 ;; http://noir.s7.xrea.com/pub/zaurus/howmz.el
139 (defalias 'howm-view-sort-items 'howm-sort)
140
141 ;;; variables
142
143 (defvar howm-view-font-lock-silent t
144   "Inhibit font-lock-verbose if non-nil.")
145 (howm-defvar-risky howm-view-summary-font-lock-keywords
146   `((,(concat "\\(^[^ \t\r\n].*?\\)" (regexp-quote howm-view-summary-sep))
147      1 howm-view-name-face)
148     ("^ +" . howm-view-empty-face)))
149 (howm-defvar-risky howm-view-contents-font-lock-keywords nil)
150
151 (howm-defvar-risky *howm-view-font-lock-keywords* nil
152   "For internal use. Don't set this variable.
153 This is a shameful global variable and should be clearned in future.")
154 (howm-defvar-risky howm-view-font-lock-keywords nil
155   "For internal use.")
156 (defvar howm-view-font-lock-first-time t
157   "For internal use.")
158 (make-variable-buffer-local 'howm-view-font-lock-keywords)
159 (make-variable-buffer-local 'howm-view-font-lock-first-time)
160
161 ;;; modes
162
163 (riffle-define-derived-mode howm-view-summary-mode riffle-summary-mode "HowmS"
164   "memo viewer (summary mode)
165 key     binding
166 ---     -------
167 \\[howm-view-summary-open]      Open file
168 \\[next-line]   Next item
169 \\[previous-line]       Previous item
170 \\[riffle-pop-or-scroll-other-window]   Pop and scroll contents
171 \\[scroll-other-window-down]    Scroll contents
172 \\[riffle-scroll-other-window]  Scroll contents one line
173 \\[riffle-scroll-other-window-down]     Scroll contents one line
174 \\[riffle-summary-to-contents]  Concatenate all contents
175 \\[howm-view-filter-uniq]       Remove duplication of same file
176 \\[howm-view-summary-shell-command]     Execute command in inferior shell
177
178 \\[delete-other-windows]        Delete contents window
179 \\[riffle-pop-window]   Pop contents window
180 \\[riffle-toggle-window]        Toggle contents window
181 \\[howm-list-toggle-title]      Show/Hide Title
182
183 \\[howm-view-filter]    Filter (by date, contents, etc.)
184 \\[howm-view-filter-by-contents]        Search (= filter by contents)
185 \\[howm-view-sort]      Sort (by date, summary line, etc.)
186 \\[howm-view-sort-reverse]      Reverse order
187 \\[howm-view-dired]     Invoke Dired-X
188 \\[describe-mode]       This help
189 \\[riffle-kill-buffer]  Quit
190 "
191   (make-local-variable 'font-lock-keywords)
192   (cheat-font-lock-mode howm-view-font-lock-silent)
193   (when howm-view-font-lock-first-time
194     (setq howm-view-font-lock-first-time nil)
195     (cheat-font-lock-merge-keywords howm-user-font-lock-keywords
196                                     howm-view-summary-font-lock-keywords
197                                     ;; dirty! Clean dependency between files.
198                                     (howm-reminder-today-font-lock-keywords)))
199   (when *howm-view-font-lock-keywords*
200     (setq howm-view-font-lock-keywords *howm-view-font-lock-keywords*))
201   (when howm-view-font-lock-keywords
202     (cheat-font-lock-merge-keywords howm-view-font-lock-keywords
203                                     howm-user-font-lock-keywords
204                                     howm-view-summary-font-lock-keywords))
205   ;; font-lock-set-defaults removes these local variables after 2008-02-24
206   (set (make-local-variable 'font-lock-keywords-only) t)
207   (set (make-local-variable 'font-lock-keywords-case-fold-search) t)
208   ;;     (setq font-lock-keywords-case-fold-search
209   ;;           howm-view-grep-ignore-case-option)
210   (cheat-font-lock-fontify)
211   )
212
213 (riffle-define-derived-mode howm-view-contents-mode riffle-contents-mode "HowmC"
214   "memo viewer (contents mode)
215 key     binding
216 ---     -------
217 \\[howm-view-contents-open]     Open file
218 \\[next-line]   Next line
219 \\[previous-line]       Previous line
220 \\[scroll-up]   Scroll up
221 \\[scroll-down] Scroll down
222 \\[riffle-scroll-up]    Scroll one line up
223 \\[riffle-scroll-down]  Scroll one line down
224 \\[riffle-contents-to-summary]  Summary
225 \\[riffle-contents-goto-next-item]      Next item
226 \\[riffle-contents-goto-previous-item]  Previous item
227
228 \\[howm-view-filter]    Filter (by date, contents, etc.)
229 \\[howm-view-filter-by-contents]        Search (= filter by contents)
230 \\[howm-view-sort]      Sort
231 \\[howm-view-sort-reverse]      Reverse order
232 \\[howm-view-dired]     Invoke Dired-X
233 \\[describe-mode]       This help
234 \\[riffle-kill-buffer]  Quit
235 "
236 ;   (kill-all-local-variables)
237   (make-local-variable 'font-lock-keywords)
238   (cheat-font-lock-mode howm-view-font-lock-silent)
239   (let ((ck `((,howm-view-header-regexp (0 howm-view-hilit-face))))
240         (sk (or (howm-view-font-lock-keywords)
241                 *howm-view-font-lock-keywords*)))
242 ;;         ;; extremely dirty!! [2003/10/06 21:08]
243 ;;         (sk (or (with-current-buffer (riffle-summary-buffer)
244 ;;                   font-lock-keywords)
245 ;;                 *howm-view-font-lock-keywords*)))
246     (cheat-font-lock-merge-keywords sk ck
247                                     howm-user-font-lock-keywords
248                                     howm-view-contents-font-lock-keywords)
249     ;; font-lock-set-defaults removes these local variables after 2008-02-24
250     (set (make-local-variable 'font-lock-keywords-only) t)
251     (set (make-local-variable 'font-lock-keywords-case-fold-search)
252          howm-view-grep-ignore-case-option)
253     (cheat-font-lock-fontify)
254     ))
255
256 (defun howm-view-font-lock-keywords ()
257   (with-current-buffer (riffle-summary-buffer)
258     howm-view-font-lock-keywords))
259
260 ;;; keymaps
261
262 ;; (defvar howm-view-summary-mode-map nil)
263 ;; (defvar howm-view-contents-mode-map nil)
264
265 (defun howm-view-define-common-key (keymap)
266   (let ((m keymap))
267 ;;     (define-key m "?" 'howm-view-help)
268     (define-key m "f" 'howm-view-filter)
269     (define-key m "G" 'howm-view-filter-by-contents)
270     (define-key m "S" 'howm-view-sort)
271     (define-key m "R" 'howm-view-sort-reverse)
272     (define-key m "q" 'howm-view-kill-buffer)
273     (define-key m "X" 'howm-view-dired)
274     ))
275
276 (let ((m howm-view-summary-mode-map))
277   (define-key m "\C-m" 'howm-view-summary-open)
278   (define-key m "\C-j" 'howm-view-summary-open)
279   (define-key m "u" 'howm-view-filter-uniq)
280   (define-key m "!" 'howm-view-summary-shell-command)
281   (define-key m "T" 'howm-list-toggle-title) ;; defined in other file. dirty!
282   ;;     (define-key m howm-reminder-quick-check-key 'howm-reminder-quick-check)
283   ;;     (define-key m ";" 'howm-view-invoke-action-lock)
284   (define-key m "\C-i" 'howm-view-summary-next-section)
285   (define-key m "\M-\C-i" 'howm-view-summary-previous-section)
286   (define-key m [tab] 'howm-view-summary-next-section)
287   (define-key m [(meta tab)] 'howm-view-summary-previous-section)
288   (howm-view-define-common-key m))
289
290 (let ((m howm-view-contents-mode-map))
291   (define-key m "\C-m" 'howm-view-contents-open)
292   (define-key m "\C-j" 'howm-view-contents-open)
293   (howm-view-define-common-key m))
294
295 ;;; summary
296
297 (defun howm-view-summary (&optional name item-list fl-keywords)
298   (let* ((*howm-view-font-lock-keywords* fl-keywords) ;; ok? [2008-07-11]
299          (r (riffle-summary name item-list ':howm
300                            (howm-view-in-background-p))))
301     (if (null r)
302         (message "No match")
303       ;; We want to entry font-lock keywords even when background-p.
304       (when *howm-view-font-lock-keywords*
305         (setq howm-view-font-lock-keywords *howm-view-font-lock-keywords*)))
306     r))
307
308 ;; (defun howm-view-summary (&optional name item-list)
309 ;;   (let ((*howm-view-font-lock-keywords* t))
310 ;;     (riffle-summary name item-list ':howm)))
311
312 (defun howm-view-summary-open (&optional reverse-delete-p)
313   (interactive "P")
314   (when (not (and howm-view-summary-keep-cursor
315                   (get-buffer-window (riffle-contents-buffer))))
316     (riffle-summary-check t))
317   (let* ((p (riffle-persistent-p howm-view-summary-persistent))
318          (persistent (if reverse-delete-p
319                          (not p)
320                        p)))
321     (howm-record-view-window-configuration)
322     (howm-view-summary-open-sub (not persistent))))
323
324 (defun howm-view-summary-open-sub (&optional kill)
325   (interactive "P")
326   (let ((b (riffle-contents-buffer))
327         (looking-at-str (buffer-substring-no-properties (point)
328                                                         (line-end-position))))
329     (riffle-pop-to-buffer b howm-view-summary-window-size)
330     (let ((howm-view-open-hook nil)) ;; Don't execute it in contents-open.
331       (howm-view-contents-open-sub kill))
332     (end-of-line)
333     (or (search-backward looking-at-str (line-beginning-position) t)
334         (beginning-of-line))
335     (run-hooks 'howm-view-open-hook)))
336
337 (defvar howm-view-summary-item-previous-name nil
338   "for internal use")
339 (defun howm-view-summary-item (item)
340   ;; Clean me. This depends on implementation of `riffle-summary-show'
341   ;; severely.
342   (when (eq (point) (point-min))
343     (setq howm-view-summary-item-previous-name ""))
344   (let* ((f (howm-item-name item))
345          (name (if (and howm-view-summary-omit-same-name
346                         (string= f howm-view-summary-item-previous-name))
347                    ""
348                  (progn
349                    (setq howm-view-summary-item-previous-name f)
350                    (howm-view-item-basename item t))))
351          (h (format howm-view-summary-format name)))
352     (concat h (howm-view-item-summary item))))
353
354 (defun howm-view-summary-next-section (&optional n)
355   (interactive "P")
356   (setq n (or n 1))
357   (let ((i (abs n))
358         (step (if (>= n 0) 1 -1)))
359     (while (and (> i 0)
360                 (howm-view-summary-next-section-sub step))
361       (setq i (1- i)))))
362 (defun howm-view-summary-previous-section (&optional n)
363   (interactive "P")
364   (setq n (or n 1))
365   (howm-view-summary-next-section (- n)))
366 (defun howm-view-summary-next-section-sub (step)
367   ;; inefficient. so what?
368   (let* ((f (lambda ()
369               (howm-view-item-filename (riffle-summary-current-item))))
370 ;;               (riffle-controller 'section (riffle-summary-current-item))))
371          (cont-p (lambda ()
372                    (save-excursion
373                      (let ((a (funcall f)))
374                        (forward-line -1)
375                        (string= a (funcall f)))))))
376     (while (and (= (forward-line step) 0)
377                 (funcall cont-p))
378       ;; no body
379       )))
380
381 ;;; contents
382
383 (defun howm-view-contents-open (&optional reverse-delete-p)
384   (interactive "P")
385   (let* ((p (riffle-persistent-p howm-view-contents-persistent))
386          (persistent (if reverse-delete-p
387                          (not p)
388                        p)))
389     (howm-record-view-window-configuration)
390     (howm-view-contents-open-sub (not persistent))))
391
392 (defvar *howm-view-item-privilege* nil) ;; dirty
393
394 (defun howm-view-contents-open-sub (&optional kill)
395   (let* ((item (riffle-contents-current-item))
396          (page (howm-item-page item))
397          (offset (howm-view-item-offset item))
398          (pos (- (point) offset))
399          (viewer (howm-view-external-viewer page)))
400     (when kill
401       (riffle-kill-buffer))
402     (when (howm-view-item-privilege item)
403       (riffle-restore-window-configuration)) ;; force without mode check
404     (setq *howm-view-item-privilege* (howm-view-item-privilege item)) ;; dirty
405     (run-hooks 'howm-view-before-open-hook)
406     (if viewer
407         (howm-view-call-external-viewer viewer page)
408       (howm-view-open-item item
409                            (lambda ()
410                              (when (or (< pos (point-min)) (<= (point-max) pos))
411                                (widen))
412                              (goto-char pos))
413                            t))
414     (run-hooks 'howm-view-open-hook)))
415
416 (defun howm-view-open-item (item &optional position-setter merely)
417   (howm-page-open (howm-item-page item))
418   (howm-view-set-mark-command)
419   (if position-setter
420       (funcall position-setter)
421     (howm-view-set-place (howm-item-place item)))
422   (recenter howm-view-open-recenter)
423   (when (not merely)
424     (howm-view-open-postprocess)))
425 (defun howm-view-open-postprocess ()
426   (run-hooks 'howm-view-open-hook))
427
428 (defvar howm-view-previous-section-page nil "For internal use")
429 (defvar howm-view-previous-section-beg nil "For internal use")
430 (defvar howm-view-previous-section-end nil "For internal use")
431
432 (defun howm-view-contents-item (item)
433   (when (howm-buffer-empty-p)
434     (setq howm-view-previous-section-page ""
435           howm-view-previous-section-beg nil
436           howm-view-previous-section-end nil))
437   (let* ((page (howm-item-page item))
438          (place (howm-view-item-place item))
439          (peq (howm-page= page howm-view-previous-section-page)) ;; dirty!
440          (done-p (if place
441                      (and peq
442                           (<= howm-view-previous-section-beg place)
443                           (<= place howm-view-previous-section-end))
444                    peq)))
445     (if done-p
446         ""
447       (let* ((header (if (null (cdr (howm-view-item-list))) ;; dirty!
448                          ""
449                        (format howm-view-header-format
450                                (howm-page-abbreviate-name page))))
451              (header-length (howm-view-string-point-count header))
452              (viewer (howm-view-external-viewer page)))
453         (concat header
454                 (howm-view-contents-item-sub item page place header viewer
455                                              (+ (point) header-length)))))))
456
457 (defvar howm-view-string-point-count-strict nil)
458 (defun howm-view-string-point-count (str)
459   "Count points of string STR.
460 Namely, it is the difference between start position and end position
461 of STR if STR is inserted to a buffer.
462 It looks to be simply equal to (length STR) on emacs-21.1.1.
463 But I'm not sure for multi-byte characters on other versions of emacsen."
464   (if howm-view-string-point-count-strict
465       (with-temp-buffer
466         (insert str)
467         (- (point) (point-min)))
468     ;; I assume (length (buffer-substring-no-properties START END))
469     ;; is equal to (abs (- START END))). Is it correct?
470     ;; (cf.) snap://Info-mode/elisp#Positions
471     (length str)))
472
473 (defun howm-view-contents-item-sub (item page place header viewer c)
474   (with-temp-buffer
475     (let (b e h)
476       (if viewer
477           (howm-view-contents-indicator viewer page)
478         (howm-page-insert page))
479       (if place
480           (progn
481             (riffle-set-place place)
482             (setq h (point))
483             (let ((r (howm-view-contents-region page)))
484               (setq b (car r)
485                     e (cadr r))))
486         (setq b (point-min)
487               e (point-max)
488               h b))
489       (howm-view-item-set-offset item (- c b))
490       (howm-view-item-set-home item (+ c (- b) h))
491       (setq howm-view-previous-section-page page ;; dirty!
492             howm-view-previous-section-beg (riffle-get-place b)
493             howm-view-previous-section-end (riffle-get-place e))
494       (buffer-substring-no-properties b e))))
495
496 (defvar howm-view-preview-narrow t)
497 (defun howm-view-contents-region (filename)
498   (when filename
499     (howm-page-set-configuration filename))
500   (if (or howm-view-preview-narrow
501           (not (riffle-preview-p)))
502       (howm-view-paragraph-region)
503     (list (point-min) (point-max))))
504
505 (defun howm-view-contents-indicator (viewer fname)
506   (insert (howm-viewer-indicator viewer fname)))
507
508 (defun howm-view-paragraph-region (&optional include-following-blank-p)
509   (let ((b (save-excursion
510              (end-of-line)
511              (re-search-backward howm-view-title-regexp
512                                  nil 'to-limit)
513              (line-beginning-position)))
514         (e (save-excursion
515              (end-of-line)
516              (let ((found (re-search-forward howm-view-title-regexp
517                                              nil 'to-limit)))
518                (if include-following-blank-p
519                    (if found (match-beginning 0) (point-max))
520                  (progn
521                    (if found
522                        (forward-line -1)
523                      (goto-char (point-max)))
524 ;                   (end-of-line)
525                    (while (and (looking-at "^$")
526                                (= (forward-line -1) 0)) ;; successful
527                      nil) ;; dummy
528                    (end-of-line)
529                    (point)))))))
530     (list b e)))
531
532 (defun howm-view-set-mark-command ()
533   (set-mark-command nil)
534   (howm-deactivate-mark))
535
536 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
537 ;;; misc.
538
539 (defun howm-view-file-list (&optional item-list)
540   (howm-cl-remove-duplicates* (mapcar #'howm-view-item-filename
541                                       (or item-list (howm-view-item-list)))
542                               :test #'howm-page=))
543
544 (defun howm-view-mtime (file)
545   (howm-view-time-to-string (howm-page-mtime file)))
546
547 ;; (defun howm-view-xtime (file x)
548 ;;   (let* ((a (file-attributes file))
549 ;;          (n (cdr (assoc x '((a . 4) (m . 5) (c . 6)))))
550 ;;          (ti (nth n a)))
551 ;;     (howm-view-time-to-string ti)))
552
553 (defun howm-view-time-to-string (ti)
554   (format-time-string "%Y%m%d-%H%M%S" ti))
555
556 (defun howm-view-string> (a b)
557   (string< b a))
558
559 (defun howm-view-string<= (a b)
560   (not (string< b a)))
561
562 (defun howm-view-string< (a b)
563   (string< a b))
564
565 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
566 ;;; dir
567
568 (defun howm-view-directory (dir &optional recursive-p)
569   (howm-view-summary "" (howm-folder-items dir recursive-p)))
570
571 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
572 ;;; filter
573
574 (defun howm-view-filter (&optional remove-p)
575   (interactive "P")
576   (let* ((table howm-view-filter-methods)
577          (command (completing-read (if remove-p
578                                        "(Reject) filter by: "
579                                      "filter by: ")
580                                    table nil t)))
581     (call-interactively (cdr (assoc command table)))))
582
583 (defun howm-view-filter-uniq ()
584   (interactive)
585   (howm-view-filter-doit #'howm-filter-items-uniq))
586
587 (defun howm-view-filter-by-name (&optional remove-p regexp)
588   (interactive "P")
589   (howm-view-filter-by-name/summary #'howm-filter-items-by-name
590                                     regexp remove-p))
591
592 (defun howm-view-filter-by-summary (&optional remove-p regexp)
593   (interactive "P")
594   (howm-view-filter-by-name/summary #'howm-filter-items-by-summary
595                                     regexp remove-p))
596
597 (defun howm-view-filter-by-name/summary (filter regexp remove-p)
598   (let* ((r (or regexp (howm-view-filter-read-from-minibuffer "Regexp: "
599                                                               remove-p)))
600          (f `(lambda (item-list rmv-p)
601                (funcall #',filter item-list ,r rmv-p))))
602     (howm-view-filter-doit f remove-p)))
603
604 (defun howm-view-filter-by-date (&optional remove-p)
605   (interactive "P")
606   (howm-view-filter-by-time-range #'howm-filter-items-by-date
607                                   remove-p))
608
609 (defun howm-view-filter-by-reminder (&optional remove-p)
610   (interactive "P")
611   (howm-view-filter-by-time-range #'howm-filter-items-by-reminder remove-p))
612
613 (defun howm-view-filter-by-mtime (&optional remove-p range)
614   (interactive "P")
615   (howm-view-filter-by-time-range #'howm-filter-items-by-mtime remove-p range))
616
617 (defun howm-view-filter-by-time-range (filter &optional remove-p range)
618   (let* ((r (or range (howm-view-ask-time-range remove-p)))
619          (from (car r))
620          (to (cadr r))
621          (f `(lambda (item-list rmv-p)
622                (funcall #',filter item-list ',from ',to rmv-p))))
623     (howm-view-filter-doit f remove-p)))
624
625 (defun howm-view-filter-by-region (beg end)
626   (interactive "r")
627   (let ((r (mapcar #'howm-view-line-number (list beg end))))
628     (howm-view-filter-by-line-range (car r) (cadr r))))
629
630 (defvar howm-view-filter-by-around-default 10)
631 (defun howm-view-filter-by-around (&optional distance)
632   (interactive "P")
633   (let* ((d (or distance howm-view-filter-by-around-default))
634          (c (howm-view-line-number)))
635     (howm-view-filter-by-line-range (- c d) (+ c d))))
636
637 (defun howm-view-filter-by-line-range (beg end)
638   (let ((f `(lambda (item-list remove-p)
639               (when remove-p
640                 (error "Not supported."))
641               ;; beg and end are counted as 1,2,3,...
642               (cl-subseq item-list
643                               (max (1- ,beg) 0)
644                               ;; end is included.
645                               (min ,end (length item-list))))))
646     (howm-view-filter-doit f)))
647
648 (defun howm-view-filter-by-contents (&optional remove-p regexp)
649   (interactive "P")
650   (let ((r (or regexp (howm-view-filter-read-from-minibuffer
651                        "Search in result (grep): "
652                        remove-p))))
653     (if remove-p
654         (howm-view-remove-by-contents r)
655       (howm-view-search-in-result r))))
656
657 (howm-if-ver1dot3 nil
658   (defcustom howm-view-search-in-result-correctly t
659     "*Non nil if search-in-result should be aware of paragraph."
660     :type 'boolean
661     :group 'howm-search))
662
663 (defun howm-view-search-in-result (regexp)
664 ;;   (interactive "sSearch in result (grep): ")
665   (let* ((orig (howm-view-name))
666          (name (if (string= orig "")
667                    regexp
668                  (format "%s&%s" orig regexp)))
669          (orig-item-list (howm-view-item-list))
670          (folder (howm-make-folder-from-items orig-item-list)))
671     (howm-write-history regexp)
672     (howm-view-search-folder regexp folder name)
673     (when howm-view-search-in-result-correctly
674       (howm-view-summary-rebuild (howm-item-list-filter (howm-view-item-list)
675                                                         orig-item-list)))))
676
677 (defun howm-view-remove-by-contents (regexp)
678 ;;   (interactive "s(Reject) Search in result (grep): ")
679   (let ((howm-v-r-b-c-regexp regexp))
680     (howm-view-sort/filter-doit
681      (lambda (item-list switch)
682        (howm-filter-items-by-contents item-list howm-v-r-b-c-regexp t)))))
683
684 (defun howm-view-sort/filter-doit (proc &optional switch)
685   (let ((kw font-lock-keywords))
686     (prog1
687         ;; return item-list for
688         ;; https://howm.osdn.jp/cgi-bin/hiki/hiki.cgi?HidePrivateReminder
689         (howm-view-summary-rebuild (funcall proc (howm-view-item-list) switch))
690       (setq font-lock-keywords kw))))
691
692 (defalias 'howm-view-filter-doit 'howm-view-sort/filter-doit)
693
694 ;; For backward compatibility with howmoney. Don't use this.
695 (defun howm-view-filter-general (pred)
696   (howm-view-filter-doit (lambda (item-list dummy)
697                            (cl-remove-if-not pred item-list))))
698 ;; (defun howm-view-filter-general (pred &optional remove-p with-index)
699 ;;   (let* ((item-list (howm-view-item-list))
700 ;;          (s (if with-index
701 ;;                 (howm-map-with-index #'list item-list)
702 ;;               item-list))
703 ;;          (r (if remove-p
704 ;;                 (cl-remove-if pred s)
705 ;;               (cl-remove-if-not pred s)))
706 ;;          (filtered (if with-index
707 ;;                        (mapcar #'car r)
708 ;;                      r)))
709 ;;     (howm-view-summary-rebuild filtered)))
710
711 (defmacro howm-filter-items (pred lis &optional remove-p)
712   `(if ,remove-p
713        (cl-remove-if ,pred ,lis)
714      (cl-remove-if-not ,pred ,lis)))
715
716 (defun howm-filter-items-uniq (item-list &optional remove-p)
717   (when remove-p
718     (error "Not supported."))
719   (let* ((howm-view-filter-uniq-prev (if howm-view-search-in-result-correctly
720                                          (cons "" nil)
721                                        ""))
722          (pred (if howm-view-search-in-result-correctly
723                    (lambda (item)
724                      (let ((page (howm-item-page item))
725                            (place (howm-item-place item))
726                            (range (howm-item-range item))
727                            (p-page  (car howm-view-filter-uniq-prev))
728                            (p-range (cdr howm-view-filter-uniq-prev)))
729                        (prog1
730                            (not (and (howm-page= page p-page)
731                                      (and place p-range
732                                           (<= (car p-range) place)
733                                           (<= place (cadr p-range)))))
734                          (setq howm-view-filter-uniq-prev (cons page range)))))
735                  ;; old code
736                  (lambda (item)
737                    (let ((f (howm-view-item-filename item)))
738                      (prog1
739                          (not (howm-page= f howm-view-filter-uniq-prev))
740                        (setq howm-view-filter-uniq-prev f)))))))
741     (cl-remove-if-not pred item-list)))
742
743 (defun howm-filter-items-by-name (item-list regexp &optional remove-p)
744   (howm-filter-items-by-name/summary #'howm-view-item-basename
745                                      item-list regexp remove-p))
746
747 (defun howm-filter-items-by-summary (item-list regexp &optional remove-p)
748   (howm-filter-items-by-name/summary #'howm-view-item-summary
749                                      item-list regexp remove-p))
750
751 (defun howm-filter-items-by-name/summary (accessor item-list regexp remove-p)
752   (howm-filter-items (lambda (item)
753                        (string-match regexp (funcall accessor item)))
754                      item-list remove-p))
755
756 (defun howm-filter-items-by-date (item-list from to &optional remove-p)
757   (let* ((form (howm-view-file-name-format))
758          (fts (mapcar (lambda (x)
759                         (file-name-nondirectory (format-time-string form x)))
760                       (list from to)))
761          (fs (car fts))
762          (ts (cadr fts)))
763     (howm-filter-items (lambda (item)
764                          (let ((cs (howm-view-item-basename item)))
765                            (and (howm-view-string<= fs cs)
766                                 (howm-view-string< cs ts))))
767                        item-list remove-p)))
768
769 (defun howm-filter-items-by-reminder (item-list from to &optional remove-p)
770   (let* ((from-str (format-time-string howm-date-format from))
771          (to-str (format-time-string howm-date-format to))
772          (reg (howm-reminder-regexp howm-reminder-types)))
773     (howm-filter-items
774      (lambda (item)
775        (let ((s (howm-view-item-summary item)))
776          (and (string-match reg s)
777               (let* ((x (match-string-no-properties 0 s)) ;; [2004-02-07]@
778                      (d (and (string-match howm-date-regexp x)
779                              (match-string-no-properties 0 x)))) ;; [2004-02-07]
780                 (and (howm-view-string<= from-str d)
781                      (howm-view-string< d to-str))))))
782      item-list remove-p)))
783
784 (defun howm-filter-items-by-mtime (item-list from to &optional remove-p)
785   (let ((fs (howm-view-time-to-string from))
786         (ts (howm-view-time-to-string to)))
787     (howm-filter-items
788      (lambda (item)
789        (let ((cs (howm-view-mtime (howm-view-item-filename item))))
790          (and (howm-view-string<= fs cs)
791               (howm-view-string< cs ts))))
792      item-list remove-p)))
793
794 (defun howm-filter-items-by-contents (item-list regexp &optional remove-p)
795   (let* ((match (howm-view-search-folder-items-fi regexp item-list)))
796     (if howm-view-search-in-result-correctly
797         (howm-item-list-filter item-list match remove-p)
798       ;; old behavior
799       (let ((match-names (howm-cl-remove-duplicates*
800                           (mapcar #'howm-item-name match))))
801         (howm-filter-items (lambda (item)
802                              (member (howm-item-name item) match-names))
803                            item-list remove-p)))))
804
805 (defun howm-view-file-name-format ()
806   howm-file-name-format) ;; defined in howm-common.el
807
808 (defun howm-view-ask-time-range (&optional remove-p)
809   (let* ((now (current-time))
810          (from (howm-view-ask-time "From" now t remove-p))
811          (to (howm-view-ask-time "To" from nil remove-p)))
812     (list from to)))
813
814 (defvar howm-view-min-year 1950)
815 (defvar howm-view-max-year 2030)
816 (defun howm-view-ask-time (prompt default &optional from-p remove-p)
817   (let* ((z (decode-time default))
818          (yd (nth 5 z))
819          (md (nth 4 z))
820          (dd (nth 3 z)))
821     (let (y0 m0 d0 hour0 min0 sec0)
822       (if from-p
823           (setq y0 howm-view-min-year m0 1 d0 1
824                 hour0 0 min0 0 sec0 0)
825         (setq y0 howm-view-max-year m0 12 d0 'last-day-of-month
826               hour0 24 min0 0 sec0 0))
827       (let ((y (howm-ask-time-sub prompt "year" yd remove-p)))
828         (if (null y)
829             (howm-view-encode-time sec0 min0 hour0 d0 m0 y0)
830           (let ((m (howm-ask-time-sub prompt "month" md remove-p)))
831             (if (null m)
832                 (howm-view-encode-time sec0 min0 hour0 d0 m0 y)
833               (let ((d (or (howm-ask-time-sub prompt "date" dd remove-p) d0)))
834                 (howm-view-encode-time sec0 min0 hour0 d m y)))))))))
835
836 (defun howm-ask-time-sub (prompt ymd default remove-p)
837   (let* ((message (format "%s %s (* = no limit) [%d]: " prompt ymd  default))
838          (raw (howm-view-filter-read-from-minibuffer message remove-p))
839          (n (if (string= raw "")
840                 default
841               (string-to-number raw))))
842     (if (= n 0)
843         nil
844       n)))
845
846 (defun howm-view-encode-time (sec min hour d m y)
847   (when (eq d 'last-day-of-month)
848     (setq m (+ m 1))
849     (setq d -1))
850   (encode-time sec min hour d m y))
851
852 (defun howm-view-filter-read-from-minibuffer (message &optional remove-p)
853   (read-from-minibuffer (if remove-p
854                             (concat "(Reject) " message)
855                           message)))
856
857 (defun howm-view-summary-rebuild (item-list &optional fl-keywords)
858   (howm-view-summary (howm-view-name) item-list fl-keywords))
859
860 (let* ((h (regexp-quote howm-view-title-header))
861        (t1 (format "Skip \"%s \"" howm-view-title-header))
862        (r1 (format "^\\(%s\\)? *$" h))
863        (t2 (format "Skip \"%s \" and \"[xxxx-xx-xx xx:xx]\""
864                    howm-view-title-header))
865        (r2 (format "\\(%s\\)\\|\\(^\\[[-: 0-9]+\\]\\)" r1)))
866   (howm-if-ver1dot3 nil
867     (defcustom howm-view-title-skip-regexp r2
868       "*Regular expression for lines which should not be titles.
869 If the original title matches this regexp, the first non-matched line
870 is shown as title instead.
871 Nil disables this feature.
872
873 This feature does not work when `howm-view-search-in-result-correctly' is nil."
874       :type `(radio (const :tag "Off" nil)
875                     (const :tag ,t1 ,r1)
876                     (const :tag ,t2 ,r2)
877                     regexp)
878       :group 'howm-title
879       :group 'howm-efficiency)))
880
881 (defcustom howm-view-list-title-type 1
882   "*Type of showing title in summary buffer.
883 Value 1 means \"show title instead of summary\".
884 Value 2 means \"show title before summary\".
885 You may want to set `howm-view-summary-format' to be \"\" if you never need
886 to see file names."
887   :type '(radio (const :tag "title instead of summary"
888                        1)
889                 (const :tag "title before summary"
890                        2))
891   :group 'howm-experimental)
892
893 (defun howm-view-list-title (title-regexp)
894   (howm-view-summary-rebuild (howm-entitle-items
895                               title-regexp (howm-view-item-list))))
896
897 (defun howm-entitle-items (title-regexp item-list)
898   (if (= howm-view-list-title-type 1)
899       (howm-entitle-items-style1 title-regexp item-list)
900     (howm-entitle-items-style2 title-regexp item-list)))
901
902 (defun howm-entitle-items-style1 (title-regexp item-list)
903   "Put title instead of summary."
904   (let ((items (howm-view-search-folder-items-fi title-regexp item-list)))
905     (if howm-view-search-in-result-correctly
906         (let* ((r (howm-item-list-filter items item-list 'with-rest))
907                (hit-items (car r))
908                (nohit-items (cdr r))
909                ;; should I use (howm-classify #'howm-item-place nohit-items) ?
910                (noplace-nohit-items
911                 (cl-remove-if #'howm-item-place nohit-items))
912                (rest-items
913                 (howm-item-list-filter (cl-remove-if-not #'howm-item-place
914                                                               nohit-items)
915                                        items t))
916                (all-items (append hit-items noplace-nohit-items rest-items)))
917           (when howm-view-title-skip-regexp
918             (mapc #'howm-view-change-title all-items))
919           all-items)
920       (let* ((pages (howm-cl-remove-duplicates* (mapcar #'howm-item-page
921                                                         item-list)))
922              (hit-pages (mapcar #'howm-item-page items))
923              (nohit-pages (cl-remove-if
924                            (lambda (p) (cl-member p hit-pages
925                                                         :test #'howm-page=))
926                            pages))
927              (nohit-items (mapcar #'howm-make-item nohit-pages))
928              (all-items (if (null nohit-items)
929                             items
930                           (append items nohit-items))))
931         all-items))))
932
933 (defvar howm-entitle-items-style2-max-length 20)
934 (defvar howm-entitle-items-style2-format "%-13s | %s") ;; for title and summary
935 (defvar howm-entitle-items-style2-title-line nil) ;; independent title line?
936 (defun howm-entitle-items-style2 (title-regexp item-list)
937   "Put title before summary."
938   ;; fix me: howm-item-place is not set for howm-list-all
939   (let ((last-title ""))
940     (cl-mapcan
941      (lambda (item)
942        (let ((orig (howm-item-summary item))
943              (titles (howm-item-titles item)))
944          (cl-mapcan
945           (lambda (s)
946             (if (string= s last-title)
947                 (setq s "")
948               (setq last-title s))
949             (when (> (length s) howm-entitle-items-style2-max-length)
950               (setq s (substring s 0 howm-entitle-items-style2-max-length)))
951             (mapcar (lambda (x)
952                       (let ((i (howm-item-dup item)))
953                         (howm-item-set-summary i x)
954                         i))
955                     (if (and howm-entitle-items-style2-title-line
956                              (not (string= s "")))
957                         (list (format howm-entitle-items-style2-format
958                                       s "")
959                               (format howm-entitle-items-style2-format
960                                       "" orig))
961                       (list (format howm-entitle-items-style2-format
962                                     s orig)))))
963           (or titles (list "")))))
964      item-list)))
965
966 ;;; detect items in same paragraph (= entry = memo. sorry for inconsistent terminology)
967
968 (defun howm-item-with-temp-buffer (item proc)
969   (with-temp-buffer
970     (howm-page-insert (howm-item-page item))
971     (let* ((p (howm-item-place item))
972            (r (if (null p)
973                   (list (point-min) (point-max))
974                 (progn
975                   (riffle-set-place p)
976                   (howm-view-paragraph-region)))))
977       (narrow-to-region (car r) (cadr r))
978       (funcall proc item))))
979
980 (defun howm-item-titles (item)
981   "List of titles of ITEM.
982 When place (see `howm-item-place') is specified, ITEM has at most one title.
983 Otherwise, ITEM can have two or more titles."
984   (howm-item-with-temp-buffer
985    item
986    (lambda (i)
987      (let ((titles nil))
988        (goto-char (point-min))
989        (while (re-search-forward (howm-list-title-regexp) nil t)
990          (setq titles
991                (cons (buffer-substring-no-properties (match-beginning 0)
992                                                      (line-end-position))
993                      titles)))
994        (mapcar (lambda (x)
995                  (if (string-match howm-view-title-regexp x)
996                      (match-string-no-properties howm-view-title-regexp-pos x)
997                    x))
998                (reverse titles))))))
999
1000 (defun howm-item-range (item)
1001   "List of beginning-place and end-place of paragraph to which ITEM belongs."
1002   (howm-item-with-temp-buffer
1003    item
1004    (lambda (i)
1005      (let ((r (list (point-min) (point-max))))
1006        (widen)
1007        (list (progn
1008                (goto-char (car r))
1009                (riffle-get-place))
1010              (progn
1011                (goto-char (cadr r))
1012                (riffle-get-place)))))))
1013 ;;   (with-temp-buffer
1014 ;;     (howm-page-insert (howm-item-page item))
1015 ;;     (let* ((p (howm-item-place item))
1016 ;;            (r (if (null p)
1017 ;;                   (list (point-min) (point-max))
1018 ;;                 (progn
1019 ;;                   (riffle-set-place p)
1020 ;;                   (howm-view-paragraph-region)))))
1021 ;;       (list (progn
1022 ;;               (goto-char (car r))
1023 ;;               (riffle-get-place))
1024 ;;             (progn
1025 ;;               (goto-char (cadr r))
1026 ;;               (riffle-get-place))))))
1027
1028 (defun howm-item-list-rangeset (item-list)
1029   "Make assoc list of page to rangeset.
1030 ITEM-LIST is list of items.
1031 Return value is assoc list; each element of it is a cons pair of page
1032 and rangeset which indicates ranges of places of paragraphs to which items
1033 in ITEM-LIST belongs."
1034   (let ((alist nil))  ;; key = page, value = rangeset of place
1035     (cl-labels ((add-to-alist (page rs)
1036                            (setq alist (cons (cons page rs) alist))))
1037       (mapc (lambda (item)
1038               (let* ((page (howm-item-page item))
1039                      (place (howm-item-place item))
1040                      (rs (cdr (assoc page alist))))
1041                 (cond ((null place)
1042                        (add-to-alist page (howm-make-rangeset)))
1043                       ((null rs)
1044                        (add-to-alist page (howm-make-rangeset
1045                                            (howm-item-range item))))
1046                       ((howm-rangeset-belong-p place rs)
1047                        nil) ;; do nothing
1048                       (t
1049                        (howm-rangeset-add! rs (howm-item-range item))))))
1050             item-list)
1051       alist)))
1052
1053 (defun howm-item-list-filter (item-list reference-item-list
1054                                         &optional remove-match)
1055   "Select items in ITEM-LIST according to REFERENCE-ITEM-LIST.
1056 When REMOVE-MATCH is nil, return value is list of items i in ITEM-LIST
1057 which satisfy the condition \"there exists i' in REFERENCE-ITEM-LIST
1058 such that i and i' belong to same paragraph\" (case 1).
1059 When REMOVE-MATCH is non-nil and not the symbol 'with-rest',
1060 return value is complement of the above list;
1061 list of items in ITEM-LIST which do not satisfy the above condition (case 2).
1062 When REMOVE-MATCH is the symbol 'with-rest',
1063 return value is (A . B), where A is the return value of case 1 and
1064 B is items in REFERENCE-ITEM-LIST that do not match in case 1."
1065   ;; 
1066   ;; split no-place items:
1067   ;; Though implementation 1 calls grep many times,
1068   ;; implementation 2 is slower in construction of folder from items.
1069   ;; [2012-12-28]
1070   ;; 
1071   ;; implementation 1 (call grep many times)
1072   (setq item-list
1073         (cl-mapcan (lambda (item)
1074                           (if (howm-item-place item)
1075                               (list item)
1076                             (or (howm-view-search-folder-items-fi
1077                                  (howm-view-title-regexp-grep) (list item))
1078                                 (list item))))
1079                         item-list))
1080   ;; 
1081   ;; ;; implementation 2 (making items-folder is slow)
1082   ;; (let* ((place-items (cl-remove-if-not #'howm-item-place item-list))
1083   ;;        (no-place-items (cl-remove-if #'howm-item-place item-list))
1084   ;;        (split-items (howm-view-search-folder-items-fi
1085   ;;                      (howm-view-title-regexp-grep) no-place-items))
1086   ;;        ;;; !!!!!!!!! use CL !!!!!!!!!!!!!!!!!!!!!!!!!!!!
1087   ;;        (no-title-items (set-difference no-place-items split-items
1088   ;;                                        :key #'howm-item-page)))
1089   ;;   (setq item-list (append place-items split-items no-title-items)))
1090   ;;
1091   (let* ((alist (howm-item-list-rangeset reference-item-list))
1092          (matcher (lambda (item)
1093                     (let* ((page (howm-item-page item))
1094                            (place (howm-item-place item))
1095                            (rs (cdr (assoc page alist))))
1096                       (cond ((null rs) nil)
1097                             ((howm-rangeset-belong-p place rs) rs)
1098                             (t nil))))))
1099     (cond ((eq remove-match 'with-rest)
1100            (let ((match (cl-remove-if-not
1101                          (lambda (item)
1102                            (let ((rs (funcall matcher item)))
1103                              (and rs (howm-rangeset-hit! rs))))
1104                          item-list)))
1105              (cons match
1106                    (cl-mapcan
1107                     (lambda (a) (and (not (howm-rangeset-hit-p (cdr a)))
1108                                      (list (howm-make-item (car a)))))
1109                     alist))))
1110           (remove-match (cl-remove-if matcher item-list))
1111           (t (cl-remove-if-not matcher item-list)))))
1112
1113 ;;; rangeset
1114 ;;; ex.
1115 ;;; (*rangeset* (1 . 4) (5 . 6) (8 . 14))
1116 ;;; (*rangeset*) ==> "almighty"
1117 ;;; (*rangeset-hit* (1 . 4) (5 . 6) (8 . 14)) ==> "hit" is recorded
1118
1119 (defun howm-make-rangeset (&optional beg-end)
1120   (if (null beg-end)
1121       (cons '*rangeset* nil)
1122     (let ((rs (howm-make-rangeset)))
1123       (howm-rangeset-add! rs beg-end))))
1124
1125 (defun howm-rangeset-belong-p (point rs)
1126   (or (null (cdr rs))
1127       (cl-member-if (lambda (pair)
1128                            (and (<= (car pair) point) (<= point (cdr pair))))
1129                          (cdr rs))))
1130
1131 (defun howm-rangeset-add! (rs beg-end)
1132   ;; "almighty" is ignored here. sorry for confusion...
1133   ;; c = cursor (pointing its cdr)
1134   ;; p = pair
1135   (let ((c rs)
1136         (beg (car beg-end))
1137         (end (cadr beg-end)))
1138     (while (and (cdr c) beg)
1139       (let ((p (cadr c)))
1140         (cond ((< end (car p)) ;; insert [beg, end] here
1141                (rplacd c (cons (cons beg end) (cdr c)))
1142                (setq beg nil))
1143               ((< (cdr p) beg) ;; skip this
1144                (setq c (cdr c)))
1145               (t ;; merge into [beg, end]
1146                (setq beg (min beg (car p))
1147                      end (max end (cdr p)))
1148                (rplacd c (cddr c))))))
1149     (when beg
1150       (rplacd c (list (cons beg end)))))
1151   rs)
1152
1153 (defvar howm-rangeset-hit-indicator '*rangeset-hit*)
1154
1155 (defun howm-rangeset-hit! (rs)
1156   (setcar rs howm-rangeset-hit-indicator))
1157
1158 (defun howm-rangeset-hit-p (rs)
1159   (eq (car rs) howm-rangeset-hit-indicator))
1160
1161 ;; check
1162
1163 (let ((tests '(
1164                (()
1165                 ())
1166                (((3 . 5))
1167                 ((3 . 5)))
1168                (((3 . 5) (0 . 1))
1169                 ((0 . 1) (3 . 5)))
1170                (((3 . 5) (6 . 8))
1171                 ((3 . 5) (6 . 8)))
1172                (((3 . 5) (1 . 4))
1173                 ((1 . 5)))
1174                (((3 . 5) (4 . 7))
1175                 ((3 . 7)))
1176                (((3 . 5) (1 . 9))
1177                 ((1 . 9)))
1178                (((3 . 1) (4 . 1) (5 . 9))
1179                 ((1 . 4) (5 . 9)))
1180                (((3 . 1) (4 . 1) (5 . 9) (2 . 6) (5 . 3))
1181                 ((1 . 9)))
1182                ))
1183        ;; inhibit 'reference to free variable' warning in byte-compilation
1184       (check nil))
1185   (cl-labels ((check (ans result)
1186                   (cond ((null ans) (null result))
1187                         ((not (equal (car ans) (car result))) nil)
1188                         (t (funcall check (cdr ans) (cdr result))))))
1189     (mapc (lambda (z)
1190             (apply (lambda (prob ans)
1191                      (let* ((rs (howm-make-rangeset)))
1192                        (mapc (lambda (pair)
1193                                (let ((a (car pair))
1194                                      (b (cdr pair)))
1195                                  (howm-rangeset-add! rs
1196                                                      (list (min a b)
1197                                                            (max a b)))))
1198                              prob)
1199                        (when (not (equal (cdr rs) ans))
1200                          (error "howm-rangeset-add: %s ==> %s" prob rs))))
1201                    z))
1202           tests)))
1203
1204 (let ((rs '(*rangeset* (1 . 4) (5 . 6) (8 . 14))))
1205   (if (and (howm-rangeset-belong-p 1 rs)
1206            (howm-rangeset-belong-p 3 rs)
1207            (howm-rangeset-belong-p 4 rs)
1208            (howm-rangeset-belong-p 5 rs)
1209            (not (howm-rangeset-belong-p 0 rs))
1210            (not (howm-rangeset-belong-p 4.5 rs))
1211            (not (howm-rangeset-belong-p 7 rs))
1212            (not (howm-rangeset-belong-p 15 rs)))
1213       t
1214     (error "howm-rangeset-belong-p: wrong result")))
1215
1216 (defun howm-view-change-title (item)
1217   (when (string-match howm-view-title-skip-regexp (howm-item-summary item))
1218     (let ((title-line (with-temp-buffer
1219                         (howm-page-insert (howm-item-page item))
1220                         (howm-view-set-place (or (howm-item-place item)
1221                                                  (howm-view-get-place
1222                                                   (point-min))))
1223                         (howm-view-get-title-line))))
1224       (howm-item-set-summary item title-line))))
1225
1226 (defun howm-view-get-title-line ()
1227   (while (and (looking-at howm-view-title-skip-regexp)
1228               (= (forward-line 1) 0))
1229     ;; do nothine
1230     )
1231   (buffer-substring-no-properties (line-beginning-position)
1232                                   (line-end-position)))
1233
1234 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1235 ;;; search
1236
1237 (defun howm-view-search (str file-list &optional
1238                              name summarizer fixed-p hilit-keywords)
1239   "This function is not used in howm any more."
1240   (howm-view-search-folder str (howm-make-folder:files file-list)
1241                            name summarizer fixed-p hilit-keywords))
1242
1243 (defun howm-view-search-items (str file-list &optional summarizer fixed-p)
1244   (howm-view-search-folder-items str (howm-make-folder:files file-list)
1245                                  summarizer fixed-p))
1246
1247 (defun howm-view-search-folder (&rest args)
1248   (howm-view-search-folder-doit (apply #'howm-view-search-folder-internal
1249                                        args)))
1250
1251 (defun howm-view-search-folder-internal (str folder
1252                                              &optional name summarizer
1253                                              fixed-p hilit-keywords)
1254   ;; clean me. str-orig can be string or list of strings.
1255   (let* ((str-orig str)
1256          (str-list (if (listp str-orig) str-orig (list str-orig)))
1257          (str-principal (if (listp str-orig) (car str-orig) str-orig)))
1258     ;; rename str
1259     (setq str str-principal)
1260     (setq name (or name str))
1261     (when howm-view-update-search-ring
1262       (isearch-update-ring str (not fixed-p)))
1263     (let* ((items (howm-view-search-folder-items str-orig
1264                                                  folder summarizer fixed-p))
1265            (kw (or hilit-keywords
1266                    (let ((r (if fixed-p
1267                                 (regexp-opt str-list)
1268                               (mapconcat (lambda (x) (concat "\\(" x "\\)"))
1269                                          str-list
1270                                          "\\|"))))
1271                      `((,r . howm-view-hilit-face))))))
1272       (let* ((f (expand-file-name str)))
1273         (when (file-exists-p f)
1274           (let ((fi (howm-view-make-item f)))
1275             (howm-view-item-set-privilege fi t)
1276             (setq items (cons fi items)))))
1277       (list kw name items))))
1278
1279 (defun howm-view-search-folder-doit (p)
1280   (howm-view-summary (cadr p) (cl-caddr p) (car p)))
1281
1282 (defun howm-view-search-folder-items (str folder &optional summarizer fixed-p)
1283   (let ((found (howm-folder-grep folder str fixed-p))
1284         (summarizer (or summarizer
1285                         (lambda (file place content)
1286                           (string-match "^ *\\(.*\\)" content)
1287                           (match-string-no-properties 1 content)))))
1288     (mapc (lambda (i)
1289             (let ((file (howm-page-name (howm-item-page i)))
1290                   (place (howm-item-place i))
1291                   (content (howm-item-summary i)))
1292               (howm-item-set-summary i (funcall summarizer
1293                                                 file place content))))
1294           found)
1295     found))
1296
1297 ;; sorry for confusing functions...
1298
1299 (defun howm-view-search-folder-items-fi (regexp item-list &rest args)
1300   (apply #'howm-view-search-folder-items
1301          regexp (howm-make-folder-from-items item-list) args))
1302
1303 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1304 ;;; sort
1305
1306 (defun howm-view-sort ()
1307   (interactive)
1308   (let* ((table howm-view-sort-methods)
1309          (command (completing-read "sort by: " table nil t)))
1310     (call-interactively (cdr (assoc command table)))))
1311
1312 (defmacro howm-view-defun-sort-by (name)
1313   "Define an interactive command howm-view-sort-by-NAME,
1314 which simply calls howm-sort-items-by-NAME."
1315   (let ((command (howm-get-symbol nil "howm-view-sort-by-" name))
1316         (internal (howm-get-symbol nil "howm-sort-items-by-" name)))
1317     `(defun ,command (&optional reverse-p)
1318        (interactive "P")
1319        (howm-view-sort-doit #',internal reverse-p))))
1320 (howm-view-defun-sort-by "random")
1321 (howm-view-defun-sort-by "name")
1322 (howm-view-defun-sort-by "numerical-name")
1323 (howm-view-defun-sort-by "date")
1324 (howm-view-defun-sort-by "reverse-date")
1325 (howm-view-defun-sort-by "summary")
1326 (howm-view-defun-sort-by "reminder")
1327 (howm-view-defun-sort-by "mtime")
1328 (howm-view-defun-sort-by "reverse")
1329
1330 (defalias 'howm-view-sort-reverse 'howm-view-sort-by-reverse)
1331
1332 (defalias 'howm-view-sort-doit 'howm-view-sort/filter-doit)
1333
1334 (defmacro howm-sort-items (evaluator comparer item-list
1335                                              &optional reverse-p)
1336   `(let* ((howm-view-s-i-comparer ,comparer)
1337           (cmp (if reverse-p
1338                    (lambda (a b) (funcall howm-view-s-i-comparer b a))
1339                  howm-view-s-i-comparer)))
1340      (howm-sort ,evaluator cmp item-list)))
1341
1342 ;; ;; generate the below aliases for howm-test080714
1343 ;; (let ((methods '("random" "name" "numerical-name" "date" "reverse-date"
1344 ;;                  "summary" "reminder" "mtime" "reverse")))
1345 ;;   (mapcar (lambda (m)
1346 ;;             (let* ((command
1347 ;;                     (howm-get-symbol nil "howm-view-sort-by-" m))
1348 ;;                    (internal
1349 ;;                     (howm-get-symbol nil "howm-sort-items-by-" m))
1350 ;;                    (obsolete
1351 ;;                     (howm-get-symbol nil command "-internal")))
1352 ;;               `(defalias ',obsolete ',internal)))
1353 ;;           methods))
1354
1355 ;; for backward compatibility with howm-test080714 only
1356 (defalias 'howm-view-sort-by-random-internal 'howm-sort-items-by-random)
1357 (defalias 'howm-view-sort-by-name-internal 'howm-sort-items-by-name)
1358 (defalias 'howm-view-sort-by-numerical-name-internal
1359   'howm-sort-items-by-numerical-name)
1360 (defalias 'howm-view-sort-by-date-internal 'howm-sort-items-by-date)
1361 (defalias 'howm-view-sort-by-reverse-date-internal
1362   'howm-sort-items-by-reverse-date)
1363 (defalias 'howm-view-sort-by-summary-internal 'howm-sort-items-by-summary)
1364 (defalias 'howm-view-sort-by-reminder-internal 'howm-sort-items-by-reminder)
1365 (defalias 'howm-view-sort-by-mtime-internal 'howm-sort-items-by-mtime)
1366 (defalias 'howm-view-sort-by-reverse-internal 'howm-sort-items-by-reverse)
1367
1368 (defun howm-sort-items-by-random (item-list &optional reverse-p)
1369   (howm-sort-items #'(lambda (dummy) (random)) #'< item-list reverse-p))
1370
1371 (defun howm-sort-items-by-name (item-list &optional reverse-p)
1372   (howm-sort-items #'howm-view-item-basename #'string< reverse-p))
1373
1374 (defun howm-sort-items-by-numerical-name (item-list &optional reverse-p)
1375   (howm-sort-items (lambda (i)
1376                              (let ((b (howm-view-item-basename i)))
1377                                (if (string-match "^[0-9]+$" b)
1378                                    (string-to-number b)
1379                                  howm-infinity)))
1380                            #'< reverse-p))
1381
1382 (defvar howm-view-sort-by-date-ignore-regexp "^[a-zA-Z]")
1383 (defun howm-sort-items-by-date (item-list &optional reverse-p)
1384   (let ((sorted (howm-sort-items #'howm-view-item-basename #'string<
1385                                          item-list reverse-p)))
1386     (cdr (howm-view-lift-internal #'howm-view-item-basename
1387                                   sorted
1388                                   howm-view-sort-by-date-ignore-regexp
1389                                   t))))
1390
1391 (defun howm-sort-items-by-reverse-date (item-list &optional reverse-p)
1392   (howm-sort-items-by-date item-list (not reverse-p)))
1393
1394 (defun howm-sort-items-by-summary (item-list &optional reverse-p)
1395   (howm-sort-items #'howm-view-item-summary #'string<
1396                            item-list reverse-p))
1397
1398 (defun howm-sort-items-by-reminder (item-list &optional reverse-p)
1399   (let* ((howm-view-s-b-r-i-regexp (howm-reminder-regexp howm-reminder-types))
1400          (howm-view-s-b-r-i-max (format-time-string
1401                                  howm-reminder-today-format
1402                                  (encode-time 59 59 23 31 12
1403                                               howm-view-max-year)))
1404          (evaluator (lambda (item)
1405                       (let ((s (howm-view-item-summary item)))
1406                         (if (string-match howm-view-s-b-r-i-regexp s)
1407                             (match-string-no-properties 0 s)
1408                           howm-view-s-b-r-i-max)))))
1409     (howm-sort-items evaluator #'string< item-list reverse-p)))
1410
1411 (defun howm-sort-items-by-mtime (item-list &optional reverse-p)
1412   (howm-sort-items (lambda (item)
1413                      (howm-view-mtime (howm-view-item-filename item)))
1414                    #'howm-view-string>
1415                    item-list reverse-p))
1416
1417 (defun howm-sort-items-by-reverse (item-list &optional dummy)
1418   (reverse item-list))
1419
1420 ;;; lift (move matched items to the top)
1421
1422 (defun howm-view-lift-by-name (&optional reverse-p regexp path-p)
1423   (interactive "P")
1424   (howm-view-lift-doit (if path-p
1425                            #'howm-view-lift-by-path-internal
1426                          #'howm-view-lift-by-name-internal)
1427                        reverse-p regexp))
1428
1429 (defun howm-view-lift-by-summary (&optional reverse-p regexp)
1430   (interactive "P")
1431   (howm-view-lift-doit #'howm-view-lift-by-summary-internal
1432                        reverse-p regexp))
1433
1434 (defun howm-view-lift-by-summary-substring (&optional reverse-p regexp
1435                                                       regexp-pos)
1436   (interactive "P")
1437   (howm-view-lift-doit #'howm-view-lift-by-summary-substring-internal
1438                        reverse-p regexp regexp-pos))
1439
1440 (defun howm-view-lift-doit (sorter &optional reverse-p regexp
1441                                             regexp-pos)
1442   (let* ((howm-view-s-b-m-d-regexp (or regexp
1443                                        (read-from-minibuffer "Regexp: ")))
1444          (howm-view-s-b-m-d-regexp-pos regexp-pos)
1445          (howm-view-s-b-m-d-sorter sorter)
1446          (howm-view-s-b-m-d-matched nil))
1447     (howm-view-sort-doit (lambda (item-list rvs-p)
1448                            (let ((p (apply howm-view-s-b-m-d-sorter
1449                                            item-list
1450                                            howm-view-s-b-m-d-regexp
1451                                            rvs-p
1452                                            howm-view-s-b-m-d-regexp-pos)))
1453                              (setq howm-view-s-b-m-d-matched (car p))
1454                              (cdr p)))
1455                          reverse-p)
1456     howm-view-s-b-m-d-matched))
1457
1458 (defun howm-view-lift-internal (picker item-list regexp
1459                                        &optional reverse-p regexp-pos)
1460   "Sort items and return (matched . sorted-list).
1461 matched can be nil, single, or multi."
1462   (let* ((howm-view-l-i-matched nil)
1463          (evaluator (lambda (item)
1464                       (let ((str (funcall picker item)))
1465                         (if (string-match regexp str)
1466                             (progn
1467                               (setq howm-view-l-i-matched
1468                                     (if howm-view-l-i-matched 'multi 'single))
1469                               (if regexp-pos
1470                                   (match-string-no-properties regexp-pos str)
1471                                 1))
1472                           0))))
1473          (comparer (if regexp-pos
1474                        (lambda (x y)
1475                          (cond ((eq x 0) nil)
1476                                ((eq y 0) t)
1477                                (t (string< x y))))
1478                      #'>)))
1479     (let ((sorted-list (howm-sort-items evaluator comparer item-list
1480                                         reverse-p)))
1481       (cons howm-view-l-i-matched sorted-list))))
1482
1483 (defun howm-view-lift-by-name-internal (item-list regexp &optional reverse-p)
1484   (howm-view-lift-internal #'howm-view-item-basename
1485                            item-list regexp reverse-p))
1486
1487 (defun howm-view-lift-by-path-internal (item-list regexp &optional reverse-p)
1488   (howm-view-lift-internal #'howm-item-name item-list regexp reverse-p))
1489
1490 (defun howm-view-lift-by-summary-internal (item-list regexp &optional reverse-p)
1491   (howm-view-lift-internal #'howm-view-item-summary item-list regexp reverse-p))
1492
1493 (defun howm-view-lift-by-summary-substring-internal (item-list regexp
1494                                                                &optional
1495                                                                reverse-p
1496                                                                regexp-pos)
1497   (howm-view-lift-internal #'howm-view-item-summary item-list regexp reverse-p
1498                            (or regexp-pos 0)))
1499
1500 ;; backward compatibility
1501 (defalias 'howm-view-sort-by-name-match 'howm-view-lift-by-name)
1502 (defalias 'howm-view-sort-by-summary-match 'howm-view-lift-by-summary)
1503 (defalias 'howm-view-sort-by-summary-match-string
1504   'howm-view-lift-by-summary-substring)
1505
1506 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1507 ;;; Dired-X
1508
1509 (defvar howm-view-dired-buffer-name "*howm-dired*")
1510 (howm-defvar-risky howm-view-dired-ls-command "ls")
1511 (howm-defvar-risky howm-view-dired-ls-options '("-l"))
1512
1513 (defun dired-virtual (dir)
1514   (howm-inhibit-warning-in-compilation))
1515
1516 (defun howm-view-dired ()
1517   (interactive)
1518   (require (if (howm-xemacsp) 'dired-vir 'dired-x))
1519   (when (not (member major-mode
1520                      '(howm-view-summary-mode howm-view-contents-mode)))
1521     (error "Invalid mode for this command."))
1522 ;;   ;; bug in emacs-21.3.50?
1523 ;;   (when (not (fboundp 'dired-insert-headerline))
1524 ;;     (defun dired-insert-headerline (dir);; also used by dired-insert-subdir
1525 ;;       ;; Insert DIR's headerline with no trailing slash, exactly like ls
1526 ;;       ;; would, and put cursor where dired-build-subdir-alist puts subdir
1527 ;;       ;; boundaries.
1528 ;;       (save-excursion (insert "  " (directory-file-name dir) ":\n"))))
1529   (let* ((i2f (lambda (item)
1530                 (file-relative-name (howm-view-item-filename item))))
1531          (current-file (funcall i2f (riffle-summary-current-item)))
1532          (files (howm-cl-remove-duplicates* (mapcar i2f (howm-view-item-list))
1533                                             :test #'equal))
1534 ;;          (pos (cl-position f files :test #'string=))
1535          (args (append howm-view-dired-ls-options files))
1536          (a `((howm-view-summary-mode . ,howm-view-summary-persistent)
1537               (howm-view-contents-mode . ,howm-view-contents-persistent)))
1538          (p (howm-view-persistent-p (cdr (assoc major-mode a)))))
1539     (if p
1540         (howm-view-restore-window-configuration)
1541       (howm-view-kill-buffer))
1542     (switch-to-buffer (get-buffer-create howm-view-dired-buffer-name))
1543     (setq buffer-read-only nil)
1544     (erase-buffer)
1545     (howm-call-process-here howm-view-dired-ls-command args)
1546     (set-buffer-modified-p nil)
1547     (dired-virtual default-directory)
1548     (howm-view-dired-goto current-file)))
1549
1550 (defun howm-view-dired-goto (rname)
1551 "In dired buffer, search file name RNAME and move cursor to corresponding line.
1552 RNAME must be relative name."
1553   (goto-char (point-min))
1554   ;; Raw call of `dired-get-filename' and `dired-next-line' causes
1555   ;; warnings in compilation.
1556   (while (let ((c (howm-funcall-if-defined (dired-get-filename 'no-dir t))))
1557            (not (and c (equal (file-relative-name c) rname))))
1558     (howm-funcall-if-defined (dired-next-line 1))))
1559
1560 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1561 ;;; shell
1562
1563 (howm-defvar-risky howm-view-summary-shell-hist '("ls -l FILE" "FILE"))
1564 (howm-defvar-risky howm-view-summary-shell-last-file "FILE")
1565 (defun howm-view-summary-shell-command ()
1566   (interactive)
1567   (when (not (member major-mode
1568                      '(howm-view-summary-mode)))
1569     (error "Invalid mode for this command."))
1570   (let* ((n (howm-view-line-number))
1571          (item (nth (1- n) (howm-view-item-list)))
1572          (file (howm-page-abbreviate-name (howm-view-item-filename item)))
1573          (last-reg (regexp-quote howm-view-summary-shell-last-file)))
1574     (setq howm-view-summary-shell-hist
1575           (mapcar (lambda (h)
1576                     (replace-regexp-in-string last-reg file h t))
1577                   howm-view-summary-shell-hist))
1578     (setq howm-view-summary-shell-last-file file)
1579     (let* ((default (car howm-view-summary-shell-hist))
1580            (c (read-string "command: "
1581                            (cons default 0)
1582                            '(howm-view-summary-shell-hist . 1))))
1583       (shell-command c))
1584     (let ((item-list (cl-remove-if (lambda (item)
1585                                           (not (file-exists-p
1586                                                 (howm-view-item-filename item))))
1587                                         (howm-view-item-list))))
1588       (setq *riffle-summary-check* nil) ;; dirty
1589       (howm-view-summary (howm-view-name) item-list)
1590       (howm-goto-line n)
1591       (save-selected-window
1592         (let ((b (get-buffer "*Shell Command Output*")))
1593           (cond ((not (howm-buffer-empty-p b))
1594                  (switch-to-buffer-other-window b))
1595                 ((eq item (riffle-summary-current-item))
1596                  nil)
1597                 (t (progn
1598                      (setq *riffle-summary-check* t) ;; dirty
1599                      (howm-view-summary-check t))))))
1600       )))
1601
1602 ;;; howm-view.el ends here