root/dotfiles/emacs/mrkn/.emacs @ 29345

;;; $Id$
(if (featurep 'meadow) (cd (expand-file-name "~")))

;;; Load path
(setq load-path
      (append (list (expand-file-name "~/elisp/")
                    )
              load-path))

;;; personal information
(setq user-full-name "Kenta Murata")
(setq user-mail-address "mrkn@mrkn.jp")

;;; Language evnrionment
(if (featurep 'mule)
    (progn
      (if (featurep 'meadow)
          (require 'un-define))
      (set-language-environment "Japanese")
      (cond
       ;; CarbonEmacs
       ((featurep 'mac-carbon)
        (set-default-coding-systems 'utf-8-unix)
        (set-buffer-file-coding-system 'utf-8-unix)
        (set-clipboard-coding-system 'sjis-mac)
        (utf-translate-cjk-mode 1)
        (set-file-name-coding-system 'utf-8m)
        (if window-system
            (set-keyboard-coding-system 'sjis-mac)
          (progn
            (set-keyboard-coding-system 'utf-8)
            (set-terminal-coding-system 'utf-8)))
        )
       ;; Etc.
       (t
        (prefer-coding-system 'utf-8-unix)
        ))
      ))

;;; Locale
(let (p)
  (setq p process-environment)
  (setq process-environment '("LANG=ja_JP.UTF_8" "LC_ALL=C"))
  (while p
    (unless (or (string-match "^LANG=" (car p))
                (string-match "^LC_.+=" (car p)))
      (setq process-environment (cons (car p) process-environment)))
    (setq p (cdr p)))
  process-environment)

;; for Japanese info files
(auto-compression-mode t)

;; System info files
(setq Info-additional-directory-list
      '("/usr/share/info"
        "/opt/local/share/info"))

;; japanese grep
(if (file-exists-p "/usr/bin/lgrep")
    (setq grep-command "lgrep -n"))

;;; Input Method
(if (featurep 'mac-carbon)
    (if window-system
        (set-input-method "MacOSX"))
  (set-input-method "japanese-skk"))
(toggle-input-method nil)

;;; UIM
;;; 起動コマンド:
;;;   env GTK_IM_MODULE=xim XMODIFIERS="@im=none" emacs
;;;
;;; .Xresources:
;;;   Emacs*xnlLanguage: C
;;;   Emacs*useXIM: false
;; (if (not (or (featurep 'meadow) (featurep 'dos-w32)))
;;     (progn
;;       (require 'uim-leim)
;;       (set-input-method "japanese-skk-uim")
;;       (toggle-input-method nil)
;;       (global-set-key "\C-x\C-j" 'toggle-input-method)))

;; global font-lock mode
(require 'font-lock)
(if (not (featurep 'xemacs))
    (global-font-lock-mode t))

;;; disable tool-bar mode
(when window-system
  (tool-bar-mode nil))

;;; set scroll-bar on right
(if window-system
    (set-scroll-bar-mode 'right))

;;; enable line- and column-number-mode
(line-number-mode t)
(column-number-mode t)

;;; display time
;;(setq display-time-day-and-date t
;;      display-time-24hr-format t)
(setq display-time-interval 1
      display-time-format "%Y-%m-%d %H:%M:%S")
(display-time)

;;; enable show-paren-mode in expression style
(show-paren-mode t)
(setq show-paren-style 'expression)

;;; enable transient-mark-mode
(transient-mark-mode t)

;;; enable partial-completion-mode
(partial-completion-mode t)

;;; enable mouse-wheel-mode
(mouse-wheel-mode t)

;; backup by copying
(setq backup-by-copying t)

;;; global key bindings
(setq mac-option-modifier 'meta)
(global-set-key "\C-h" 'backward-delete-char)
(global-set-key "\M-?" 'help-for-help)
(global-set-key "\M-g" 'goto-line)
(global-set-key [f1] 'help-for-help)
(global-set-key "\C-cs" 'svn-status)
(global-set-key [M-kanji] 'ignore)

;;; universal diff
(setq diff-switches "-uN")

;;; aspell
(setq ispell-program-name "aspell")

;; TRAMP
(require 'tramp-util)
(setq tramp-default-method
      (if (featurep 'meadow) "plink" "ssh"))
(setq tramp-completion-without-shell-p t)
(add-to-list 'backup-directory-alist
             (cons tramp-file-name-regexp nil))
(if (featurep 'meadow)
    (setq tramp-encoding-shell "tcsh"
          tramp-encoding-command-switch "-c"
          tramp-ls-command "ls"
          ls-lisp-use-insert-directory-program t))

;;; fakecygpty
(if (featurep 'meadow)
    (setq mw32-process-wrapper-alist
          '(("/\\(bash\\|tcsh\\|svn\\|ssh\\|scp\\|gpg[esvk]?\\)\\.exe" .
             (nil . ("fakecygpty.exe" . set-process-connection-type-pty))))
          ))

;;; shell setting using bash
(if (featurep 'meadow)
    (progn
      (setq explicit-shell-file-name "bash.exe")
      (setq shell-file-name "c:/cygwin/bin/bash.exe")
      )
  (progn
    (setq explicit-shell-file-name "bash")
    (setq shell-file-name "/bin/bash")
    (setq shell-prompt-pattern "^[^$]*\$ *")
    (add-hook 'shell-mode-hook
              '(lambda ()
                 (setq comint-process-echoes t)))
    ))
(setq shell-command-switch "-c")
(setq explicit-bash-args '("--login"))
(autoload 'ansi-color-for-comint-mode-on "ansi-color"
  "Set `ansi-color-for-comint-mode' to t." t)
(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)

;;; Cygwin


;;; flymake
(require 'flymake)
(defun flymake-display-err-for-current-line-minibuffer ()
  "Display a errors/warnings for current line if it has errors and/or warnings."
  (interactive)
  (let* ((line-no             (flymake-current-line-no))
         (line-err-info-list  (nth 0 (flymake-find-err-info flymake-err-info line-no)))
         (count               (length line-err-info-list)))
    (while (> count 0)
      (when line-err-info-list
        (let* ((file       (flymake-ler-file (nth (1- count) line-err-info-list)))
               (full-file  (flymake-ler-full-file (nth (1- count) line-err-info-list)))
               (text (flymake-ler-text (nth (1- count) line-err-info-list)))
               (line       (flymake-ler-line (nth (1- count) line-err-info-list))))
          (message "[%s] %s" line text)
          ))
      (setq count (1- count))
      )))
(global-set-key [f3] 'flymake-display-err-for-current-line-minibuffer)
(global-set-key [f4] 'flymake-goto-next-error)
(add-hook 'find-file-hook 'flymake-find-file-hook)
(set-face-background 'flymake-errline "#303")
(set-face-background 'flymake-warnline "dark slate blue")
(defun flymake-get-make-cmdline (source base-dir)
  (list "make"
        (list "check-syntax" "-s" "-C"
              base-dir
              (concat "CHK_SOURCES=" source)
              "SYNTAX_CHECK_MODE=1")))
(push '("\\.h\\'" flymake-simple-make-init)
      flymake-allowed-file-name-masks)
(push '("\\.hpp\\'" flymake-simple-make-init)
      flymake-allowed-file-name-masks)
(push '("\\.hh\\'" flymake-simple-make-init)
      flymake-allowed-file-name-masks)

;; ESS/R
(setq auto-mode-alist
     (cons (cons "\\.r$" 'R-mode) auto-mode-alist))
(autoload 'R-mode "ess-site" "Emacs Speaks Statistics mode" t)
(setq-default inferior-R-program-name "/Library/Frameworks/R.framework/Resources/bin/R")
(setq ess-pre-run-hook
 '((lambda () (setq S-directory default-directory)
     (setq default-process-coding-system '(utf-8-unix . utf-8-unix))
  )))
(autoload 'R "ess-site" nil 'interactive)

;;; cc-mode settings
(if (file-exists-p "~/.emacs.d/ccmode.el")
    (load-file "~/.emacs.d/ccmode.el"))
(require 'ruby-style)

;;; for autoloading inf-ruby when run-ruby is refered
(autoload 'run-ruby "inf-ruby" 
  "Run an inferior Ruby process" t)
(autoload 'run-ruby-keys "inf-ruby"
  "Set local key defs for inf-ruby in ruby-mode" t)
(add-hook 'ruby-mode-hook
          '(lambda ()
             (inf-ruby-keys)))
(if (featurep 'meadow)
    (add-hook 'inferior-ruby-mode-hook
              '(lambda ()
                 (setq comint-process-echoes t))))

;;; for InstantRails
(if (featurep 'meadow)
    (defun instant-rails (&optional buffer)
      ""
      (interactive
       (list
        (and current-prefix-arg
             (read-buffer "Shell buffer: "
                          (generate-new-buffer-name "*instant-rails*")))))
      (setq buffer (get-buffer-create (or buffer "*instant-rails*")))
      ;; Pop to buffer, so that the buffer's window will be correctly set
      ;; when we call comint (so that comint sets the COLUMN env var properly).
      (pop-to-buffer buffer)
      (unless (comint-check-proc buffer)
        (let* ((startfile "c:/InstantRails/use_ruby.cmd"))
          (apply 'make-comint-in-buffer "instant-rails" buffer "cmd.exe"
                 startfile '("\Q"))
          (shell-mode)
          (setq default-directory "c:/InstantRails/rails_apps")))
      buffer))

;;; JavaScript
(autoload 'javascript-mode "javascript" nil t)
(add-to-list 'auto-mode-alist
             (cons "\\.\\(js\\|as\\|json\\|jsn\\)$"
                   'javascript-mode))
(setq js-indent-level 2)

;;; Erlang


;;; GNU Global
(if (file-exists-p "~/.emacs.d/global.el")
    (load-file "~/.emacs.d/global.el"))

;;; muse

;;; AUCTeX
(if (file-exists-p "~/.emacs.d/auctex.el")
    (load-file "~/.emacs.d/auctex.el"))

;;; git-status
(if (file-exists-p "~/.emacs.d/git.el")
    (load-file "~/.emacs.d/git.el"))

;;; eijiro
(if (featurep 'meadow)
    (load "~/.emacs.d/eijiro.el"))

;;; Font settings
(if window-system
    (load "~/.emacs.d/fonts.el"))

;;; gnuserv
(when window-system
  (if (and (not (featurep 'dos-w32)) (not (featurep 'mac-carbon)))
      (progn
       (require 'gnuserv-compat)
       (gnuserv-start)
       )))

;;; applying default fontset
(when window-system
  (let ((setter (lambda (key value alist-sym)
                  (if (symbolp alist-sym)
                      (if (assoc key (symbol-value alist-sym))
                          (setcdr (assoc key (symbol-value alist-sym)) value)
                        (set alist-sym (append (list (cons key value))
                                               (symbol-value alist-sym))))
                    (error "alist-sym must be a symbol")))))
    (cond
     ((featurep 'dos-w32)
      (progn
        (funcall setter 'font
                 (if (featurep 'meadow)
                     "MeiryoKe_Console 12"
                   "fontset-mp2vm")
                 'default-frame-alist)
        (funcall setter 'height 40 'default-frame-alist)
        (set-face-attribute 'default nil :height 120)))
     ((featurep 'carbon-emacs-package)
      ;;(add-to-list 'default-frame-alist '(font . "fontset-default"))
      ;;(funcall setter 'width 96 'default-frame-alist)
      ;;(funcall setter 'height 32 'default-frame-alist)
      ;;(funcall setter 'alpha '(90 80) 'default-frame-alist)
      (set-frame-parameter nil 'alpha 90)
      )
     (t
      (progn
        (funcall setter 'font "fontset-m+2vm+ipag circle_12"
                 'default-frame-alist)
        )))))

;;; fullscreen
(defun fullscreen ()
  (interactive)
  (set-frame-parameter nil 'fullscreen
                       (if (frame-parameter nil 'fullscreen) nil 'fullboth)))
(global-set-key [f5] 'fullscreen)

;;; color-theme
(require 'color-theme)
(color-theme-initialize)
(color-theme-dark-laptop)

;;; Local Variables:
;;; mode: emacs-lisp
;;; indent-tabs-mode: nil
;;; End:
;;; end of file