38. メモを書こう (2006/01/18)

(autoload 'clmemo "clmemo" "ChangeLog memo mode." t)
(define-key ctl-x-map "M" 'clmemo)
(setq clmemo-entry-list
      '("emacs" "book" "url" "idea" "download" "soft" "meadowmemo"))
(autoload 'clgrep "clgrep" "grep mode for ChangeLog file." t)
(autoload 'clgrep-title "clgrep" "grep first line of entry in ChangeLog." t)
(autoload 'clgrep-header "clgrep" "grep header line of ChangeLog." t)
(autoload 'clgrep-other-window "clgrep" "clgrep in other window." t)
(autoload 'clgrep-clmemo "clgrep" "clgrep directly ChangeLog MEMO." t)
(add-hook 'change-log-mode-hook
          '(lambda ()
             (define-key change-log-mode-map "\C-c\C-g" 'clgrep)
             (define-key change-log-mode-map "\C-c\C-t" 'clgrep-title)))

;; 2003-01-15
;; 日誌のときだけ ChangeLog メモに曜日を入れる
;;
;; 使用前: 2003-01-15  Satoru Takabayashi  
;; 使用後: 2003-01-15 (Wed)  Satoru Takabayashi  
;;
(defvar change-log-diary-file-name-regexp "clmemo.txt")
(defun add-log-iso8601-time-string-with-weekday ()
  (let ((system-time-locale "C"))
    (concat (add-log-iso8601-time-string)
            " " "(" (format-time-string "%a") ")")))

(add-hook 'change-log-mode-hook
          (function
           (lambda ()
             (if (and (buffer-file-name)
                      (string-match change-log-diary-file-name-regexp
                                    (buffer-file-name)))
                 (set (make-local-variable 'add-log-time-format)
                      'add-log-iso8601-time-string-with-weekday)))))

;; 常に入れておきたいタイトルのリスト
(defvar clmemo-title-list
  '("idea" "system" "url" "computer")
  "*List of entries.
Set your favourite entry of ChangeLog MEMO.")

;; 最近の記事からヘッダを拾い出す
(when (file-exists-p clmemo-file-name)
  (with-temp-buffer
    ;; 行頭から5000文字を拾い出す
    (insert-file-contents clmemo-file-name
                          nil 0 5000)
    (let ((entry nil) (subentry nil))
      (goto-char (point-min))
      (while (re-search-forward
              "^\t\\*[ ]+\\([^:\n]+\\):" nil t)
        (setq entry
              (buffer-substring-no-properties
               (match-beginning 1)
               (match-end 1)))
        (when (string-match "(" entry)
          (setq subentry
                (substring
                 entry
                 (+ (string-match "(" entry) 1)
                 (- (length entry) 1)))
          (setq entry
                (substring entry
                           0
                           (string-match "(" entry)))
          (if (or (member subentry clmemo-title-list)
                  (not entry))
              ()
            (setq clmemo-title-list
                  (cons subentry clmemo-title-list))
            (setq subentry nil)))
        (if (or (member entry clmemo-title-list)
                (not entry))
            ()
          (setq clmemo-title-list
                (cons entry clmemo-title-list))
          (setq entry nil))))))

(defadvice clmemo-completing-read
  (after set-entry activate)
  (let ((entry ad-return-value))
    (if (or (member entry clmemo-title-list)
            (not entry))
        ()
      (if (string-match "+" entry)
          (setq entry
                (substring
                 entry
                 0
                 (string-match "+" entry))))
      (setq clmemo-title-list
            (cons entry clmemo-title-list)))))

     clmemo-file-name nil 0 10000)

(autoload 'postit "postit" nil t)
(setq postit-colorize 'dark)
;; ファイルの圧縮はしない
(setq postit-compress-commands nil)

;; 日記のファイルが作成されるディレクトリ
(setq schedule-dir "~/Calendar")
(autoload 'schedule "nikki" nil t)

(setq my-memo-list
      '("emacs.txt" "url.txt"))
(setq my-memo-dir "~/memo/puti")

(defvar my-memo-window-conf nil)

(require 'newcomment)
(defun my-memo-insert (category memo-text str)
  (let ((coding-system-for-read 'euc-jp-unix)
        (coding-system-for-write 'euc-jp-unix)
        memo-buf (cbuf (current-buffer))
        )

    (if (get-file-buffer
         (expand-file-name category my-memo-dir))
        (setq memo-buf
              (get-file-buffer
               (expand-file-name category my-memo-dir)))
      (setq memo-buf
            (find-file-noselect
             (expand-file-name  category my-memo-dir))))

    (set-buffer memo-buf)
    (goto-char (point-min))
    (insert
     (concat
      (format-time-string "[%Y/%m/%d %k:%M:%S] ")
      memo-text))
    (if (and comment-add
             (= comment-add 0))
        ()
      (comment-region
       (save-excursion (goto-char (point-min))
                       (push-mark nil nil t) (point))
       (save-excursion (end-of-line) (point))))

    (insert (concat
             "\n"
             str
             "\n\n"))

    (insert
     (concat
      "------------------------------------------------------------"
      "\n"))
    (forward-line -1)
    (if (and comment-add
             (= comment-add 0))
        ()
      (comment-region
       (save-excursion
         (beginning-of-line) (push-mark nil nil t) (point))
       (save-excursion
         (forward-line 1) (beginning-of-line) (point))))
    (save-buffer)
    (set-buffer cbuf)
    (kill-buffer memo-buf)
    ))

(defun my-memo-initialize ()
  (if (and (file-exists-p my-memo-dir)
           (file-directory-p my-memo-dir))
      ()
    (make-directory my-memo-dir))
  )

(defun my-memo-read-category ()
  (let ((file-list nil) category)
    ;; directory list
    (setq file-list (mapcar '(lambda (file)
                               (if (and (string-match ".+$" file)
                                        (not (file-directory-p file)))
                                   file))
                            (directory-files my-memo-dir)))

    (setq file-list (delq nil file-list))
    (setq file-list (append my-memo-list file-list))
    (setq category (completing-read
                    "memo category : "
                    (mapcar 'list file-list)
                    nil nil))
    (if (file-name-extension category)
        ()
      (setq category (concat category ".txt")))
    category
    ))

(defun my-memo-new ()
  (interactive)
  (let (category memo-text str)
    (setq str (buffer-substring (point-min) (point-max)))
    (my-memo-initialize)
    (setq category (my-memo-read-category))
    (setq memo-text (read-from-minibuffer "input memo : "))
    (my-memo-insert category memo-text str)
    (kill-buffer (current-buffer))
    (set-window-configuration my-memo-window-conf)
    ))

(defun my-memo (&optional arg)
  (interactive "P")
  (let (category memo-text str
                 (cbuf (current-buffer))
                 )
    (setq my-memo-window-conf (current-window-configuration)))

  (cond
   (arg
    (let ((moccur-use-migemo nil)
          (dmoccur-mask-internal '(".*"))
          (moccur-split-word nil))
      (dmoccur my-memo-dir "\\[[/0-9]+ [/:0-9]+\\]" nil)))

   (mark-active
    (setq str (buffer-substring (region-beginning) (region-end)))
    (my-memo-initialize)
    (setq category (my-memo-read-category))
    (setq memo-text (read-from-minibuffer "input memo : "))
    (my-memo-insert category memo-text str)
    )
   (t
    (with-output-to-temp-buffer "*my-memo*"
      (switch-to-buffer "*my-memo*")
      (kill-all-local-variables)

      (local-set-key "\C-c\C-c" 'my-memo-new)))

   ))

;; 必要に応じてキーバインドを追加
(global-set-key "\C-c\C-w" 'my-memo)

(autoload 'memo-mode "memo-mode" "Memo mode" t)

(provide 'embed-memo)

(setq howm-menu-lang 'ja)
(global-set-key "\C-c,," 'howm-menu)
(mapc
 (lambda (f)
   (autoload f
     "howm" "Hitori Otegaru Wiki Modoki" t))
 '(howm-menu howm-list-all howm-list-recent
             howm-list-grep howm-create
             howm-keyword-to-kill-ring))

;; リンクを TAB で辿る
(eval-after-load "howm-mode"
  '(progn
     (define-key howm-mode-map [tab] 'action-lock-goto-next-link)
     (define-key howm-mode-map [(meta tab)] 'action-lock-goto-previous-link)))
;; 「最近のメモ」一覧時にタイトル表示
(setq howm-list-recent-title t)
;; 全メモ一覧時にタイトル表示
(setq howm-list-all-title t)
;; メニューを 2 時間キャッシュ
(setq howm-menu-expiry-hours 2)

;; howm の時は auto-fill で
(add-hook 'howm-mode-on-hook 'auto-fill-mode)

;; RET でファイルを開く際, 一覧バッファを消す
;; C-u RET なら残る
(setq howm-view-summary-persistent nil)

;; メニューの予定表の表示範囲
;; 10 日前から
(setq howm-menu-schedule-days-before 10)
;; 3 日後まで
(setq howm-menu-schedule-days 3)

;; howm のファイル名
;; 以下のスタイルのうちどれかを選んでください
;; で，不要な行は削除してください
;; 1 メモ 1 ファイル (デフォルト)
(setq howm-file-name-format "%Y/%m/%Y-%m-%d-%H%M%S.howm")
;; 1 日 1 ファイルであれば
(setq howm-file-name-format "%Y/%m/%Y-%m-%d.howm")

(setq howm-view-grep-parse-line
      "^\\(\\([a-zA-Z]:/\\)?[^:]*\\.howm\\):\\([0-9]*\\):\\(.*\\)$")
;; 検索しないファイルの正規表現
(setq
 howm-excluded-file-regexp
 "/\\.#\\|[~#]$\\|\\.bak$\\|/CVS/\\|\\.doc$\\|\\.pdf$\\|\\.ppt$\\|\\.xls$")

;; いちいち消すのも面倒なので
;; 内容が 0 ならファイルごと削除する
(if (not (memq 'delete-file-if-no-contents after-save-hook))
    (setq after-save-hook
          (cons 'delete-file-if-no-contents after-save-hook)))
(defun delete-file-if-no-contents ()
  (when (and
         (buffer-file-name (current-buffer))
         (string-match "\\.howm" (buffer-file-name (current-buffer)))
         (= (point-min) (point-max)))
    (delete-file
     (buffer-file-name (current-buffer)))))

;; http://howm.sourceforge.jp/cgi-bin/hiki/hiki.cgi?SaveAndKillBuffer
;; C-cC-c で保存してバッファをキルする
(defun my-save-and-kill-buffer ()
  (interactive)
  (when (and
         (buffer-file-name)
         (string-match "\\.howm"
                       (buffer-file-name)))
    (save-buffer)
    (kill-buffer nil)))
(eval-after-load "howm"
  '(progn
     (define-key howm-mode-map
       "\C-c\C-c" 'my-save-and-kill-buffer)))

 ;; メニューを自動更新しない
(setq howm-menu-refresh-after-save nil)
;; 下線を引き直さない
(setq howm-refresh-after-save nil)

(eval-after-load "calendar"
  '(progn
     (define-key calendar-mode-map
       "\C-m" 'my-insert-day)
     (defun my-insert-day ()
       (interactive)
       (let ((day nil)
             (calendar-date-display-form
         '("[" year "-" (format "%02d" (string-to-int month))
           "-" (format "%02d" (string-to-int day)) "]")))
         (setq day (calendar-date-string
                    (calendar-cursor-to-date t)))
         (exit-calendar)
         (insert day)))))

(defun my-get-date-gen (form)
  (insert (format-time-string form)))
(defun my-get-date ()
  (interactive)
  (my-get-date-gen "[%Y-%m-%d]"))
(defun my-get-time ()
  (interactive)
  (my-get-date-gen "[%H:%M]"))
(defun my-get-dtime ()
  (interactive)
  (my-get-date-gen "[%Y-%m-%d %H:%M]"))
(global-set-key "\C-c\C-d" 'my-get-date)
(global-set-key "\C-c\C-t" 'my-get-time)
(global-set-key "\C-c\ed" 'my-get-dtime)

(autoload 'howm-mode
  "howm-mode" "Hitori Otegaru Wiki Modoki" t)
(defadvice howm-mode
  (before outline-minor activate)
  (outline-minor-mode t))
(require 'outline)
(defun my-outline-flip-subtree (&optional dummy)
  (interactive)
  (if (save-excursion
        (forward-line 1)
        (let ((p (overlays-at (line-beginning-position)))
              (ol nil))
          (while (and p (not ol))
            (setq ol (overlay-get (car p) 'invisible))
            (setq p (cdr p)))
          ol))
      (show-subtree)
    (hide-subtree)))
(defun add-my-action-lock-rule ()
  (let ((rule
         (action-lock-general
          'my-outline-flip-subtree
          (if (and
               buffer-file-name
               (string-match "\\.howm$" buffer-file-name))
              "^ *\\(\\*\\**\\)"
            (concat "\\(" outline-regexp "\\)"))
          1 1)))
    (if (not (member rule action-lock-default-rules))
        (progn (setq action-lock-default-rules
                     (cons rule action-lock-default-rules))
               (action-lock-set-rules action-lock-default-rules)))))
(add-hook 'action-lock-mode-on-hook 'add-my-action-lock-rule)

(require 'calendar)
(require 'howm-mode)
(setq
 calendar-date-display-form
 '("[" year "-" (format "%02d" (string-to-int month))
   "-" (format "%02d" (string-to-int day)) "]"))
(setq diary-file
      (expand-file-name "diary" howm-directory))

(defun howm-mark-calendar-date ()
  (interactive)
  (require 'howm-reminder)
  (let* ((today (howm-reminder-today 0))
         (limit (howm-reminder-today 1))
         (howm-schedule-types
          howm-schedule-menu-types)
         (raw (howm-reminder-search
               howm-schedule-types))
         (str nil) (yy nil) (mm nil) (dd nil))
    (while raw
      (setq str (nth 1 (car raw)))
      (when
          (string-match
           "\\([0-9]+\\)-\\([0-9]+\\)-\\([0-9]+\\)"
           str)
        (setq yy (match-string 1 str))
        (setq mm (match-string 2 str))
        (setq dd (match-string 3 str)))
      (when (and yy mm dd)
        (mark-calendar-date-pattern
         (string-to-int mm)
         (string-to-int dd)
         (string-to-int yy)))
      (setq mm nil)
      (setq dd nil)
      (setq yy nil)
      (setq raw (cdr raw))
      )))

(defadvice mark-diary-entries
  (after mark-howm-entry activate)
  (howm-mark-calendar-date))

(setq
 howm-menu-display-rules
 (cons
  (cons "%hdiary[\n]?" 'howm-menu-diary)
  howm-menu-display-rules
   ))

(defun howm-menu-diary ()
  (require 'diary-lib)
  (message "scanning diary...")
  (delete-region
   (match-beginning 0) (match-end 0))
  (let* ((now (decode-time (current-time)))
         (diary-date
          (list (nth 4 now) (nth 3 now) (nth 5 now)))
         (diary-display-hook 'ignore)
         (cbuf (current-buffer))
         (howm-diary-entry nil)
         (howm-diary-entry-day nil)
         (str nil))
    (unwind-protect
        (setq howm-diary-entry
              (list-diary-entries
               diary-date howm-menu-schedule-days))
      (save-excursion
        (set-buffer
         (find-buffer-visiting diary-file))
        (subst-char-in-region
         (point-min) (point-max) ?\^M ?\n t)
        (setq selective-display nil)))

    (while howm-diary-entry
      (setq howm-diary-entry-day (car howm-diary-entry))
      (setq mm (nth 0 (car howm-diary-entry-day)))
      (setq dd (nth 1 (car howm-diary-entry-day)))
      (setq yy (nth 2 (car howm-diary-entry-day)))
      (setq str (nth 1 howm-diary-entry-day))
      (setq howm-diary-entry (cdr howm-diary-entry))
      (insert
       (format
        ">>d [%04d-%02d-%02d] %s\n" yy mm dd str))))
  (message "scanning diary...done")
  )

(setq diary-date-forms
      '((month "/" day "[^/0-9]")
        (month "/" day "/" year "[^0-9]")
        ("\\[" year "-" month "-" day "\\]" "[^0-9]")
        (monthname " *" day "[^,0-9]")
        (monthname " *" day ", *" year "[^0-9]")
        (dayname "\\W")))

(defun howm-open-diary (&optional dummy)
  (interactive)
  (let ((date-str nil) (str nil))
    (save-excursion
      (beginning-of-line)
      (when (re-search-forward
             ">>d \\(\\[[-0-9]+\\]\\) " nil t)
        (setq str
              (concat
               "^.+"
               (buffer-substring-no-properties
                (point) (line-end-position))))
        (setq date-str
              (concat
               "^.+"
               (buffer-substring-no-properties
                (match-beginning 1)
                (match-end 1))
               " " str))
        (find-file
         (substitute-in-file-name diary-file))
        (howm-mode t)
        (goto-char (point-min))
        (if (re-search-forward date-str nil t)
            ()
          (re-search-forward str nil t))))))

(defun add-diary-action-lock-rule ()
  (let ((rule
         (action-lock-general
          'howm-open-diary
          "^\\(>>d\\) "
          1 1)))
    (if (not (member rule action-lock-default-rules))
        (progn
          (setq action-lock-default-rules
                (cons rule action-lock-default-rules))
          (action-lock-set-rules
           action-lock-default-rules)))))

(add-hook 'action-lock-mode-on-hook
          'add-diary-action-lock-rule)

(defadvice make-diary-entry
  (after howm-mode activate)
  (text-mode)
  (howm-mode t))

;; M-x calendar しといて M-x howm-from-calendar
;;         → その日付を検索
(defun howm-from-calendar ()
  (interactive)
  (require 'howm-mode)
  (let* ((mdy (calendar-cursor-to-date t))
         (m (car mdy))
         (d (second mdy))
         (y (third mdy))
         (key (format-time-string
               howm-date-format
               (encode-time 0 0 0 d m y))))
    (howm-keyword-search key)))

;;カレンダーの上で d を押すと grep
(add-hook 'initial-calendar-window-hook
          '(lambda ()
             (local-set-key
              "d" 'howm-from-calendar)))

;;howm のメニューで d でカレンダー
(add-hook 'howm-menu-hook
          '(lambda ()
             (local-set-key "d" 'calendar)))

(setq
 howm-excluded-file-regexp
 (concat
  "\\(^\\|/\\)\\([.]\\|CVS/\\)\\|"
  "[~#]$\\|"
  "\\.\\("
  (mapconcat
   (lambda (f) f)
   '(
     "doc" "pdf" "ppt" "xls"
     "bak" "elc" "gz" "aux"
     "toc" "idx" "dvi" "jpg"
     "gif" "png"
     ) "\\|") "\\)$"))
(setq imcap-capture-command-format
      (concat
       "d:/home/bin/WinShot.exe"
       " -Jpeg -Rectangle -Close -File %s"))
(autoload 'imcap-capture "imcap"
  "Hitori Otegaru Wiki Modoki image capture" t)
(autoload 'imcap-display "imcap"
  "Hitori Otegaru Wiki Modoki image capture" t)
(add-hook 'howm-view-open-hook 'imcap-display)

(defadvice kill-region
  (around delete-image-file activate)
  (when (and (boundp 'howm-mode)
             howm-mode)
    (let ((str
           (split-string
            (buffer-substring-no-properties
             (ad-get-arg 0)
             (ad-get-arg 1)) "[\n\r]+"))
          (line nil)
          (imagefile nil))
      (while str
        (setq line (car str))
        (if (string-match
             ">>> \\(.*\\.\\(jpg\\|png\\|gif\\)\\)"
             line)
            (setq imagefile (match-string 1 line)))
        (when (and imagefile
                   (file-exists-p
                    (expand-file-name imagefile)))
          (if (y-or-n-p
               (format
                "Delete image file %s?" imagefile))
              (progn
                (setq imagefile
                      (expand-file-name imagefile))
                (delete-file imagefile))))
        (setq imagefile nil)
        (setq str (cdr str)))))
  ad-do-it)

(autoload 'imcap-image-downsize "imcap"
  "imcap" t)
(autoload 'imcap-image-upsize "imcap"
  "imcap" t)

(eval-after-load "howm-mode"
  '(progn
     (define-key howm-mode-map [f11]
       'imcap-image-downsize)
     (define-key howm-mode-map [f12]
       'imcap-image-upsize)))