init.el

;; load path
(defun add-to-load-path (&rest paths)
  (let (path)
    (dolist (path paths paths)
      (let ((default-directory
              (expand-file-name (concat user-emacs-directory path))))
        (add-to-list 'load-path default-directory)
        (if (fboundp 'normal-top-level-add-subdirs-to-load-path)
            (normal-top-level-add-subdirs-to-load-path))))))

(add-to-load-path "lisp")

(setenv "LANG" "ja_JP.SJIS")

(setq Info-default-directory-list
      (cons (expand-file-name (concat user-emacs-directory "info"))
	    Info-default-directory-list))

(require 'package)
(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/") t)
(add-to-list
 'package-archives '("melpa-stable" . "http://stable.melpa.org/pacages/") t)
(add-to-list
 'package-archives '("marmalade" . "http://marmalade-repo.org/packages/") t)
(add-to-list 'package-archives '("org" . "http://orgmode.org/elpa/") t)
(package-initialize)

(require 'server)
(unless (server-running-p)
  (server-start))

(setq c-basic-offset 4)

(add-hook 'c-mode-hook
	  '(lambda()
	     (setq tab-width 8)))

(setq c-default-style
      '((java-mode . "java")
	(c-mode    . "bsd")
	(c++-mode  . "bsd")
	(other     . "gnu")))
(add-to-list 'auto-mode-alist '("\\.h$" . c++-mode))
(add-hook 'c++-mode-hook
	  '(lambda ()
	     (setq tab-width 8)
	     (setq c-basic-offset 4)
	     (gtags-mode 1)))

(set-language-environment "Japanese")
(require 'ucs-normalize)
(setq file-name-coding-system 'cp932)
(setq default-buffer-file-coding-system 'cp932-dos)
(set-buffer-file-coding-system 'cp932-dos)
(set-terminal-coding-system 'cp932-dos)
(set-keyboard-coding-system 'cp932-dos)
(set-clipboard-coding-system 'cp932-dos)
(prefer-coding-system 'cp932-dos)
;; (set-language-environment 'cp932) ;;
(set-default-coding-systems 'cp932-dos)
(setq locale-coding-system 'cp932)
(setq dired-default-file-coding-system 'cp932-dos)

(setq fixed-width-use-QuickDraw-for-ascii t)
(setq mac-allow-anti-aliasing t)
(setq-default line-spacing 1)

;; (require 'skk-autoloads)
(global-set-key "\C-\\" 'skk-mode)
(setq skk-large-jisyo (concat user-emacs-directory "etc/SKK-JISYO.L"))

(require 'ffap)

;;; ruby
(autoload 'ruby-mode "ruby-mode" "Ruby editing mode" t)

(autoload 'run-ruby "inf-ruby" "Run an inferior Ruby process" t)
(autoload 'inf-ruby-keys "inf-ruby"
  "Set local key defs for inf-ruby in ruby-mode")
(add-hook 'ruby-mode-hook
          '(lambda () (inf-ruby-keys)))

(autoload 'ruby-elect-end "kazu-ruby-electric" nil t)
(add-hook 'ruby-mode-hook
	  '(lambda ()
	     (define-key ruby-mode-map "d" 'ruby-elect-end)
	     (define-key ruby-mode-map "\C-c\C-c" 'comment-region)))

(let ((mode '(("ruby" . ruby-mode))))
  (while mode
    (setq interpreter-mode-alist (cons (car mode) interpreter-mode-alist))
    (setq mode (cdr mode))))

(let ((mode '(("\\.rb$"  . ruby-mode)
	      ("\\.cgi$" . ruby-mode)
	      ("Rakefile$" . ruby-mode))))
  (while mode
    (add-to-list 'auto-mode-alist (car mode))
    (setq mode (cdr mode))))

(setenv "RUBYLIB" (expand-file-name "~/ruby/lib"))

(setq ruby-deep-indent-paren-style 'space)

(require 'refe)
(require 'rbenv)

(defun ruby-coding-from-buffer-file-coding-system ()
  (let ((coding-system (symbol-name buffer-file-coding-system)))
    (cond
     ((string-match "japanese-iso-8bit\\|euc-j" coding-system) "euc-jp")
     ((string-match "shift.jis\\|sjis\\|cp932"  coding-system) "cp932")
     ((string-match "utf-8" coding-system) "utf-8"))))

(defun ruby-normalize-major-mode ()
  (goto-char (point-at-bol))
  (or (re-search-forward ":" (point-at-eol) t)
      (if (re-search-forward "^#\\s *-\\*-\\s *\\(\\S +\\)\\s *-\\*-\\s *$"
			     (point-at-eol) t)
	  (replace-match
	   (format "# -*- mode: %s; -*-"
		   (buffer-substring (match-beginning 1) (match-end 1)))))))

(defun ruby-remove-coding ()
  (goto-char (point-at-bol))
  (if (re-search-forward
       "coding\\s *:\\s *[^ 	;]+\\s *;?\\s *" (point-at-eol) t)
      (delete-region (match-beginning 0) (match-end 0))))

(defun ruby-insert-coding ()
  (goto-char (point-at-bol))
  (if (re-search-forward "^#\\s *-\\*-\\s *" (point-at-eol) t)
      (replace-match (format "# -*- coding: %s; " ruby-coding-system))))

(defun ruby-modify-magic-comment ()
  (ruby-normalize-major-mode)
  (ruby-remove-coding)
  (ruby-insert-coding))

(defun ruby-set-coding-system-in-magic-comment ()
  (save-excursion
    (goto-char 1)
    (when (looking-at "^#!")
      (forward-line 1))
    (if (re-search-forward "^#.*-\\*-" (point-at-eol) t)
	(ruby-modify-magic-comment)
      (insert (format "# -*- coding: %s; -*-\n" ruby-coding-system)))))

(defun ruby-set-coding-system-in-magic-comment-if-needed ()
  (interactive)
  (let ((ruby-coding-system (ruby-coding-from-buffer-file-coding-system)))
    (and ruby-coding-system
	 (eq major-mode 'ruby-mode)
	 (find-multibyte-characters (point-min) (point-max) 1)
	 (ruby-set-coding-system-in-magic-comment))))

(add-hook 'ruby-mode-hook
	  '(lambda ()
	     (define-key ruby-mode-map "\C-x\C-me"
	       'ruby-set-coding-system-in-magic-comment-if-needed)))

(defun make-ruby-scratch-buffer ()
  (with-current-buffer (get-buffer-create "*ruby scratch*")
    (ruby-mode)
    (current-buffer)))
(defun ruby-scratch ()
  (interactive)
  (pop-to-buffer (make-ruby-scratch-buffer)))

(require 'rcodetools)

(setq rct-find-tag-if-available nil)

(defun ruby-mode-hook-rcodetools ()
  (define-key ruby-mode-map "\M-\C-i" 'rct-complete-symbol)
  (define-key ruby-mode-map "\C-c\C-t" 'ruby-toggle-buffer)
  (define-key ruby-mode-map "\C-c\C-d" 'xmp)
  (define-key ruby-mode-map "\C-c\C-f" 'rct-ri))
(add-hook 'ruby-mode-hook 'ruby-mode-hook-rcodetools)

;;; migemo
(when (and (executable-find "cmigemo")
	   (require 'migemo nil t))
  (setq migemo-command "cmigemo")
  (setq migemo-options '("-q" "--emacs" "-i" "\a"))
  ;; ;; (setq migemo-dictionary "/usr/local/share/migemo/utf-8/migemo-dict")
  (setq migemo-dictionary "/usr/local/share/migemo/euc-jp/migemo-dict")
  ;; ;; (setq migemo-dictionary "/usr/local/share/migemo/cp932/migemo-dict")
  ;; ;; (setq migemo-dictionary "C:/Cygwin/usr/local/share/migemo/utf-8/migemo-dict")
  ;; ;; (setq migemo-dictionary "C:/Cygwin/usr/local/share/migemo/euc-jp/migemo-dict")
  ;; ;; (setq migemo-dictionary "C:/Cygwin/usr/local/share/migemo/cp932/migemo-dict")
  ;; ;; (setq migemo-dictionary
  ;; ;; 	"C:/Program Files/cmigemo-default-win64/dict/utf-8/migemo-dict")
  ;; (setq migemo-user-dictionary nil)
  ;; (setq migemo-regex-dictionary nil)
  ;; (setq migemo-use-pattern-alist t)
  ;; (setq migemo-use-frequent-patten-alist t)
  ;; (setq migemo-pattern-alist-length 1000)
  ;; ;; (setq migemo-coding-system 'utf-8-unix)
  ;; ;; (setq migemo-coding-system 'utf-8-dos)
  ;; (setq migemo-coding-system 'euc-jp-unix)
  ;; ;; (setq migemo-coding-system 'euc-jp-dos)
  ;; ;; (setq migemo-coding-system 'cp932)
  (migemo-init))

;;; shell
(setq shell-prompt-pattern "[a-z]*$ ")
(setq sh-basic-offset 2)

(setq explicit-shell-file-name "bash.exe")
(setq shell-file-name "bash.exe")
;; (setq shell-command-switch "-c")
(add-hook 'shell-mode-hook
	  (lambda ()
	    (set-buffer-process-coding-system 'undecided-dos 'cp932-unix)))


(let* ((font-size 9)
       (default-font "Consolas")
       (en (font-spec :family default-font))
       (ja (font-spec :family "メイリオ")))
  (set-face-attribute 'default nil
                      :family default-font :height (* font-size 10))
  (set-fontset-font nil 'katakana-jisx0201 ja)
  (set-fontset-font nil 'japanese-jisx0208 ja)
  (set-fontset-font nil '(#x0080 . #x024F) en)
  (set-fontset-font nil '(#x0370 . #x03FF) en))

(setq face-font-rescale-alist
      '((".*Meiryo UI.*" . 1.2)
        (".*メイリオ.*" . 1.2)
        ("-cdac$" . 1.3)))

(tool-bar-mode -1)
(menu-bar-mode -1)
(set-scroll-bar-mode nil)
(setq cursor-type 'box)
(setq cursor-in-non-selected-windows 'hollow)
(blink-cursor-mode t)
(setq transient-mark-mode nil)
(set-background-color "LemonChiffon")

;; ;; for note pc
;; (setq default-frame-alist
;;       '((top . 8) (left . 672) (width . 80) (height . 44)))
;; for wide display
(setq default-frame-alist
      '((top . 16) (left . 920) (width . 80) (height . 64)))

(setq completion-ignore-case t)
(setq read-buffer-completion-ignore-case t)

(require 'uniquify)
(setq uniquify-buffer-name-style 'post-forward-angle-brackets)


(defun memo()
  (interactive)
  (add-change-log-entry
   nil
   (expand-file-name "~/.log")))
(define-key ctl-x-map "m" 'memo)

(defun insert-date()
  (interactive)
  (insert (substring (current-time-string) 11 19)))
(global-set-key "\C-xt" 'insert-date)


(autoload 'kill-summary "kill-summary" nil t)
(global-set-key "\M-\C-y" 'kill-summary)

(require 'session)
(add-hook 'after-init-hook 'session-initialize)

(require 'lispxmp)
(defun emacs-lisp-mode-hook-xmp ()
  (define-key emacs-lisp-mode-map "\C-c\C-d" 'lispxmp))
(add-hook 'emacs-lisp-mode-hook 'emacs-lisp-mode-hook-xmp)

(defun open-junk-file ()
  (interactive)
  (let* ((file (expand-file-name
                (format-time-string
                 "%Y/%m/%Y-%m-%d-%H%M%S." (current-time))
                "~/memo/"))
         (dir (file-name-directory file)))
    (make-directory dir t)
    (find-file-other-window (read-string "Junk Code: " file))))
(global-set-key "\C-x\C-n" 'open-junk-file)

(setq ispell-program-name "aspell")

;;; look word
(global-set-key "\C-x," 'look-word)

(defvar word-file "/usr/share/dict/words")

(if (not (fboundp 'when))
    (defmacro when (pred &rest exec)
      "(when C T...) if conditoin C holds, eval T... with implicit progn."
      (list 'if pred (cons 'progn exec))))

(defun look-word ()
  "look the word before point, and displays on a pop-up buffer."
  (interactive)
  (let (beg end)
    (save-excursion
      (setq end (point))
      (forward-word -1)
      (setq beg (point)))
    (when (= beg end)
      (signal 'error '("null string")))
    (let ((word (buffer-substring beg end))
	  (old (current-buffer))
	  (look (get-buffer-create " *look*"))
	  (dict (get-buffer-create " *look-dict*"))
	  (list-start (point-min))
	  (list-end (point-min))
	  (finds nil))
      ;; 
      (setq word (read-string "Look at: " word))
      ;;
      (message "Looking at %s..." word)
      ;;
      (save-window-excursion
	;;
	(set-buffer dict)
	(when (= (buffer-size) 0)
	  (insert-file-contents word-file 'visit)
	  (setq buffer-read-only t))
	;;
	(goto-char (point-min))
	(when (re-search-forward (format "^%s" word) nil t)
	  (beginning-of-line)
	  (setq list-start (point)
		list-end (point))
	  (while (re-search-forward (format "^%s" word) nil t)
	    (end-of-line)
	    (setq list-end (point))))
	(setq finds (buffer-substring list-start list-end))
	;;
	(pop-to-buffer look)
	(widen)
	(erase-buffer)
	(insert-string finds)
	;;
	(goto-char (point-min))
	(end-of-line)
	(while (< (point) (point-max))
	  (delete-char 1)
	  (if (> (current-column) 65)	; over 8th tab stop
	      (newline)
	    (indent-to(* (/ (+ 15 (current-column))
			    16)16)))
	  (end-of-line))
	(goto-char (point-min))
	;;
	(message "Looking at %s...done" word)
	(pop-to-buffer old)	; return cursor to current buffer
	;; show look buffer until key in
	(sit-for 30)))))

;;; Mew
(autoload 'xcite-yank-cur-msg "xcite" nil t)
(autoload 'mew "mew" nil t)
(autoload 'mew-send "mew" nil t)
(setq mew-summary-form '(type (5 date) " " (20 from) " " t (0 subj)))
(setq mew-case "")

(require 'xcite)
(autoload 'xcite-yank-cur-msg "xcite" "Exciting cite" t)

;;; fake Outlook
(defun xcite-pickup-name (handle)
  (replace-regexp-in-string "(.*)" "" handle))

(defun xcite-convert-date-rfc2822-to-outlook (src)
  (let* ((sep "[ \t,:]+")
	 (date (split-string src sep))
	 (weeks '(("Mon" . "Monday")
		  ("Tue" . "Tuesday")
		  ("Wed" . "Wednesday")
		  ("Thu" . "Thursday")
		  ("Fri" . "Friday")
		  ("Sat" . "Saturday")
		  ("Sun" . "Sunday")))
	 (wday (cdr (assoc (car date) weeks)))
	 (mday (string-to-int (cadr date)))
	 (months '(("Jan" . "January")   ("Feb" . "February")
		   ("Mar" . "March")     ("Apr" . "April")
		   ("May" . "May")       ("Jun" . "June")
		   ("Jul" . "July")      ("Aug" . "August")
		   ("Sep" . "September") ("Oct" . "October")
		   ("Nov" . "November")  ("Dec" . "December")))
	 (mon (cdr (assoc (caddr date) months)))
	 (year (string-to-int (nth 3 date)))
	 (hour (string-to-int (nth 4 date)))
	 (min (string-to-int (nth 5 date)))
	 (ampm (if (< hour 12) "AM" "PM")))
    (format "%s, %s %02d, %d %d:%d %s"
	    wday mon mday year
	    (if (< hour 13) hour (- hour 12))
	    min ampm)))

(defun xcite-default-header ()
  (format "-----Original Message-----\nFrom: %s [mailto:%s]\nSent: %s\nTo: %s\nSubject: %s\n"
	  (xcite-pickup-name handle) id
	  (xcite-convert-date-rfc2822-to-outlook date)
	  (cdr (assoc "name" (assoc "" mew-config-alist))) subject))

(setq xcite:citation-suffix "")
;;; fake Outlook

(autoload 'add-signature "c-sig" "c-sig" t)
(autoload 'delete-signature "c-sig" "c-sig" t)
(autoload 'insert-signature-eref "c-sig" "c-sig" t)
(autoload 'insert-signature-automatically "c-sig" "c-sig" t)
(autoload 'insert-signature-randomly "c-sig" "c-sig" t)

(setq mew-safe-domains '(""))


(add-hook 'mew-message-mode-hook
	  (lambda ()
	    (setq cursor-in-non-selected-windows nil)))

(setq mew-search-method 'est)

(defun buffer-fiber-exe ()
  (interactive)
  (let ((file (buffer-file-name)))
    (cond
     ((string= major-mode 'dired-mode)
      (if (string-match "^\\([a-z]:\\)/$" default-directory)
          (start-process "explorer" "diredfiber" "explorer.exe"
                         (match-string 1  default-directory))
        (start-process "explorer" "diredfiber" "explorer.exe"
                       (unix-to-dos-filename
                        (directory-file-name
                         default-directory)))))
;     ((and mmemo-buffer-file-name
;           (file-exists-p mmemo-buffer-file-name))
;      (start-process "fiber" "diredfiber" "fiber.exe"
;                     mmemo-buffer-file-name))
     ((not file)
      (message
       "現在のバッファはファイルではありません"))
     ((file-directory-p file)
      (start-process
       "explorer" "diredfiber" "explorer.exe"
       (unix-to-dos-filename file)))
     ((file-exists-p file)
      (start-process
       "fiber" "diredfiber" "fiber.exe" file))
     ((not (file-exists-p file))
      (message "ファイルが存在しません")))))

;; ;;; calendar
;; ;; 日本の祝日
;; (add-hook 'calendar-load-hook
;; 	  (lambda ()
;; 	    (require 'japanese-holidays)
;; 	    (setq calendar-holidays
;; 		  (append japanese-holidays local-holidays other-holidays))))
;; (setq mark-holidays-in-calendar t)

;; "今日" をマーク
(add-hook 'today-visible-calendar-hook 'calendar-mark-today)

;; 休日を赤く
(setq calendar-weekend-marker 'diary)
(add-hook 'today-visible-calendar-hook 'calendar-mark-weekend)
(add-hook 'today-invisible-calendar-hook 'calendar-mark-weekend)


;;; lookup
(autoload 'lookup "lookup" nil t)
(autoload 'lookup-region "lookup" nil t)
(autoload 'lookup-pattern "lookup" nil t)
; 上記は (require 'lookup) で代用可。
; ただし (require) だと起動時に load される

(global-set-key "\C-cw" 'lookup-pattern)

(setq ndeb-program-name (executable-find "eblook"))

;(setq lookup-search-agents '((ndtp "localhost"))) ; 外字を指定していないから?
(setq lookup-search-agents
      '((ndeb "/cygdrive/c/epwing/YRRS_096")
      	(ndeb "/cygdrive/c/epwing/YRRS_235")
      	(ndeb "/cygdrive/c/epwing/YRRS_261")))


(put 'set-goal-column  'disabled nil)
(put 'upcase-region    'disabled nil)
(put 'downcase-region  'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'narrow-to-page   'disabled nil)

(defun tab4 ()
  (interactive)
  (setq tab-width 4))

(defun tab8 ()
  (interactive)
  (setq tab-width 8))

(defun upto (&optional beg end fmt stp)
  (interactive)
  (or beg (setq beg 0))
  (or end (setq end 10))
  (or fmt (setq fmt "%d\n"))
  (or stp (setq stp 1))
  (while (<= beg end)
    (insert (format fmt beg))
    (setq beg (1+ beg))))

(defun fold(re)
  "fold after string"
  (interactive "sfold after string: ")
  (save-excursion
    (while (re-search-forward (concat re "\\([^\n]\\)") nil t)
      (backward-char 1)
      (insert "\n"))))

(defun tall-window ()
  (interactive)
  (set-frame-height nil 48))

(defun half-window ()
  (interactive)
  (set-frame-height nil 24))