.xyzzy載せてみる

なんとなく。もう使ってない機能とか多い。

(pushnew (merge-pathnames "site-lisp/howm/" (si:system-root))
        *load-path* :test #'string-equal)
(require "howm-wrap")
;; `howm-init.l' をコピーしてない場合、以下を有効に。
;; 日本語メニューを使う。
;(setq elisp-lib::howm-menu-lang 'elisp-lib::ja)


(require "nise-about")
(require "isearch")

;;howm関係
;;(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-file-name-format "%Y/%Y%m%d-%H%M%S.howm")
(setq howm-keyword-file "~/howm/.howm-keys")

(setq elisp-lib::howm-menu-refresh-after-save nil)

;;; -*- Mode: Lisp -*-
; $Id: sample.xyzzy,v 1.3 2005/11/24 15:12:27 torihat Exp $
;
; sample.xyzzy for www-mode
;
; by HATTORI Masashi

(autoload 'www "www/www" t)	                ; 通常起動
(autoload 'www-open-url "www/www" t)            ; URLを指定して起動
(autoload 'www-open-local-file "www/www" t)     ; ローカルのファイルを指定して開く
(autoload 'www-open-current-buffer "www/www" t)	; 現在のバッファのファイルを開く


;;;info-modoki-mode
;;; .xyzzyか、もしくはsiteinit.lに以下を記述する
(require "info-modoki-mode")
(define-key ed::*lisp-mode-map* #\F1 'imm-refer-selection)
(define-key ed::*lisp-interaction-mode-map* #\F1 'imm-refer-selection)

(in-package "editor")

(defvar *lisp-keyword-hash-table* nil)

(defun use-lisp-keyword ()
  "キーワード色付け"
  (if (null *lisp-keyword-hash-table*)
      (setq *lisp-keyword-hash-table*
            (load-keyword-file "lisp")))
  (when *lisp-keyword-hash-table*
    (make-local-variable 'keyword-hash-table)
    (setq keyword-hash-table *lisp-keyword-hash-table*)))

(add-hook '*lisp-mode-hook*
          #'(lambda ()
              (use-lisp-keyword)
              (define-key *lisp-mode-map* #\C-. 'lisp-complete-symbol)))

(add-hook '*lisp-interaction-mode-hook*
          #'(lambda ()
              (use-lisp-keyword)
              (define-key *lisp-interaction-mode-map* #\C-. 'lisp-complete-symbol)))

(in-package "user")

;;;;;
;;C-x t d
(defun insert-my-date-string()
(interactive)
(insert (format-date-string "[%Y-%m-%d]")))
(global-set-key '(#\C-x #\t #\d) 'insert-my-date-string)

;;; -*- Mode: Lisp; syntax: lisp -*- 
; .xyzzy のサンプル
; 必要な物を.xyzzyにコピーしてください

; ■ KaTeX
; *load-path* に追加 (.xyzzyに必須)
(push (merge-pathnames "site-lisp/katex" (si:system-root)) *load-path*)

;;; 以下は、siteinit.lでも可
;;;  siteinit.lへ書くときは、↑をsiteinit.lにも書くこと
; パッケージを有効にする
(require "elisp")

; texファイルを読み込んだとき、KaTeXモードにする
(push '("\\.tex$" . elisp::katex-mode) *auto-mode-alist*)
;(push '("\\.sty$" . elisp::katex-mode) *auto-mode-alist*)
;(push '("\\.cls$" . elisp::katex-mode) *auto-mode-alist*)
(autoload 'elisp::katex-mode "katex" t)

; Alt+Ret が使えるようにする
(set-extended-key-translate-table exkey-M-return #\M-RET)

;;; 各種設定
; TeXのコマンド
;(setq elisp::tex-command "platex") ; "platex"を使う
(setq elisp::dvi2-command "c:/usr/local/dviout/dviout")
(setq elisp::tex-command "platex -src") ; source specialを使う
;追加
(defun katex-dvisrcprv ()
  (interactive)
  (let* ((tex-file (get-buffer-file-name))
         (dvi-file (el::KaTeX-get-preview-file-name)))
    (call-process (concat el::dvi2-command " -1 " dvi-file " \"\# "
                          (format nil "~D" (current-line-number)) " " tex-file "\"")
                  :exec-directory (directory-namestring tex-file))))
; 全般的な設定
;(setq elisp::*KaTeX-prefix* #\F4) ; "C-c"でコピーしたい
;(setq elisp::KaTeX-use-AMS-LaTeX t) ; AMS-LaTeXを使う
(setq elisp::KaTeX-math-need-image t) ; 数式モードでTABを押したときにイメージを表示する
(setq elisp::*KaTeX-math-formats*
      (compile-regexp-keyword-list
       '(("\\$[^$]*\\$" t (:keyword 2) nil)))) ; 正規表現での色付け
; [色表示の指定]の部分は、xyzzyのChangeLog.htmlの
;    Mon Jul 02 2001 Version 0.2.2.202
; 付近をみる

; toolbar
(setq elisp::*KaTeX-use-toolbar* t) ; KaTeX toolbarを表示する
; toolbar を[表示]->[ツールバー]から削除したい場合は、
;  (elisp::KaTeX-delete-tool-bar)
; で消えるはず

; プロセス関係
;(setq elisp::*typeset-with-shell-command* t) ; TeXの実行に *shell* を使う
(setq elisp::*preview-with-typeset* t) ; previewするファイルがなければ、typesetする

; 補完関係
;(setq elisp::KaTeX-no-begend-shortcut t) ; [prefix] b ?? のショートカットを使わない
;(setq elisp::KaTeX-default-document-style "jsarticle") ; document-styleの初期値
;(setq elisp::env-name "eqnarray") ; begin型補完の初期値
;(setq elisp::section-name "section") ; section型補完の初期値
;(setq elisp::fontsize-name "bf") ; large型補完の初期値
;(setq elisp::single-command "newpage") ; maketitle型補完の初期値

; その他
;(setq elisp::KaTeX-default-pop-window-height 6) ; 画面を分割するときの高さ
(setq elisp::KaTeX-template-file "../template.tex") ; 新規ファイル作成時に読み込むファイル
;(setq elisp::KaTeX-fill-column 60) ; 自動改行の幅を変える

; ■ kahtml
;(push '("\\.html$" . elisp::kahtml-mode) *auto-mode-alist*)
;(autoload 'elisp::kahtml-mode "kahtml" t) ; "Yet Another HTML mode"

; hook
;(add-hook 'elisp::katex-mode-hook
;	  #'(lambda ()
;	      (auto-fill-mode nil) ; 自動改行をやめる 
;             (run-hooks '*text-mode-hook*) ; *text-mode-hook* を走らせる
;	      ))
;(add-hook 'elisp::katex-mode-hook 'olt-setting-LaTeX-mode) ; olt の設定
;(pushnew '(elisp::katex-mode . olt-setting-LaTeX-mode)
;	 *olt-setting-alist* :test 'equal))

; katex-mode-load-hook が多くなるときは、katexhks.l に書く
;(add-hook 'elisp::katex-mode-load-hook
;	  #'(lambda ()
;	      (KaTeX-define-begend-key '(#\b #\a) "abstract") ; [prefix] b a で \begine{abstract} \end{abstract} を入力する
;	      ))
;;; 自動改行なし
(add-hook 'elisp::katex-mode-hook
          #'(lambda ()
              (auto-fill-mode nil)))

;;;aspell
(import '(ed::aspell ed::*aspell-command* ed::*aspell-language* imported1 imported1))
(autoload 'aspell "aspell" t)
;(global-set-key #\M-a 'aspell)
(setq *aspell-command* "C:\\Program Files\\Aspell\\bin\\aspell.exe -a") ;"C:\Program Files\Aspell\bin\aspell.exe" check


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; C-S-Returnでウィンドウ表示を切り替え
;;; http://xyzzy.s53.xrea.com/wiki/index.php?cmd=read&page=tips%2F%A5%D0%A5%C3%A5%D5%A5%A1%A4%CE%C9%BD%BC%A8%A4%F2%A5%C8%A5%B0%A5%EB&word=set-buffer-fold-type-none-update
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun previous-buffer-fold ()
  (interactive)
  (case
      (cond
       ((set-buffer-fold-type-none-update) 0)
       ((set-buffer-fold-type-column-update) 1)
       ((set-buffer-fold-type-window-update) 2))
    (2 (set-buffer-fold-type-none)   (message "折り返し表示を止めました。"))
    (0 (set-buffer-fold-type-column) (message "折り返し位置を固定幅にしました。"))
    (1 (set-buffer-fold-type-window) (message "折り返し位置をウィンドウ幅に合わせました。"))
    ))
(set-extended-key-translate-table exkey-S-C-return #\F23)
(global-set-key #\F23 'previous-buffer-fold)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 編集ファイルをエクスプローラで表示
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global-set-key #\C-F11
		#'(lambda ()
		    (interactive)
		    (setq current_file_path (map-slash-to-backslash (directory-namestring (get-buffer-file-name))))
		    (setq command  (concat "explorer.exe " current_file_path))
		    (call-process command )))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; grepの色を目立つように
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq  *grep-highlight-match*
       '( :background 4 :underline nil))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; ディレクトリを自動作成するfind-file
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun find-file-after-create-directory (filename &optional encoding nomsg)
  (interactive "lFind file: \n0zEncoding: " :title0 "Find file")
  (long-operation
    (if (listp filename)
	(dolist (file filename)
	  (find-file-after-create-directory file encoding nomsg))
      (if (file-exist-p (directory-namestring filename))
	  (set-buffer (ed::find-file-internal filename nil encoding nil nomsg))
	(if t
	    (progn
	      (create-directory (directory-namestring filename))
	      (set-buffer (ed::find-file-internal filename nil encoding nil nomsg)))
	  (set-buffer (create-new-buffer filename)))))))

(global-set-key '(#\C-x #\C-f) 'find-file-after-create-directory)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; tips/.lnkを展開する
;;; http://xyzzy.s53.xrea.com/wiki/index.php?cmd=read&page=tips%2F.lnk%A4%F2%C5%B8%B3%AB%A4%B9%A4%EB&word=.lnk
;;; リンク先を開くようにする
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(add-hook
 '*before-find-file-hook*
 #'(lambda (x)
     (let ((sh
	    (ignore-errors
	     (resolve-shortcut x))))
       (when sh
	 (find-file sh)
	 (get-file-buffer sh)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; tips/ファイルを開く時にセッションファイルならば展開する - Xyzzy Wiki
;;; http://xyzzy.s53.xrea.com/wiki/index.php?cmd=read&page=tips%2F%A5%D5%A5%A1%A5%A4%A5%EB%A4%F2%B3%AB%A4%AF%BB%FE%A4%CB%A5%BB%A5%C3%A5%B7%A5%E7%A5%F3%A5%D5%A5%A1%A5%A4%A5%EB%A4%CA%A4%E9%A4%D0%C5%B8%B3%AB%A4%B9%A4%EB&word=.ssn
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(add-hook '*before-find-file-hook*
	  #'(lambda (x)
	      (when (string-matchp "\\.ssn$" x)
		(load-session x)
		(selected-buffer))))

(defun make-directory-unless-directory-exists (filename)
  (unless (valid-path-p filename)
    (let ((d (directory-namestring filename)))
      (when (yes-or-no-p "~a~%ディレクトリがないけど作る?"  d)
        (create-directory d))))
  nil)
; ファイルを開く前に実行
(add-hook '*before-find-file-hook*
          #'make-directory-unless-directory-exists)

;rss-mode
	(autoload 'rss "rss/main" t)
	(autoload 'rss-toggle "rss/main" t)
	(autoload 'rss-add-feed "rss/main" t)

(defun delete-file-if-no-contents ()
  "ファイルサイズ0で保存した場合に確認して削除する"
  (let ((buffer (selected-buffer))
        (file (get-buffer-file-name)))
    (and file (= 0 (buffer-size))
         (yes-or-no-p
          "~a~%は中身がありません。\nバッファを閉じてファイルを削除しますか?"
          buffer)
         (if (delete-file file)
             (or (deleted-buffer-p buffer)
                 (kill-buffer buffer))
           (message-box "削除に失敗しました。")))))
(add-hook '*after-save-buffer-hook* 'delete-file-if-no-contents)

;find-file(C-x C-f)の後F7で.xyzzy、F8でsiteinit.lをロード
(define-key minibuffer-local-completion-map #\F7
    #'(lambda () (interactive)
        (delete-region (point-min) (point-max))
        (insert (concat
            (merge-pathnames ".xyzzy" (user-homedir-pathname))))))

(define-key minibuffer-local-completion-map #\F8
    #'(lambda () (interactive)
        (delete-region (point-min) (point-max))
        (insert (concat
          (merge-pathnames "site-lisp" (si:system-root)) "/"))))

(define-key minibuffer-local-completion-map #\F9
    #'(lambda () (interactive)
        (delete-region (point-min) (point-max))
	(insert "C:/docs/study/")))

(define-key minibuffer-local-completion-map #\F10
    #'(lambda () (interactive)
        (delete-region (point-min) (point-max))
	(insert "C:/Users/foo/Desktop/")))



;;======================================================================
;;  分指定のタイマー
;; 2007/02/18(Sun)
;; 2007/02/20(Tue)
;;  タイマーセット後、他のアプリをアクティブにして作業してると 時間が
;;  来ても、MessageBoxが隠れて見えない(Beep音は スピーカー繋げてない
;;  ので役にたたない)のを対策  API使うので require必須
;;======================================================================
(require "wip/winapi")  ; 必要ならつける
(export '(set-timer))

(defun set-timer (cnt)
  (interactive "n待ち時間は(分)?:" )
  (start-timer (* cnt 60)
    #'(lambda ()
          (winapi:ShowWindow (get-window-handle) 6)  ; SW_MINIMIZE(最小化)
          (winapi:ShowWindow (get-window-handle) 9)  ; SW_RESTORE(元に戻す)
          (message-box (format nil "~D分たったよ!" cnt) "xyzzyタイマー" '(:exclamation) )
       ) t)

  (message (format nil "~D 分タイマーセットしたよ!" cnt))
)
;;tetris
(require "tetris")

;;paren
(require 'paren)
(turn-on-global-paren)

; Emacs 風 write-file
(global-set-key '(#\C-x #\C-w) 'emacs-write-file)

(setq *ebdict-directories* '("c:/dicts/EDict2" "c:/dicts/webster1913" "c:/dicts/WordNet" "c:/dicts/WaDokuJT/epwing"))
(define-key *ebdict-output-mode-map* #\f 'ebdict-output-next-dictionary)

;goo辞書
(defun lookup-goo-dict-selection ()
  (interactive)
  (let* ((str (if (pre-selection-p)
                  (selection-start-end (beg end)
                    (buffer-substring beg end))
                (read-string "goo辞書: ")))
         (url (concat "http://dictionary.goo.ne.jp/search.php?MT="
                      (si:www-url-encode str))))
    (shell-execute url t)))
(global-set-key '(#\C-c #\n) 'lookup-goo-dict-selection)

(defun exec-utf82tex ()
  (interactive)
  (let ((in-file (file-namestring (get-buffer-file-name)))
	(out-file (concat (pathname-name (get-buffer-file-name))
			  "-utex."
			  (pathname-type (get-buffer-file-name))))
	(dir (directory-namestring (get-buffer-file-name)))
	)
    (save-buffer)
    (call-process "utf82tex"
		  :input in-file
		  :output out-file
		  :exec-directory dir
		  :wait t)
    (split-window)
    (other-window)
    (find-file (concat dir out-file))
    ;; 文字コードも自動的に Shift_JIS にしたい場合は
    ;; 下の行の一番左の;を削除(コメントアウト)する。
    (set-buffer-fileio-encoding *encoding-sjis*)
    (set-buffer-modified-p t)
    (save-buffer);強制上書き保存
    ))

;;;;hatena diary
(require "hateda-mode")
(setf hw::*hatedara-multi-accounts*
      '(("Nos" nil "~/hateda" "-t -c ")
	;("ユーザ名" "パスワード" "ディレクトリ" "はてダラに毎回渡す引数")
	))


;;;;mine
(global-set-key #\C-o 'toggle-ime)

;;ドイツ語例文入力用
(defun input-next-japanese (current_point)
  (interactive "d")
  (if (scan-buffer "^$" :regexp t)
      (progn
	(goto-char (match-beginning 0))
	(insert "\\j{" (read-Japanese) "}\n")
	(next-line)
	(input-next-japanese (match-beginning 0)))
    nil))

(defun read-Japanese () ;input-next-japanese専用、空文字列だったらもう一回訊く
  (let ((str (read-string "input Japanese: ")))
    (if (string-equal str "") (read-Japanese) str)))


;;mtascでコンパイル
(defun compile-as-with-mtasc ()
  (interactive)
  (let ((file (file-namestring (get-buffer-file-name)))
	(dir  (directory-namestring (get-buffer-file-name)))
	(buf  (selected-buffer)))
    (setq winconf (current-window-configuration))
    (save-buffer)
    (execute-shell-command (format nil "C:\\flash\\mtasc-1.12\\mtasc.exe -swf ~A.swf -main ~A -version 7 -header 240:320:30" (substring file 0 (string-match ".as" file)) file)
			   nil "*mtasc-output*" nil dir)
    (setup-temp-buffer (find-buffer "*mtasc-output*"))
    (let ((str (buffer-substring 0 (point-max)))
	  (line)
	  (column))
      (set-window-configuration winconf)
      (if (string-equal str "")
	  (message "compile finished successfully.")
	(progn
	  (ding)
	  (message str)
	  (string-match ":\\([0-9]+\\):.+ \\([0-9]+\\)[^0-9].+" str)
	  (setq line   (read-from-string (match-string 1)))
	  (setq column (read-from-string (match-string 2)))
	  (goto-line line)
	  (goto-column column))))))

;;actionscript-mode
(export 'ed::actionscript-mode "ed")
(autoload 'actionscript-mode "actionscript-mode" t)
(pushnew '("\\.asc?$" . actionscript-mode) *auto-mode-alist* :test 'equal)

(setq ed::*actionscript-mode-autosave-as-utf8* t)
(setq ed::*actionscript-use-browser-dll* nil)
(setq ed::*actionscript-use-mm-compatible-shortcuts* nil)

;;lisp-mode キーワードハイライト
(add-hook '*lisp-mode-hook*
  #'(lambda ()
       (make-local-variable 'keyword-hash-table)
       (setf keyword-hash-table (load-keyword-file "lisp"))
       (make-local-variable 'regexp-keyword-list)
       (setf regexp-keyword-list
          (compile-regexp-keyword-list
            '(("(" t (:color 14))
              (")" t (:color 14)))))))

;; wc-region
(defvar wc-script "wc")
(defun wc-region ()
  (interactive)
  (shell-command-on-region (region-beginning) (region-end) wc-script))
(defun wc-buffer ()
  (interactive)
  (shell-command-on-region 1 (buffer-size) wc-script))

;; aspell ドイツ語スペルチェック cf. http://www.shido.info/xyzzy/aspell_l.html
(defun aspell-ready-for-deutsch()
  (interactive)
  (write-file (get-buffer-file-name) nil nil *encoding-iso-8859-1*)
  (setq ed::*aspell-language* "de"))
(defun aspell-ready-for-english()
  (interactive)
  (write-file (get-buffer-file-name) nil nil *encoding-iso-8859-1*)
  (setq ed::*aspell-language* "en"))

(defun count-words-region (start end)
  (interactive "r")
  (save-excursion
  (let ((count 0))
    (goto-char start)
    (while (< (point) end )
      (forward-word 1)
      (setq count (1+ count)))
    (message "buffer contained ~d words." count))))

;; topmost
(require "topmost")
(global-set-key #\S-C-F11 'toggle-topmost-xyzzy)
(set-function-bar-label #\S-C-F11 "toggle top")

;; google補完
(require "junk/http")
(defvar *google-suggest-url* "http://www.google.com/complete/search?hl=en&js=true&qu=")
(defun google-suggest-query(string)
  (with-open-stream (stream
		     (junk::junk-http-get-url
		      (concat *google-suggest-url* string)))
    (remove nil (mapcar #'(lambda(x)(if(string-match string x)(string-trim " \"" x)))
			(split-string (read-line stream nil) #\,)))))

; 英次郎
;(load-library "eijiro/eijiro") ; ※前バージョンと異なってます!!
;(global-set-key '(#\C-c #\e) 'ie-eijiro-selection)

; 国語辞書
(global-set-key '(#\C-c #\j) 'jj-dictionary-selection)

;; word-tools
(require "word-tools")

;(setq *error-output* (make-buffer-stream (create-new-buffer "*Stack Trace*")))
;(setq si:*trace-on-error* t)

(mc-load-library "deutsch-dic/sanshusha-dic")

(global-set-key '(#\C-c #\d) 'lookup-d2j-dictionary-word)

(defun comment-out-section (p)
  (interactive "d")
  (save-excursion
    (let* ((from (progn
		   (scan-buffer "\\\\section\\*?{" :regexp t :reverse t)
		   (goto-char (match-beginning 0))
		   (current-line-number)))
	   (to   (progn
		   (goto-char p)
		   (scan-buffer "\\\\section\\*{" :regexp t)
		   (goto-char (match-beginning 0))
		   (current-line-number))))
      (dotimes (i (- to from))
	(progn
	  (goto-line (+ i from))
	  (goto-bol)
	  (insert "%"))))))

(global-set-key '(#\C-x #\h) 'mark-whole-buffer)



;--- 単語に色をつける ---
(require "strcolor")
;(global-set-key '(#\C-c #\C-s) 'set-color-sexp)
(global-set-key '(#\C-c #\C-o) 'set-string-color)
(global-set-key #\C-\; 'search-color-text-forward)
(global-set-key #\C-\: 'search-color-text-backward)
(global-set-key '(#\C-c #\C-p) 'clear-string-all-colors)
(setq *match-string-forecolor* 3)
(setq *match-string-backcolor* 1)

;--- サーチした文字に色をつける ---
(setq *show-match-hook* 'search-strcolor)
(defun search-strcolor ()
  ( clear-string-all-colors )
  ( set-string-color-after-search ed::*last-search-string* )
  t
  )

(defun emacs-next-error (&optional arg)
  (interactive "p")
  (if (not editor::*error-list*)
      (progn
        (goto-char (point-min))
        (first-error arg nil))
    (next-error arg)))

(define-key ctl-x-map #\F11 'emacs-next-error)


(defun task-open ()
  (interactive)
  (let* ((frame "Task")
         (fa "S:/docs/task/schedule.txt")
         (fb "S:/docs/task/tel.txt")
         (fc "S:/docs/task/todo.txt")
         (bl (list (file-namestring fa)
                   (file-namestring fb)
                   (file-namestring fc))))
    (new-pseudo-frame frame)
    (split-window 12 nil) (find-file fa)
    (split-window -50 t) (find-file fb)
    (other-window 1) (find-file fc)
    (other-window 1)
    (defun task-close ()
      (interactive)
      (let ((pf (find-pseudo-frame frame)))
        (when pf
          (delete-pseudo-frame pf)
          (dolist (buf bl)
            (when (find-buffer buf)
              (kill-buffer buf))))))))


(require "wip/winapi")
(c:define-dll-entry winapi:BOOL ShowWindow (winapi:HWND c:int) "user32")
;最大化
(defun maximize-xyzzy ()
  (interactive)
  (ShowWindow (get-window-handle) 3))
;元のサイズに戻す
(defun restore-xyzzy ()
  (interactive)
  (ShowWindow (get-window-handle) 9))

;トグル
(c:define-dll-entry winapi:BOOL IsZoomed (winapi:HWND) "user32")
(defun toggle-maximize-xyzzy ()
  (interactive)
  (if (/= 0 (IsZoomed (get-window-handle)))
      (restore-xyzzy)
    (maximize-xyzzy)))
(global-set-key #\S-C-F12 'toggle-maximize-xyzzy)
(set-function-bar-label #\S-C-F12 "toggle maximize")

(require "clickable-uri")
(global-set-key #\C-l 'clickable-uri-recenter)
(global-set-key '(#\C-c #\C-o) 'clickable-uri-open)

#|
(add-hook '*text-mode-hook*
	  #'(lambda ()
	      (if (zerop (buffer-size))
		  (set-fileio-encoding *encoding-utf8*))))
|#

(defvar *start-minibuffer-toggle-ime* nil)

(defun start-minibuffer-ime-off-1 (buf his)
  (when (get-ime-mode)
    (toggle-ime)
    (setq *start-minibuffer-toggle-ime* t)))

(defun start-minibuffer-ime-off-2 (buf his)
  (when *start-minibuffer-toggle-ime*
    (toggle-ime)
    (setq *start-minibuffer-toggle-ime* nil)))

;(add-hook '*enter-minibuffer-hook* 'start-minibuffer-ime-off-1)
;(add-hook '*exit-minibuffer-hook* 'start-minibuffer-ime-off-2)

(autoload 'colortest "colortest" t nil)


(pushnew (merge-pathnames "site-lisp/atomm/" (si:system-root))
        *load-path* :test #'string-equal)

;(setq *eshell* "/cygwin/bin/bash -i")
(setq *shell-command-option* (concat "/E:2048" *shell-command-option*))


(defvar *encoding-menu* nil)
(defun encoding-menu ()
  (or *encoding-menu*
      (let ((menu (create-popup-menu)))
        (mapc #'(lambda (x)
                  (add-menu-item menu nil (car x)
                                 #'(lambda ()
                                     (interactive)
                                     (revert-buffer (cdr x)))))
              `(("utf-8n \t(&8)" . ,*encoding-utf8n*)
                ("utf-16 \t(&6)" . ,*encoding-utf16*)
                ("sjis   \t(&S)" . ,*encoding-sjis*)
                ("auto   \t(&A)" . ,*encoding-auto*)
                ("euc-jp \t(&E)" . ,*encoding-euc-jp*)
                ("jis    \t(&J)" . ,*encoding-jis*)))
        (add-menu-item menu :select "詳細指定\t(&_)"
                       #'(lambda (encoding)
                           (interactive "zEncoding: ")
                           (revert-buffer encoding)))
        (setq *encoding-menu* menu))))
(defun revert-buffer-encoding-popup2 ()
  (interactive)
  (track-popup-menu (encoding-menu)))

(defun encoding-menu-in-file-autoload ()
  (let ((filemenu (get-menu *app-menu* 'ed::file)))
    (insert-popup-menu filemenu
                       (1- (get-menu-position (get-menu *app-menu* 'ed::file) :above-session))
                       (encoding-menu) "Reopen with Encoding (&G)\tC-c e")))
(add-hook '*init-app-menus-hook* 'encoding-menu-in-file-autoload)
;(global-set-key '(#\C-c #\e) 'revert-buffer-encoding-popup2)


(dolist (c '(#\C-0 #\C-1 #\C-2 #\C-3 #\C-4 #\C-5 #\C-6 #\C-7 #\C-8 #\C-9))
  (global-set-key c 'digit-argument))

(global-set-key #\C-+ "\\")


(require "multiple-replace")

(require "virtual-file/virtual-file")
(virtual-file-bindings)

;; emacs-write-fileが好みな方用
;(setf *virtual-file-write-default* 'emacs-write-file)

;; xyzzy wikiのtips/find-file時にディレクトリが作れるように
;; をwrite-fileでも使う
;(add-hook '*virtual-file-before-write-hook*
;          'make-directory-unless-directory-exists)


;; hatena-diary-mode

;(setf hd:*hatena-id* "Nos")

(require "shell3")

(turn-on-paren)

;;money
(defvar *money-logfile* "c:/docs/howm/etc/money.txt")

(defun money-balance ()
  (interactive)
  (save-excursion
    (let ((sum 0)
	  (regexp-money (compile-regexp "^\\[[12][0-9][0-9][0-9]-[0-1][0-9]-[0-3][0-9]\\] \\([+-]?[0-9]+\\) ")))
      (find-file *money-logfile*)
      (beginning-of-buffer)
      (scan-buffer regexp-money :tail t)
      (while (match-string 1)
	(setq sum (+ sum (parse-integer (match-string 1))))
	(scan-buffer regexp-money :tail t))
      (message "~A yen available." sum))))

(defun money-deposit (amount note)
  (interactive "nHow much? : \nsfor what? : ")
  (save-excursion
    (find-file *money-logfile*)
    (end-of-buffer)
    (unless (bolp) (newline))
    (insert (concat (format-date-string "[%Y-%m-%d]") (format nil " ~D " amount) note))
    (newline)))

(defun money-spend (amount note)
  (interactive "nHow much? : \nsfor what? : ")
  (money-deposit (- amount) note))

(defvar money-map (make-keymap))
(setf (symbol-function 'money-prefix) money-map)

(define-key ctl-x-map #\m 'money-prefix)
(define-key money-map #\a 'money-balance)
(define-key money-map #\b 'money-balance)
(define-key money-map #\d 'money-deposit)
(define-key money-map #\s 'money-spend)

(defvar *money-toread-logfile* "c:/docs/howm/etc/toread.txt" "urlメモ用のファイル")

(defun money-toread-push (url note)
  "読もうとしているwebページの管理用。
*money-toread-logfile*(ファイルパスの文字列)に格納。"
  (interactive "swhere? : \nsfor what's this? : ")
  (save-excursion
    (let ((days-to-sink 7))
      (find-file *money-toread-logfile*)
      (end-of-buffer)
      (unless (bolp) (newline))
      (insert (concat (format-date-string "[%Y-%m-%d]") (format nil "-~D " days-to-sink) note " " url))
      (newline))))
(define-key money-map #\p 'money-toread-push)

(defun decode-time (a)
  "hh:mm:ss -> s"
  (when (string-match "\\([0-9]+\\):\\([0-9][0-9]+\\):\\([0-9][0-9]\\)" a)
    (let ((h (match-string 1))
	  (m (match-string 2))
	  (s (match-string 3)))
      (+ (* (parse-integer h) 3600) (* (parse-integer m) 60) (parse-integer s)))))
(defun encode-time (s)
  "s -> hh:mm:ss"
  (format nil "~2,'0D:~2,'0D:~2,'0D" (div s 3600) (mod (div s 60) 60) (mod s 60)))
(defun div (a b)
  (floor (/ a b)))
(defun add-time (&rest l)
  "input ex) 12:34:56"
  (encode-time (apply #'+ (mapcar #'decode-time l))))
(defun add-time-buffer ()
  (interactive)
  (save-excursion
    (let ((sum 0)
	  (regexp-time (compile-regexp "\\([0-9]+:[0-9][0-9]:[0-9][0-9]\\)")))
      (beginning-of-buffer)
      (scan-buffer regexp-time :tail t)
      (while (match-string 1)
	(setq sum (+ sum (decode-time (match-string 1))))
	(scan-buffer regexp-time :tail t))
      (message "~A" (encode-time sum)))))

(defvar *money-todo-logfile* "c:/docs/howm/etc/todo.txt")
(defun money-todo-throw (todo)
  "todoファイルに登録"
  (interactive "swhat? : ")
  (save-excursion
    (let ((days-to-sink 7))
      (find-file *money-todo-logfile*)
      (unless (eql (get-buffer-file-name (selected-buffer)) *money-todo-logfile*)
	(end-of-buffer))
      (unless (bolp) (newline))
      (insert (concat (format-date-string "{ }")  " " todo))
      (newline))))
#|
(defun money-todo-view ()
  (interactive)
  (pop-to-buffer (ed::find-file-internal *money-todo-logfile*))
  (widen)
  (text-mode)			; なんかelisp-lib::howm-after-saveが*after-save-buffer-hook*に(howm-mode t)のたびに登録されて重くなるので一旦まっさらに
  (howm-mode t)
  (line-shift-mode t)
  (money-todo-mode t)
  (goto-char (point-min))
  (scan-buffer "{ }")
;  (when (match-beginning 0) (goto-char (match-beginning 0)))
  (scan-buffer "^\\[[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]\\]" :regexp t :reverse t)
  (when (match-beginning 0)
    (narrow-to-region (match-beginning 0) (point-max))
    (recenter 1)
    (next-line)))
|#
(defun money-todo-view ()
  (interactive)
  (select-pseudo-frame (or (find-pseudo-frame "*todo*")
			   (new-pseudo-frame "*todo*")))
  (pop-to-buffer (ed::find-file-internal *money-todo-logfile*))
  (widen)
  (text-mode)			; なんかelisp-lib::howm-after-saveが*after-save-buffer-hook*に(howm-mode t)のたびに登録されて重くなるので一旦まっさらに
  (howm-mode t)
  (line-shift-mode t)
  (money-todo-mode t)
  (goto-char (point-min))
  (scan-buffer "{ }")
;  (when (match-beginning 0) (goto-char (match-beginning 0)))
  (scan-buffer "^\\[[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]\\]" :regexp t :reverse t)
  (when (match-beginning 0)
    (narrow-to-region (match-beginning 0) (point-max))
    (recenter 1)
    (next-line)))

(defun money-todo-latest-date ()
  "現在のバッファ中の[yyyy-mm-dd]形式の日付のうち末尾にあるものをuniversal-timeとして取得。なければnil。"
  (save-excursion
    (save-restriction
      (widen)
      (end-of-buffer)
      (scan-buffer "^\\[\\([0-9][0-9][0-9][0-9]\\)-\\([0-9][0-9]\\)-\\([0-9][0-9]\\)\\]" :regexp t :reverse t)
      (if (match-beginning 0)
	  (let
	      ((y (parse-integer (match-string 1)))
	       (m (parse-integer (match-string 2)))
	       (d (parse-integer (match-string 3))))
	    (encode-universal-time 0 0 0 d m y))
	nil))))


(defun money-todo-insert-dates (n)
  (interactive "nhow many days: ")
  (save-excursion
    (save-restriction
      (widen)
      (let ((time (money-todo-latest-date)))
	(when (> (- (get-universal-time) time) (* 60 60 24)) (setq time (- (get-universal-time) (* 60 60 24))))
	(end-of-buffer)
	(dotimes (i n)
	  (insert (format-date-string "[%Y-%m-%d] %a\n" (+ time (* 60 60 24 (1+ i))))))
	))))

(defun money-todo-next-line-add-newdates (&optional (n 1))
  "下に移動、バッファの末尾では日付を継ぎ足す"
  (interactive "p")
  (when (eobp) (money-todo-insert-dates n))
  (next-line n))

(defun money-todo-previous-line-delete-newdates (&optional (n 1))
  "上に移動、そこから下に日付しかなければそれらを削除。money-todo-next-line-add-newdatesの逆"
  (interactive "p")
  (let ((bol (bolp)))
    (previous-line n)
    (save-excursion
      (save-restriction
	(goto-bol)
	(narrow-to-region (point) (point-max))
	(end-of-buffer)
	(scan-buffer "{" :reverse t)
	(if (match-beginning 0)
	    (progn
	      (goto-char (match-beginning 0))
	      (next-line))
	  (progn
	    (goto-char (point-min))
	    (unless bol (next-line))))
	  (delete-region (point) (point-max))))))

(defvar-local *money-todo-mode* nil)
(defvar *money-todo-mode-map* nil)
(unless *money-todo-mode-map*
  (setq *money-todo-mode-map* (make-sparse-keymap))
  (define-key *money-todo-mode-map* #\C-n 'money-todo-next-line-add-newdates)
  (define-key *money-todo-mode-map* #\Down 'money-todo-next-line-add-newdates)
  (define-key *money-todo-mode-map* #\C-p 'money-todo-previous-line-delete-newdates)
  (define-key *money-todo-mode-map* #\Up  'money-todo-previous-line-delete-newdates)
  (define-key *money-todo-mode-map* #\{   'money-todo-throw)
  (define-key *money-todo-mode-map* #\j 'money-todo-next-line-add-newdates)
  (define-key *money-todo-mode-map* #\k 'money-todo-previous-line-delete-newdates)
  )

(defun money-todo-mode (&optional (arg nil sv))
  (interactive "p")
  (ed::toggle-mode '*money-todo-mode* arg sv)
  (update-mode-line t)
  (if *money-todo-mode*
      (set-minor-mode-map *money-todo-mode-map*)
    (unset-minor-mode-map *money-todo-mode-map*))
  t)

(pushnew
 '(*money-todo-mode* . "MTodo") *minor-mode-alist* :key #'car)


(define-key money-map #\t 'money-todo-throw)
(define-key money-map #\v 'money-todo-view)


(defun list-num (n)
  "1からnまでの数を改行付きでバッファに出力"
  (interactive "Ninteger : ")
  (let ((d (floor (1+ (log n 10)))))
  (dotimes (i n)
    (with-output-to-selected-buffer (format t (concat "~" (format nil "~D" d) ",' D ~%") (1+ i))))))

(global-set-key #\C-? #'redo)

;;calc拡張
(add-hook 'ed::*calc-mode-hook*
	  #'(lambda()
	      (require "calc-ext")))

(substitute-key-definition 'next-line 'next-virtual-line)
(substitute-key-definition 'previous-line 'previous-virtual-line)


;; フレーム移動
;; 前のフレーム
(set-extended-key-translate-table exkey-S-C-tab #\S-C-F24)
(global-set-key #\S-C-F24 'previous-pseudo-frame)

;; 次のフレーム
(set-extended-key-translate-table exkey-C-tab #\C-F24)
(global-set-key #\C-F24 'next-pseudo-frame)


(require 'line-shift)


(defun nspace (n)
  (if (<= n 0) "" (concat " " (nspace (1- n)))))

(defun input-vertically ()
  (interactive)
  (let ((width      4)
	(done-lines 0)
	(start-column (current-column))
	(start-line (current-line-number)))
    (loop
      (let ((str (concat (read-string "?: "))))
	(if (<= (count-column str) width)
	    (insert (concat str (nspace (- width (count-column str)))))
	  (let ((expansion (- (count-column str) width))) ; widthより広かったらそれまでの行を全部広げてwidthを更新
	    (insert str)
	    (dotimes (i done-lines)
	      (previous-line)
	      (goto-column (+ start-column width))
	      (insert (nspace expansion)))
	    (goto-line (+ start-line done-lines))
	    (incf width expansion)
	    (goto-column width)))
	
	(incf done-lines)
	(if (= (buffer-lines) (current-line-number))
	    (progn
	      (end-of-line)
	      (newline))
	  (progn
	    (next-line)
	    (goto-column start-column))))
      (insert (nspace (- start-column (current-column)))))))

(defun input-vertically-with-comma-separation ()
  (interactive)
  (let ((width      5)
	(done-lines 0)
	(start-column (current-column))
	(start-line (current-line-number)))
    (loop
      (let ((str (concat (read-string "?: "))))
	(if (<= (+ (count-column str) 1) width)
	    (insert (concat str (nspace (- width (count-column str) 1)) ","))
	  (let ((expansion (- (+ (count-column str) 1) width))) ; widthより広かったらそれまでの行を全部広げてwidthを更新
	    (insert (concat str ","))
	    (dotimes (i done-lines)
	      (previous-line)
	      (goto-column (+ start-column width -1))
	      (insert (nspace expansion)))
	    (goto-line (+ start-line done-lines))
	    (incf width expansion)
	    (goto-column width)))
	
	(incf done-lines)
	(if (= (buffer-lines) (current-line-number))
	    (progn
	      (end-of-line)
	      (newline))
	  (progn
	    (next-line)
	    (goto-column start-column))))
	  (insert (nspace (- start-column (current-column)))))))

(require 'calc)
(defun calc ()
  (interactive)
  (select-pseudo-frame (or (find-pseudo-frame "*calc*")
			   (new-pseudo-frame "*calc*")))
  (switch-to-buffer "*calc*")
  (calc-mode))

(toggle-line-number t)
(toggle-ruler t)