You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

2724 lines
94 KiB

  1. ;;; emacs.el --- 10sr emacs initialization
  2. ;;; Commentary:
  3. ;;; Code:
  4. ;; SETUP_LOAD: (let ((file "DOTFILES_DIR/emacs.el"))
  5. ;; SETUP_LOAD: (and (file-readable-p file)
  6. ;; SETUP_LOAD: (load-file file)))
  7. ;; make directories
  8. (unless (file-directory-p (expand-file-name user-emacs-directory))
  9. (make-directory (expand-file-name user-emacs-directory)))
  10. (let ((d (expand-file-name (concat user-emacs-directory
  11. "lisp"))))
  12. (unless (file-directory-p d)
  13. (make-directory d))
  14. (add-to-list 'load-path d))
  15. (eval-when-compile
  16. (require 'cl nil t))
  17. ;; (add-hook 'after-change-major-mode-hook
  18. ;; (lambda ()
  19. ;; (message "cmm: %S %s"
  20. ;; major-mode
  21. ;; buffer-file-name)))
  22. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  23. ;; Some macros for internals
  24. (defun call-after-init (func)
  25. "If `after-init-hook' has been run, call FUNC immediately.
  26. Otherwize hook it."
  27. (if after-init-time
  28. (funcall func)
  29. (add-hook 'after-init-hook
  30. func)))
  31. (defmacro defvar-set (symbol value &optional docstring)
  32. "Define SYMBOL as a variable and set to VALUE.
  33. Variable will be defined with DOCSTRING if given, otherwise do not set even
  34. VALUE when defining SYMBOL."
  35. `(set (if ,docstring
  36. (defvar ,symbol
  37. nil
  38. ,docstring)
  39. (defvar ,symbol))
  40. ,value))
  41. (defmacro safe-require-or-eval (feature)
  42. "Require FEATURE if available.
  43. At compile time the feature will be loaded immediately."
  44. `(eval-and-compile
  45. (require ,feature nil t)))
  46. (defmacro autoload-eval-lazily (feature &optional functions &rest body)
  47. "Define autoloading FEATURE that defines FUNCTIONS.
  48. FEATURE is a symbol. FUNCTIONS is a list of symbols. If FUNCTIONS is nil,
  49. the function same as FEATURE is defined as autoloaded function. BODY is passed
  50. to `eval-after-load'.
  51. After this macro is expanded, this returns the path to library if FEATURE
  52. found, otherwise returns nil."
  53. (let* ((libname (symbol-name (eval feature)))
  54. (libpath (locate-library libname)))
  55. (and libpath
  56. `(progn
  57. ,@(mapcar (lambda (f)
  58. (unless (fboundp f)
  59. `(progn
  60. (message "Autoloaded function `%S' defined (%s)"
  61. (quote ,f)
  62. ,libpath)
  63. (autoload (quote ,f)
  64. ,libname
  65. ,(concat "Autoloaded function defined in \""
  66. libpath
  67. "\".")
  68. t))))
  69. (or (eval functions)
  70. `(,(eval feature))))
  71. (eval-after-load ,feature
  72. (quote (progn
  73. ,@body)))
  74. (locate-library ,libname)))))
  75. (put 'autoload-eval-lazily 'lisp-indent-function 2)
  76. (when (autoload-eval-lazily 'tetris nil
  77. (message "Tetris loaded!"))
  78. (message "Tetris found!"))
  79. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  80. ;; download library from web
  81. (defvar fetch-library-enabled-p t
  82. "Set nil to skip downloading with `fetch-library'.")
  83. (defun fetch-library (url &optional byte-compile-p force-download-p)
  84. "Download a library from URL and locate it in \"~/emacs.d/lisp/\".
  85. Return nil if library unfound and failed to download,
  86. otherwise the path where the library installed.
  87. If BYTE-COMPILE-P is t byte compile the file after downloading.
  88. If FORCE-DOWNLOAD-P it t ignore exisiting library and always download.
  89. This function also checks the value of `fetch-library-enabled-p' and do not
  90. fetch libraries if this value is nil. In this case all arguments (including
  91. FORCE-DOWNLOAD-P) will be ignored."
  92. (let* ((dir (expand-file-name (concat user-emacs-directory "lisp/")))
  93. (lib (file-name-sans-extension (file-name-nondirectory url)))
  94. (lpath (concat dir lib ".el"))
  95. (locate-p (locate-library lib)))
  96. (if (and fetch-library-enabled-p
  97. (or force-download-p
  98. (not locate-p)))
  99. (if (progn (message "Downloading %s..."
  100. url)
  101. (download-file url
  102. lpath
  103. t))
  104. (progn (message "Downloading %s...done"
  105. url)
  106. (when (and byte-compile-p
  107. (require 'bytecomp nil t))
  108. (and (file-exists-p (byte-compile-dest-file lpath))
  109. (delete-file (byte-compile-dest-file lpath)))
  110. (message "Byte-compiling %s..."
  111. lpath)
  112. (byte-compile-file lpath)
  113. (message "Byte-compiling %s...done"
  114. lpath)))
  115. (progn (and (file-writable-p lpath)
  116. (delete-file lpath))
  117. (message "Downloading %s...failed"
  118. url))))
  119. (locate-library lib)))
  120. ;; If EMACS_EL_DRY_RUN is set and it is not an empty string, fetch-library
  121. ;; does not actually fetch library.
  122. (let ((dryrun (getenv "EMACS_EL_DRY_RUN")))
  123. (when (and dryrun
  124. (< 0
  125. (length dryrun)))
  126. (setq fetch-library-enabled-p
  127. nil)
  128. (message "EMACS_EL_DRY_RUN is set. Skip fetching libraries.")))
  129. (defun download-file (url path &optional ok-if-already-exists)
  130. "Download file from URL and output to PATH.
  131. IF OK-IF-ALREADY-EXISTS is true force download."
  132. (let ((curl (executable-find "curl"))
  133. (wget (executable-find "wget")))
  134. (cond (wget
  135. (if (and (not ok-if-already-exists)
  136. (file-exists-p path))
  137. nil
  138. (and (eq 0
  139. (call-process wget
  140. nil
  141. nil
  142. nil
  143. "-O"
  144. path
  145. url
  146. ))
  147. path)))
  148. (curl
  149. (if (and (not ok-if-already-exists)
  150. (file-exists-p path))
  151. nil
  152. (and (eq 0
  153. (call-process curl
  154. nil
  155. nil
  156. nil
  157. "--output"
  158. path
  159. "-L"
  160. url
  161. ))
  162. path)))
  163. (t
  164. (ignore-errors
  165. (require 'url)
  166. (url-copy-file url
  167. path
  168. ok-if-already-exists)
  169. path)))))
  170. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  171. ;; package
  172. (defvar-set my-package-list
  173. '(
  174. markdown-mode
  175. yaml-mode
  176. gnuplot-mode
  177. erlang
  178. js2-mode
  179. git-commit-mode
  180. gitignore-mode
  181. ;; ack
  182. color-moccur
  183. gtags
  184. flycheck
  185. ;; is flymake installs are required?
  186. ;;flymake-jshint
  187. ;;flymake-python-pyflakes
  188. xclip
  189. foreign-regexp
  190. multi-term
  191. dirtree
  192. term-run
  193. editorconfig
  194. git-ps1-mode
  195. scala-mode2
  196. ensime
  197. )
  198. "Package list just for me.")
  199. (when (safe-require-or-eval 'package)
  200. ;; (add-to-list 'package-archives
  201. ;; '("ELPA" . "http://tromey.com/elpa/"))
  202. (add-to-list 'package-archives
  203. '("melpa" . "http://melpa.milkbox.net/packages/")
  204. t)
  205. (add-to-list 'package-archives
  206. '("marmalade" . "http://marmalade-repo.org/packages/"))
  207. (package-initialize)
  208. (defun my-auto-install-package ()
  209. "Install packages semi-automatically."
  210. (interactive)
  211. (package-refresh-contents)
  212. (mapc (lambda (pkg)
  213. (or (package-installed-p pkg)
  214. (locate-library (symbol-name pkg))
  215. (package-install pkg)))
  216. my-package-list))
  217. )
  218. ;; (lazy-load-eval 'sudoku)
  219. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  220. ;; my-idle-hook
  221. (defvar my-idle-hook nil
  222. "Hook run when idle for several secs.")
  223. (defvar my-idle-hook-sec 5
  224. "Second to run `my-idle-hook'.")
  225. (run-with-idle-timer my-idle-hook-sec
  226. t
  227. (lambda ()
  228. (run-hooks 'my-idle-hook)))
  229. ;; (add-hook 'my-idle-hook
  230. ;; (lambda ()
  231. ;; (message "idle hook message")))
  232. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  233. ;; start and quit
  234. (setq inhibit-startup-message t)
  235. (setq confirm-kill-emacs 'y-or-n-p)
  236. (setq gc-cons-threshold (* 1024 1024 4))
  237. (when window-system
  238. (add-to-list 'default-frame-alist '(cursor-type . box))
  239. (add-to-list 'default-frame-alist '(background-color . "white"))
  240. (add-to-list 'default-frame-alist '(foreground-color . "gray10"))
  241. ;; (add-to-list 'default-frame-alist '(alpha . (80 100 100 100)))
  242. ;; does not work?
  243. )
  244. ;; (add-to-list 'default-frame-alist '(cursor-type . box))
  245. (if window-system (menu-bar-mode 1) (menu-bar-mode 0))
  246. (and (fboundp 'tool-bar-mode)
  247. (tool-bar-mode 0))
  248. (and (fboundp 'set-scroll-bar-mode)
  249. (set-scroll-bar-mode nil))
  250. (add-hook 'kill-emacs-hook
  251. ;; load init file when terminating emacs to ensure file is not broken
  252. 'reload-init-file)
  253. (defun my-force-kill-emacs ()
  254. "My force kill Emacs."
  255. (interactive)
  256. (let ((kill-emacs-hook nil))
  257. (kill-emacs)))
  258. (call-after-init
  259. (lambda ()
  260. (message "%s %s" invocation-name emacs-version)
  261. (message "%s was taken to initialize emacs." (emacs-init-time))
  262. (switch-to-buffer "*Messages*")))
  263. (cd ".") ; when using windows use / instead of \ in `default-directory'
  264. ;; locale
  265. (set-language-environment "Japanese")
  266. (set-default-coding-systems 'utf-8-unix)
  267. (prefer-coding-system 'utf-8-unix)
  268. (setq system-time-locale "C")
  269. ;; my prefix map
  270. (defvar my-prefix-map nil
  271. "My prefix map.")
  272. (define-prefix-command 'my-prefix-map)
  273. (define-key ctl-x-map (kbd "C-x") 'my-prefix-map)
  274. (define-key my-prefix-map (kbd "C-q") 'quoted-insert)
  275. (define-key my-prefix-map (kbd "C-z") 'suspend-frame)
  276. ;; (comint-show-maximum-output)
  277. ;; kill scratch
  278. (call-after-init (lambda ()
  279. (let ((buf (get-buffer "*scratch*")))
  280. (when buf
  281. (kill-buffer buf)))))
  282. ;; modifier keys
  283. ;; (setq mac-option-modifier 'control)
  284. ;; display
  285. (setq redisplay-dont-pause t)
  286. (setq visible-bell t)
  287. (setq ring-bell-function 'ignore)
  288. (mouse-avoidance-mode 'banish)
  289. (and window-system
  290. (fetch-library
  291. "https://raw.github.com/10sr/emacs-lisp/master/save-window-size.el"
  292. t)
  293. (safe-require-or-eval 'save-window-size))
  294. (defun reload-init-file ()
  295. "Reload Emacs init file."
  296. (interactive)
  297. (when (and user-init-file
  298. (file-readable-p user-init-file))
  299. (load-file user-init-file)))
  300. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  301. ;; for windows
  302. (defun start-ckw-bash ()
  303. "Start ckw in windows."
  304. (interactive)
  305. (start-process
  306. "ckw_bash"
  307. nil
  308. "C:/Documents and Settings/sr/Application Data/dbx/apps/ckw/ckw.exe"))
  309. ;; command seems to have to be in c drive
  310. (defun my-w32-add-export-path (&rest args)
  311. "Add pathes ARGS for windows."
  312. (mapc (lambda (path)
  313. (add-to-list 'exec-path (expand-file-name path)))
  314. (reverse args))
  315. (setenv "PATH"
  316. (mapconcat 'convert-standard-filename
  317. exec-path
  318. ";")))
  319. (when (eq system-type 'windows-nt)
  320. ;; (setq scheme-program-name "\"c:/Program Files/Gauche/bin/gosh.exe\" -i")
  321. ;; (setq python-python-command "c:/Python26/python.exe")
  322. ;; (define-key my-prefix-map (kbd "C-c") 'start-ckw-bash)
  323. (my-w32-add-export-path "c:/Windows/system"
  324. "c:/Windows/System32"
  325. "c:/Program Files/Git/bin"
  326. "c:/MinGW/bin"
  327. "c:/MinGW/mingw32/bin"
  328. (expand-file-name "~/.local/bin")
  329. (expand-file-name "~/dbx/apps/bin"))
  330. (when window-system
  331. (defvar-set w32-enable-synthesized-fonts t))
  332. (defvar-set w32-apps-modifier 'meta)
  333. (setq file-name-coding-system 'sjis))
  334. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  335. ;; global keys
  336. (global-set-key (kbd "<up>") 'scroll-down-line)
  337. (global-set-key (kbd "<down>") 'scroll-up-line)
  338. (global-set-key (kbd "<left>") 'scroll-down)
  339. (global-set-key (kbd "<right>") 'scroll-up)
  340. ;; (define-key my-prefix-map (kbd "C-h") help-map)
  341. (global-set-key (kbd "C-\\") help-map)
  342. (define-key ctl-x-map (kbd "DEL") help-map)
  343. (define-key ctl-x-map (kbd "C-h") help-map)
  344. (define-key help-map "a" 'apropos)
  345. ;; disable annoying keys
  346. (global-set-key [prior] 'ignore)
  347. (global-set-key (kbd "<next>") 'ignore)
  348. (global-set-key [menu] 'ignore)
  349. (global-set-key [down-mouse-1] 'ignore)
  350. (global-set-key [down-mouse-2] 'ignore)
  351. (global-set-key [down-mouse-3] 'ignore)
  352. (global-set-key [mouse-1] 'ignore)
  353. (global-set-key [mouse-2] 'ignore)
  354. (global-set-key [mouse-3] 'ignore)
  355. (global-set-key (kbd "<eisu-toggle>") 'ignore)
  356. (global-set-key (kbd "C-<eisu-toggle>") 'ignore)
  357. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  358. ;; title and mode-line
  359. (when (and (fetch-library
  360. "https://raw.github.com/10sr/emacs-lisp/master/terminal-title.el"
  361. t)
  362. (safe-require-or-eval 'terminal-title))
  363. ;; if TERM is not screen use default value
  364. (if (getenv "TMUX")
  365. ;; if use tmux locally just basename of current dir
  366. (defvar-set terminal-title-format
  367. '((file-name-nondirectory (directory-file-name
  368. default-directory))))
  369. (if (and (let ((tty-type (frame-parameter nil
  370. 'tty-type)))
  371. (and tty-type
  372. (equal (car (split-string tty-type
  373. "-"))
  374. "screen")))
  375. (not (getenv "SSH_CONNECTION")))
  376. (defvar-set terminal-title-format
  377. '((file-name-nondirectory (directory-file-name
  378. default-directory))))
  379. ;; seems that TMUX is used locally and ssh to remote host
  380. (defvar-set terminal-title-format
  381. `("em:"
  382. ,user-login-name
  383. "@"
  384. ,(car (split-string system-name
  385. "\\."))
  386. ":"
  387. default-directory))
  388. )
  389. )
  390. (terminal-title-mode))
  391. (setq eol-mnemonic-dos "\\r\\n")
  392. (setq eol-mnemonic-mac "\\r")
  393. (setq eol-mnemonic-unix "\\n")
  394. (which-function-mode 0)
  395. (line-number-mode 0)
  396. (column-number-mode 0)
  397. (size-indication-mode 0)
  398. (setq mode-line-position
  399. '(:eval (format "L%%l/%d,C%%c"
  400. (count-lines (point-max)
  401. (point-min)))))
  402. (when (require 'git-ps1-mode nil t)
  403. (git-ps1-mode))
  404. ;; http://www.geocities.jp/simizu_daisuke/bunkei-meadow.html#frame-title
  405. ;; display date
  406. (call-after-init (lambda ()
  407. (when display-time-mode
  408. (display-time-update))))
  409. (when (safe-require-or-eval 'time)
  410. (setq display-time-interval 29)
  411. (setq display-time-day-and-date t)
  412. (setq display-time-format "%a, %d %b %Y %T")
  413. (if window-system
  414. (display-time-mode 0)
  415. (display-time-mode 1)))
  416. ;; ;; current directory
  417. ;; (let ((ls (member 'mode-line-buffer-identification
  418. ;; mode-line-format)))
  419. ;; (setcdr ls
  420. ;; (cons '(:eval (concat " ("
  421. ;; (abbreviate-file-name default-directory)
  422. ;; ")"))
  423. ;; (cdr ls))))
  424. ;; ;; display last modified time
  425. ;; (let ((ls (member 'mode-line-buffer-identification
  426. ;; mode-line-format)))
  427. ;; (setcdr ls
  428. ;; (cons '(:eval (concat " "
  429. ;; my-buffer-file-last-modified-time))
  430. ;; (cdr ls))))
  431. (defun buffer-list-not-start-with-space ()
  432. "Return a list of buffers that not start with whitespaces."
  433. (let ((bl (buffer-list))
  434. b nbl)
  435. (while bl
  436. (setq b (pop bl))
  437. (unless (string-equal " "
  438. (substring (buffer-name b)
  439. 0
  440. 1))
  441. (add-to-list 'nbl b)))
  442. nbl))
  443. ;; http://www.masteringemacs.org/articles/2012/09/10/hiding-replacing-modeline-strings/
  444. ;; (add-to-list 'minor-mode-alist
  445. ;; '(global-whitespace-mode ""))
  446. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  447. ;; system info
  448. (defun my-message-current-info ()
  449. "Echo current login name, hostname and directory."
  450. (interactive)
  451. (message "%s@%s:%s"
  452. user-login-name
  453. system-name
  454. (abbreviate-file-name default-directory)))
  455. ;; (run-with-idle-timer 3
  456. ;; t
  457. ;; 'my-message-current-info)
  458. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  459. ;; minibuffer
  460. (setq insert-default-directory t)
  461. (setq completion-ignore-case t
  462. read-file-name-completion-ignore-case t
  463. read-buffer-completion-ignore-case t)
  464. (setq resize-mini-windows t)
  465. (temp-buffer-resize-mode 1)
  466. (savehist-mode 1)
  467. (fset 'yes-or-no-p 'y-or-n-p)
  468. ;; complete symbol when `eval'
  469. (define-key read-expression-map (kbd "TAB") 'lisp-complete-symbol)
  470. (define-key minibuffer-local-map (kbd "C-u")
  471. (lambda () (interactive) (delete-region (point-at-bol) (point))))
  472. ;; I dont know these bindings are good
  473. (define-key minibuffer-local-map (kbd "C-p") (kbd "ESC p"))
  474. (define-key minibuffer-local-map (kbd "C-n") (kbd "ESC n"))
  475. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  476. ;; letters, font-lock mode and fonts
  477. ;; (set-face-background 'vertical-border (face-foreground 'mode-line))
  478. ;; (set-window-margins (selected-window) 1 1)
  479. (and (or (eq system-type 'Darwin)
  480. (eq system-type 'darwin))
  481. (fboundp 'mac-set-input-method-parameter)
  482. (mac-set-input-method-parameter 'japanese 'cursor-color "red")
  483. (mac-set-input-method-parameter 'roman 'cursor-color "black"))
  484. (when (and (boundp 'input-method-activate-hook) ; i dont know this is correct
  485. (boundp 'input-method-inactivate-hook))
  486. (add-hook 'input-method-activate-hook
  487. (lambda () (set-cursor-color "red")))
  488. (add-hook 'input-method-inactivate-hook
  489. (lambda () (set-cursor-color "black"))))
  490. (when (safe-require-or-eval 'paren)
  491. (show-paren-mode 1)
  492. (setq show-paren-delay 0.5
  493. show-paren-style 'parenthesis) ; mixed is hard to read
  494. ;; (set-face-background 'show-paren-match
  495. ;; "black")
  496. ;; ;; (face-foreground 'default))
  497. ;; (set-face-foreground 'show-paren-match
  498. ;; "white")
  499. ;; (set-face-inverse-video-p 'show-paren-match
  500. ;; t)
  501. )
  502. (transient-mark-mode 1)
  503. (global-font-lock-mode 1)
  504. (setq font-lock-global-modes
  505. '(not
  506. help-mode
  507. eshell-mode
  508. term-mode
  509. Man-mode))
  510. ;; (standard-display-ascii ?\n "$\n")
  511. (defvar my-eol-face
  512. '(("\n" . (0 font-lock-comment-face t nil)))
  513. )
  514. (defvar my-tab-face
  515. '(("\t" . '(0 highlight t nil))))
  516. (defvar my-jspace-face
  517. '(("\u3000" . '(0 highlight t nil))))
  518. (add-hook 'font-lock-mode-hook
  519. (lambda ()
  520. ;; (font-lock-add-keywords nil my-eol-face)
  521. (font-lock-add-keywords nil my-jspace-face)
  522. ))
  523. (when (safe-require-or-eval 'whitespace)
  524. (add-to-list 'whitespace-display-mappings ; not work
  525. `(tab-mark ?\t ,(vconcat "^I\t")))
  526. (add-to-list 'whitespace-display-mappings
  527. `(newline-mark ?\n ,(vconcat "$\n")))
  528. (setq whitespace-style '(face
  529. trailing ; trailing blanks
  530. newline ; newlines
  531. newline-mark ; use display table for newline
  532. ;; tab-mark
  533. empty ; empty lines at beg or end of buffer
  534. lines-tail ; lines over 80
  535. ))
  536. ;; (setq whitespace-newline 'font-lock-comment-face)
  537. (global-whitespace-mode t)
  538. (if (eq (display-color-cells)
  539. 256)
  540. (set-face-foreground 'whitespace-newline "brightblack")
  541. ;; (progn
  542. ;; (set-face-bold-p 'whitespace-newline
  543. ;; t))
  544. ))
  545. (and nil
  546. (fetch-library
  547. "http://www.emacswiki.org/emacs/download/fill-column-indicator.el"
  548. t)
  549. (safe-require-or-eval 'fill-column-indicator)
  550. (setq fill-column-indicator))
  551. ;; highlight current line
  552. ;; http://wiki.riywo.com/index.php?Meadow
  553. (defface my-hl-line
  554. '((((min-colors 256)
  555. (background dark))
  556. (:background "color-234"))
  557. (((min-colors 256)
  558. (background light))
  559. (:background "color-234"))
  560. (t
  561. (:underline "black")))
  562. "*Face used by hl-line.")
  563. (defvar-set hl-line-face 'my-hl-line) ;; (setq hl-line-face nil)
  564. (global-hl-line-mode 1) ;; (hl-line-mode 1)
  565. (defvar-set hl-line-global-modes
  566. '(not
  567. term-mode))
  568. (set-face-foreground 'font-lock-regexp-grouping-backslash "#666")
  569. (set-face-foreground 'font-lock-regexp-grouping-construct "#f60")
  570. ;; fonts
  571. (defun my-set-ascii-and-jp-font (list)
  572. "Set font configuration to LIST."
  573. (let ((fspec1 (if (> emacs-major-version 22)
  574. ;; font spec is available in emacs23 and later
  575. (font-spec :family (nth 2 list) :size (nth 3 list))
  576. (cons (nth 2 list) "jisx0208.*")))
  577. (fspec2 (if (> emacs-major-version 22)
  578. (font-spec :family (nth 2 list) :size (nth 3 list))
  579. (cons (nth 2 list) "jisx0201.*"))))
  580. (set-face-attribute 'default nil
  581. :family (nth 0 list)
  582. :height (nth 1 list))
  583. (set-fontset-font "fontset-default"
  584. 'japanese-jisx0208
  585. fspec1)
  586. (set-fontset-font "fontset-default"
  587. 'katakana-jisx0201
  588. fspec2)))
  589. ;; (my-set-ascii-and-jp-font '("dejavu sans mono" 90 "takaogothic" 13))
  590. ;; (my-set-ascii-and-jp-font '("dejavu sans mono" 100 "takaogothic" 14))
  591. ;; (my-set-ascii-and-jp-font '("dejavu sans mono" 100 "ms gothic" 14))
  592. ;; (my-set-ascii-and-jp-font '("monaco" 75 "takaogothic" 11))
  593. ;; (my-set-ascii-and-jp-font '("monaco" 90 "takaogothic" 13))
  594. ;; (my-set-ascii-and-jp-font '("ProggyCleanTTSZ" 120 "takaogothic" 11))
  595. ;; あ a
  596. (and (fetch-library
  597. "https://raw.github.com/10sr/emacs-lisp/master/set-modeline-color.el"
  598. t)
  599. (progn
  600. (safe-require-or-eval 'set-modeline-color)))
  601. (let ((fg (face-foreground 'default))
  602. (bg (face-background 'default)))
  603. (set-face-background 'mode-line-inactive
  604. (if (face-inverse-video-p 'mode-line) fg bg))
  605. (set-face-foreground 'mode-line-inactive
  606. (if (face-inverse-video-p 'mode-line) bg fg)))
  607. (set-face-underline 'mode-line-inactive
  608. t)
  609. (set-face-underline 'vertical-border
  610. nil)
  611. (and (fetch-library
  612. "https://raw.github.com/tarao/elisp/master/end-mark.el"
  613. t)
  614. (safe-require-or-eval 'end-mark)
  615. (global-end-mark-mode))
  616. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  617. ;; file handling
  618. (require 'editorconfig nil t)
  619. (setq revert-without-query '(".+"))
  620. ;; save cursor position
  621. (when (safe-require-or-eval 'saveplace)
  622. (setq-default save-place t)
  623. (setq save-place-file (concat user-emacs-directory
  624. "places")))
  625. ;; http://www.bookshelf.jp/soft/meadow_24.html#SEC260
  626. (setq make-backup-files t)
  627. ;; (make-directory (expand-file-name "~/.emacsbackup"))
  628. (setq backup-directory-alist
  629. (cons (cons "\\.*$" (expand-file-name (concat user-emacs-directory
  630. "backup")))
  631. backup-directory-alist))
  632. (setq version-control 'never)
  633. (setq delete-old-versions t)
  634. (setq auto-save-list-file-prefix (expand-file-name (concat user-emacs-directory
  635. "auto-save/")))
  636. (setq delete-auto-save-files t)
  637. (add-to-list 'completion-ignored-extensions ".bak")
  638. ;; (setq delete-by-moving-to-trash t
  639. ;; trash-directory "~/.emacs.d/trash")
  640. (add-hook 'after-save-hook
  641. 'executable-make-buffer-file-executable-if-script-p)
  642. (defvar-set bookmark-default-file (concat user-emacs-directory
  643. "bmk"))
  644. (add-hook 'recentf-load-hook
  645. (lambda ()
  646. (defvar recentf-exclude)
  647. (add-to-list 'recentf-exclude
  648. (regexp-quote bookmark-default-file))))
  649. (and (fetch-library
  650. "https://raw.github.com/10sr/emacs-lisp/master/read-only-only-mode.el"
  651. t)
  652. (autoload-eval-lazily 'read-only-only-mode))
  653. (and (fetch-library
  654. "https://raw.github.com/10sr/emacs-lisp/master/smart-revert.el"
  655. t)
  656. (safe-require-or-eval 'smart-revert)
  657. (smart-revert-on))
  658. ;; autosave
  659. (and (fetch-library
  660. "https://raw.github.com/10sr/emacs-lisp/master/autosave.el"
  661. t)
  662. (safe-require-or-eval 'autosave)
  663. (autosave-set 2))
  664. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  665. ;; editting
  666. (defun my-copy-whole-line ()
  667. "Copy whole line."
  668. (interactive)
  669. (kill-new (concat (buffer-substring (point-at-bol)
  670. (point-at-eol))
  671. "\n")))
  672. (setq require-final-newline t)
  673. (setq kill-whole-line t)
  674. (setq scroll-conservatively 35
  675. scroll-margin 2
  676. scroll-step 0)
  677. (setq-default major-mode 'text-mode)
  678. (setq next-line-add-newlines nil)
  679. (setq kill-read-only-ok t)
  680. (setq truncate-partial-width-windows nil) ; when splitted horizontally
  681. ;; (setq-default line-spacing 0.2)
  682. (setq-default indicate-empty-lines t) ; when using x indicate empty line
  683. (setq-default tab-width 4)
  684. (setq-default indent-tabs-mode nil)
  685. (setq-default indent-line-function nil)
  686. ;; (pc-selection-mode 1) ; make some already defined keybind back to default
  687. (delete-selection-mode 1)
  688. (cua-mode 0)
  689. (setq line-move-visual nil)
  690. ;; key bindings
  691. ;; moving around
  692. ;; (global-set-key (kbd "M-j") 'next-line)
  693. ;; (global-set-key (kbd "M-k") 'previous-line)
  694. ;; (global-set-key (kbd "M-h") 'backward-char)
  695. ;; (global-set-key (kbd "M-l") 'forward-char)
  696. ;;(keyboard-translate ?\M-j ?\C-j)
  697. ;; (global-set-key (kbd "M-p") 'backward-paragraph)
  698. (define-key esc-map "p" 'backward-paragraph)
  699. ;; (global-set-key (kbd "M-n") 'forward-paragraph)
  700. (define-key esc-map "n" 'forward-paragraph)
  701. (global-set-key (kbd "C-<up>") 'scroll-down-line)
  702. (global-set-key (kbd "C-<down>") 'scroll-up-line)
  703. (global-set-key (kbd "C-<left>") 'scroll-down)
  704. (global-set-key (kbd "C-<right>") 'scroll-up)
  705. (global-set-key (kbd "<select>") 'ignore) ; 'previous-line-mark)
  706. (define-key ctl-x-map (kbd "ESC x") 'execute-extended-command)
  707. (define-key ctl-x-map (kbd "ESC :") 'eval-expression)
  708. ;; C-h and DEL
  709. (global-set-key (kbd "C-h") (kbd "DEL"))
  710. (global-set-key (kbd "C-m") 'reindent-then-newline-and-indent)
  711. (global-set-key (kbd "C-o") (kbd "C-e C-m"))
  712. (define-key esc-map "k" 'my-copy-whole-line)
  713. ;; (global-set-key "\C-z" 'undo) ; undo is M-u
  714. (define-key esc-map "u" 'undo)
  715. (define-key esc-map "i" (kbd "ESC TAB"))
  716. ;; (global-set-key (kbd "C-r") 'query-replace-regexp)
  717. (global-set-key (kbd "C-s") 'isearch-forward-regexp)
  718. (global-set-key (kbd "C-r") 'isearch-backward-regexp)
  719. (define-key my-prefix-map (kbd "C-o") 'occur)
  720. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  721. ;; japanese input method
  722. (defun my-load-scim ()
  723. "Use scim-bridge.el as japanese im."
  724. ;; Load scim-bridge.
  725. (when (safe-require-or-eval 'scim-bridge)
  726. ;; Turn on scim-mode automatically after loading .emacs
  727. (call-after-init 'scim-mode-on)
  728. (defvar-set scim-cursor-color "red")
  729. (scim-define-preedit-key ?\^h t)
  730. (scim-define-common-key ?\* nil)
  731. (scim-define-common-key ?\^/ nil)))
  732. (defun my-load-anthy ()
  733. "Use anthy.el as japanese im."
  734. ;; anthy
  735. (when (safe-require-or-eval 'anthy)
  736. (global-set-key
  737. (kbd "<muhenkan>") (lambda () (interactive) (anthy-mode-off)))
  738. (global-set-key (kbd "<henkan>") (lambda () (interactive) (anthy-mode-on)))
  739. (when (>= emacs-major-version 23)
  740. (defvar-set anthy-accept-timeout 1))))
  741. ;; quail
  742. ;; aproposs input-method for some information
  743. ;; (setq default-input-method "japanese")
  744. (defun my-load-mozc-el ()
  745. "Use mozc.el as japanese im."
  746. (when (safe-require-or-eval 'mozc)
  747. (defvar-set defauit-input-method "japanese-mozc")
  748. (defvar-set mozc-leim-title "[MZ]")
  749. ))
  750. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  751. ;; gmail
  752. (setq mail-interactive t
  753. send-mail-function 'smtpmail-send-it
  754. ;; message-send-mail-function 'smtpmail-send-it
  755. smtpmail-smtp-server "smtp.gmail.com"
  756. smtpmail-smtp-service 587
  757. smtpmail-starttls-credentials '(("smtp.gmail.com" 587
  758. "8.slashes@gmail.com" nil))
  759. smtpmail-auth-credentials '(("smtp.gmail.com" 587
  760. "8.slashes@gmail.com" nil))
  761. user-mail-address "8.slashes@gmail.com")
  762. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  763. ;; buffer killing
  764. ;; (defun my-delete-window-killing-buffer () nil)
  765. (defun my-query-kill-current-buffer ()
  766. "Interactively kill current buffer."
  767. (interactive)
  768. (if (y-or-n-p (concat "kill current buffer? :"))
  769. (kill-buffer (current-buffer))))
  770. (substitute-key-definition 'kill-buffer
  771. 'my-query-kill-current-buffer
  772. global-map)
  773. ;;(global-set-key "\C-xk" 'my-query-kill-current-buffer)
  774. (defun my-kill-buffers ()
  775. "Kill buffers that visit files."
  776. (interactive)
  777. (mapcar (lambda (buf)
  778. (when (buffer-file-name buf)
  779. (kill-buffer buf)))
  780. (buffer-list)))
  781. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  782. ;; share clipboard with x
  783. ;; this page describes this in details, but only these sexps seem to be needed
  784. ;; http://garin.jp/doc/Linux/xwindow_clipboard
  785. (and (not window-system)
  786. (not (eq window-system 'mac))
  787. (getenv "DISPLAY")
  788. (not (equal (getenv "DISPLAY") ""))
  789. (executable-find "xclip")
  790. ;; (< emacs-major-version 24)
  791. (safe-require-or-eval 'xclip)
  792. nil
  793. (turn-on-xclip))
  794. (and (eq system-type 'darwin)
  795. (fetch-library
  796. "https://raw.github.com/10sr/emacs-lisp/master/pasteboard.el"
  797. t)
  798. (safe-require-or-eval 'pasteboard)
  799. (turn-on-pasteboard)
  800. (getenv "TMUX")
  801. (pasteboard-enable-rtun))
  802. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  803. ;; https://github.com/lunaryorn/flycheck
  804. (when (safe-require-or-eval 'flycheck)
  805. (call-after-init 'global-flycheck-mode))
  806. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  807. ;; window
  808. '(and (fetch-library
  809. "https://raw.github.com/10sr/emacs-lisp/master/window-organizer.el"
  810. t)
  811. (autoload-eval-lazily 'window-organizer)
  812. (define-key ctl-x-map (kbd "w") 'window-organizer))
  813. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  814. ;; server
  815. (when (safe-require-or-eval 'server)
  816. (setq server-name (concat "server"
  817. (number-to-string (emacs-pid))))
  818. ;; In Cygwin Environment `server-runnning-p' stops when server-use-tcp is nil
  819. ;; In Darwin environment, init fails with message like 'Service name too long'
  820. ;; when server-use-tcp is nil
  821. (when (or (eq system-type
  822. 'cygwin)
  823. (eq system-type
  824. 'darwin))
  825. (setq server-use-tcp t))
  826. (defun my-construct-emacsclient-editor-command ()
  827. "Construct and return command in a string to connect to current Emacs server."
  828. (if server-use-tcp
  829. (format "%s -f \"%s/%s\""
  830. "emacsclient"
  831. (expand-file-name server-auth-dir)
  832. server-name)
  833. (format "%s -s \"%s/%s\""
  834. "emacsclient"
  835. server-socket-dir
  836. server-name)))
  837. (setq process-environment
  838. `(,(concat "EDITOR="
  839. (my-construct-emacsclient-editor-command))
  840. ,(concat "GIT_EDITOR="
  841. (my-construct-emacsclient-editor-command))
  842. ,@process-environment))
  843. (server-start))
  844. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  845. ;; some modes and hooks
  846. (defvar-set ac-ignore-case nil)
  847. ;; (when (require 'ensime nil t)
  848. ;; (defvar-set ensime-ac-case-sensitive t)
  849. ;; (defvar-set ensime-company-case-sensitive t)
  850. ;; (add-hook 'scala-mode-hook
  851. ;; 'ensime-scala-mode-hook)
  852. ;; (add-hook 'ensime-scala-mode-hook
  853. ;; 'ac-stop))
  854. (when (autoload-eval-lazily 'term-run '(term-run-shell-command term-run))
  855. (define-key ctl-x-map "t" 'term-run-shell-command))
  856. (add-to-list 'safe-local-variable-values
  857. '(encoding utf-8))
  858. (setq enable-local-variables :safe)
  859. (when (autoload-eval-lazily 'dirtree nil
  860. (defun my-dirtree-current-line-directory-p ()
  861. "Return nil if element on current line is not a directory."
  862. (file-directory-p (widget-get (tree-mode-button-current-line)
  863. :file)))
  864. ;; This fix is actually a little strange. Strictly speaking
  865. ;; judging tree should be done by whether the widget is a tree one.
  866. (defun my-dirtree-next-node (arg)
  867. "Fix the problem that `tree-mode-next-node' moves cursor 2 lines."
  868. (interactive "p")
  869. (if (my-dirtree-current-line-directory-p)
  870. (widget-forward (* arg 2))
  871. (widget-forward arg)))
  872. (defun my-dirtree-previous-node (arg)
  873. "Fix the problem that `tree-mode-previous-node' moves cursor 2 lines."
  874. (interactive "p")
  875. (my-dirtree-next-node (- arg)))
  876. (define-key dirtree-mode-map "n" 'my-dirtree-next-node)
  877. (define-key dirtree-mode-map "p" 'my-dirtree-previous-node))
  878. (define-key ctl-x-map "d" 'dirtree))
  879. (and (fetch-library
  880. "https://raw.github.com/10sr/emacs-lisp/master/remember-major-modes-mode.el"
  881. t)
  882. (safe-require-or-eval 'remember-major-modes-mode)
  883. (remember-major-modes-mode 1)
  884. )
  885. ;; Detect file type from shebang and set major-mode.
  886. (add-to-list 'interpreter-mode-alist
  887. '("python3" . python-mode))
  888. (add-to-list 'interpreter-mode-alist
  889. '("python2" . python-mode))
  890. ;; http://fukuyama.co/foreign-regexp
  891. '(and (safe-require-or-eval 'foreign-regexp)
  892. (progn
  893. (setq foreign-regexp/regexp-type 'perl)
  894. '(setq reb-re-syntax 'foreign-regexp)
  895. ))
  896. (safe-require-or-eval 'session)
  897. (autoload-eval-lazily 'sql '(sql-mode)
  898. (safe-require-or-eval 'sql-indent))
  899. '(and (fetch-library "https://raw.github.com/10sr/emacs-lisp/master/gtkbm.el"
  900. t)
  901. (autoload-eval-lazily 'gtkbm)
  902. (global-set-key (kbd "C-x C-d") 'gtkbm))
  903. (and (fetch-library
  904. "https://raw.github.com/10sr/git-command-el/master/git-command.el"
  905. t)
  906. (autoload-eval-lazily 'git-command
  907. nil
  908. ;; for git-command old version
  909. (when (boundp 'git-command-major-mode-alist)
  910. (message "You are using old git-command ! Update it !!!")
  911. (add-to-list 'git-command-major-mode-alist
  912. '("di" . diff-mode))
  913. (add-to-list 'git-command-major-mode-alist
  914. '("graph" . fundamental-mode))
  915. (add-to-list 'git-command-major-mode-alist
  916. '("log" . fundamental-mode)))
  917. ;; for git-command new version
  918. (when (boundp 'git-command-view-command-list)
  919. (add-to-list 'git-command-view-command-list
  920. "graph")
  921. (add-to-list 'git-command-view-command-list
  922. "blame")
  923. (add-to-list 'git-command-view-command-list
  924. "help"))
  925. (when (boundp 'git-command-aliases-alist)
  926. ;; (message "new version of git-command!")
  927. (add-to-list 'git-command-aliases-alist
  928. '("di" . (lambda (options cmd args new-buffer-p)
  929. (git-command-exec options
  930. "diff"
  931. args
  932. new-buffer-p))))
  933. (add-to-list 'git-command-aliases-alist
  934. '("grep" . (lambda (options cmd args new-buffer-p)
  935. (my-rgrep
  936. (concat
  937. "git "
  938. (git-command-construct-commandline
  939. `(,@options "--no-pager"
  940. "-c" "color.grep=false")
  941. cmd
  942. `("-nHe" ,@args))))))))
  943. (setq git-command-use-emacsclient t)
  944. (or git-command-prompt-file
  945. (setq git-command-prompt-file
  946. (git-command-find-git-ps1
  947. "/usr/share/git-core/contrib/completion/git-prompt.sh"))))
  948. ;; (setq git-command-default-options "-c color.ui=always")
  949. (define-key ctl-x-map "g" 'git-command))
  950. (and (fetch-library
  951. "http://www.emacswiki.org/emacs/download/sl.el"
  952. t)
  953. (autoload-eval-lazily 'sl))
  954. (defalias 'qcalc 'quick-calc)
  955. (safe-require-or-eval 'simple)
  956. (add-hook 'makefile-mode-hook
  957. (lambda ()
  958. (local-set-key (kbd "C-m") 'newline-and-indent)
  959. ;; this functions is set in write-file-functions, i cannot find any
  960. ;; good way to remove this.
  961. (fset 'makefile-warn-suspicious-lines 'ignore)
  962. ))
  963. (add-hook 'verilog-mode-hook
  964. (lambda ()
  965. (local-set-key ";" 'self-insert-command)))
  966. (setq diff-switches "-u")
  967. (add-hook 'diff-mode-hook
  968. (lambda ()
  969. ;; (when (and (eq major-mode
  970. ;; 'diff-mode)
  971. ;; (not buffer-file-name))
  972. ;; ;; do not pass when major-mode is derived mode of diff-mode
  973. ;; (view-mode 1))
  974. (set-face-attribute 'diff-header nil
  975. :foreground nil
  976. :background nil
  977. :weight 'bold)
  978. (set-face-attribute 'diff-file-header nil
  979. :foreground nil
  980. :background nil
  981. :weight 'bold)
  982. (set-face-foreground 'diff-index-face "blue")
  983. (set-face-attribute 'diff-hunk-header nil
  984. :foreground "cyan"
  985. :weight 'normal)
  986. (set-face-attribute 'diff-context nil
  987. ;; :foreground "white"
  988. :foreground nil
  989. :weight 'normal)
  990. (set-face-foreground 'diff-removed-face "red")
  991. (set-face-foreground 'diff-added-face "green")
  992. (set-face-background 'diff-removed-face nil)
  993. (set-face-background 'diff-added-face nil)
  994. (set-face-attribute 'diff-changed nil
  995. :foreground "magenta"
  996. :weight 'normal)
  997. (set-face-attribute 'diff-refine-change nil
  998. :foreground nil
  999. :background nil
  1000. :weight 'bold
  1001. :inverse-video t)
  1002. ;; Annoying !
  1003. ;;(diff-auto-refine-mode)
  1004. ))
  1005. ;; (ffap-bindings)
  1006. (add-hook 'sh-mode-hook
  1007. (lambda ()
  1008. (local-set-key
  1009. (kbd "C-x C-e")
  1010. 'my-execute-shell-command-current-line)))
  1011. (defvar-set sh-here-document-word "__EOC__")
  1012. (defun my-execute-shell-command-current-line ()
  1013. "Run current line as shell command."
  1014. (interactive)
  1015. (shell-command (buffer-substring-no-properties (point-at-bol)
  1016. (point))))
  1017. (setq auto-mode-alist
  1018. `(("autostart\\'" . sh-mode)
  1019. ("xinitrc\\'" . sh-mode)
  1020. ("xprograms\\'" . sh-mode)
  1021. ("PKGBUILD\\'" . sh-mode)
  1022. ,@auto-mode-alist))
  1023. (and (autoload-eval-lazily 'pkgbuild-mode)
  1024. (setq auto-mode-alist (append '(("PKGBUILD\\'" . pkgbuild-mode))
  1025. auto-mode-alist)))
  1026. (add-hook 'yaml-mode-hook
  1027. (lambda ()
  1028. (local-set-key(kbd "C-m") 'newline)))
  1029. (add-hook 'html-mode-hook
  1030. (lambda ()
  1031. (local-set-key(kbd "C-m") 'reindent-then-newline-and-indent)))
  1032. (add-hook 'text-mode-hook
  1033. (lambda ()
  1034. (local-set-key (kbd "C-m") 'newline)))
  1035. (add-to-list 'Info-default-directory-list
  1036. (expand-file-name "~/.info/emacs-ja"))
  1037. (add-hook 'apropos-mode-hook
  1038. (lambda ()
  1039. (local-set-key "n" 'next-line)
  1040. (local-set-key "p" 'previous-line)
  1041. ))
  1042. (add-hook 'isearch-mode-hook
  1043. (lambda ()
  1044. ;; (define-key isearch-mode-map
  1045. ;; (kbd "C-j") 'isearch-other-control-char)
  1046. ;; (define-key isearch-mode-map
  1047. ;; (kbd "C-k") 'isearch-other-control-char)
  1048. ;; (define-key isearch-mode-map
  1049. ;; (kbd "C-h") 'isearch-other-control-char)
  1050. (define-key isearch-mode-map (kbd "C-h") 'isearch-delete-char)
  1051. (define-key isearch-mode-map (kbd "M-r")
  1052. 'isearch-query-replace-regexp)))
  1053. ;; do not cleanup isearch highlight: use `lazy-highlight-cleanup' to remove
  1054. (setq lazy-highlight-cleanup nil)
  1055. ;; face for isearch highlighing
  1056. (set-face-attribute 'lazy-highlight
  1057. nil
  1058. :foreground `unspecified
  1059. :background `unspecified
  1060. :underline t
  1061. ;; :weight `bold
  1062. )
  1063. (add-hook 'outline-mode-hook
  1064. (lambda ()
  1065. (if (string-match "\\.md\\'" buffer-file-name)
  1066. (set (make-local-variable 'outline-regexp) "#+ "))))
  1067. (add-to-list 'auto-mode-alist (cons "\\.ol\\'" 'outline-mode))
  1068. (add-to-list 'auto-mode-alist (cons "\\.md\\'" 'outline-mode))
  1069. (when (autoload-eval-lazily 'markdown-mode
  1070. '(markdown-mode gfm-mode))
  1071. (add-to-list 'auto-mode-alist (cons "\\.md\\'" 'gfm-mode))
  1072. (setq markdown-command (or (executable-find "markdown")
  1073. (executable-find "markdown.pl")))
  1074. (add-hook 'markdown-mode-hook
  1075. (lambda ()
  1076. (outline-minor-mode 1)
  1077. (flyspell-mode)
  1078. (set (make-local-variable 'comment-start) ";"))))
  1079. ;; c-mode
  1080. ;; http://www.emacswiki.org/emacs/IndentingC
  1081. ;; http://en.wikipedia.org/wiki/Indent_style
  1082. ;; http://d.hatena.ne.jp/emergent/20070203/1170512717
  1083. ;; http://seesaawiki.jp/whiteflare503/d/Emacs%20%a5%a4%a5%f3%a5%c7%a5%f3%a5%c8
  1084. (when (autoload-eval-lazily 'cc-vars
  1085. nil
  1086. (defvar c-default-style)
  1087. (add-to-list 'c-default-style
  1088. '(c-mode . "k&r"))
  1089. (add-to-list 'c-default-style
  1090. '(c++-mode . "k&r"))
  1091. (add-hook 'c-mode-common-hook
  1092. (lambda ()
  1093. ;; why c-basic-offset in k&r style defaults to 5 ???
  1094. (defvar-set c-basic-offset 4)
  1095. (defvar-set indent-tabs-mode nil)
  1096. ;; (set-face-foreground 'font-lock-keyword-face "blue")
  1097. (c-toggle-hungry-state -1)
  1098. ;; (and (require 'gtags nil t)
  1099. ;; (gtags-mode 1))
  1100. ))))
  1101. (when (autoload-eval-lazily 'php-mode)
  1102. (add-hook 'php-mode-hook
  1103. (lambda ()
  1104. (setq c-basic-offset 2))))
  1105. (when (autoload-eval-lazily 'js2-mode)
  1106. ;; currently do not use js2-mode
  1107. ;; (add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
  1108. ;; (add-to-list 'auto-mode-alist '("\\.jsm\\'" . js2-mode))
  1109. (add-hook 'js2-mode-hook
  1110. (lambda ()
  1111. (define-key js2-mode-map (kbd "C-m") (lambda ()
  1112. (interactive)
  1113. (js2-enter-key)
  1114. (indent-for-tab-command)))
  1115. ;; (add-hook (kill-local-variable 'before-save-hook)
  1116. ;; 'js2-before-save)
  1117. ;; (add-hook 'before-save-hook
  1118. ;; 'my-indent-buffer
  1119. ;; nil
  1120. ;; t)
  1121. )))
  1122. (eval-after-load "js"
  1123. (defvar-set js-indent-level 2))
  1124. (add-to-list 'interpreter-mode-alist
  1125. '("node" . js-mode))
  1126. (when (autoload-eval-lazily 'flymake-jslint
  1127. '(flymake-jslint-load))
  1128. (autoload-eval-lazily 'js nil
  1129. (add-hook 'js-mode-hook
  1130. 'flymake-jslint-load)))
  1131. (safe-require-or-eval 'js-doc)
  1132. (add-hook 'haskell-mode-hook 'turn-on-haskell-indentation)
  1133. (when (safe-require-or-eval 'uniquify)
  1134. (setq uniquify-buffer-name-style 'post-forward-angle-brackets)
  1135. (setq uniquify-ignore-buffers-re "*[^*]+*")
  1136. (setq uniquify-min-dir-content 1))
  1137. (add-hook 'view-mode-hook
  1138. (lambda()
  1139. (defvar view-mode-map)
  1140. (define-key view-mode-map "j" 'scroll-up-line)
  1141. (define-key view-mode-map "k" 'scroll-down-line)
  1142. (define-key view-mode-map "v" 'toggle-read-only)
  1143. (define-key view-mode-map "q" 'bury-buffer)
  1144. ;; (define-key view-mode-map "/" 'nonincremental-re-search-forward)
  1145. ;; (define-key view-mode-map "?" 'nonincremental-re-search-backward)
  1146. ;; (define-key view-mode-map
  1147. ;; "n" 'nonincremental-repeat-search-forward)
  1148. ;; (define-key view-mode-map
  1149. ;; "N" 'nonincremental-repeat-search-backward)
  1150. (define-key view-mode-map "/" 'isearch-forward-regexp)
  1151. (define-key view-mode-map "?" 'isearch-backward-regexp)
  1152. (define-key view-mode-map "n" 'isearch-repeat-forward)
  1153. (define-key view-mode-map "N" 'isearch-repeat-backward)
  1154. (define-key view-mode-map (kbd "C-m") 'my-rgrep-symbol-at-point)
  1155. ))
  1156. (global-set-key "\M-r" 'view-mode)
  1157. ;; (setq view-read-only t)
  1158. ;; (defun my-view-mode-search-word (word)
  1159. ;; "Search for word current directory and subdirectories.
  1160. ;; If called intearctively, find word at point."
  1161. ;; (interactive (list (thing-at-point 'symbol)))
  1162. ;; (if word
  1163. ;; (if (and (require 'gtags nil t)
  1164. ;; (gtags-get-rootpath))
  1165. ;; (gtags-goto-tag word "s")
  1166. ;; (my-rgrep word))
  1167. ;; (message "No word at point.")
  1168. ;; nil))
  1169. (add-hook 'Man-mode-hook
  1170. (lambda ()
  1171. (view-mode 1)
  1172. (setq truncate-lines nil)))
  1173. (defvar-set Man-notify-method (if window-system
  1174. 'newframe
  1175. 'aggressive))
  1176. (defvar-set woman-cache-filename (expand-file-name (concat user-emacs-directory
  1177. "woman_cache.el")))
  1178. (defalias 'man 'woman)
  1179. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1180. ;; python
  1181. (when (autoload-eval-lazily 'python '(python-mode))
  1182. (defvar-set python-python-command (or (executable-find "python3")
  1183. (executable-find "python")))
  1184. ;; (defun my-python-run-as-command ()
  1185. ;; ""
  1186. ;; (interactive)
  1187. ;; (shell-command (concat python-python-command " " buffer-file-name)))
  1188. (defun my-python-display-python-buffer ()
  1189. ""
  1190. (interactive)
  1191. (defvar python-buffer)
  1192. (set-window-text-height (display-buffer python-buffer
  1193. t)
  1194. 7))
  1195. (add-hook 'python-mode-hook
  1196. (lambda ()
  1197. (local-set-key (kbd "C-c C-e") 'my-python-run-as-command)
  1198. (local-set-key (kbd "C-c C-b") 'my-python-display-python-buffer)
  1199. (local-set-key (kbd "C-m") 'newline-and-indent)))
  1200. (add-hook 'inferior-python-mode-hook
  1201. (lambda ()
  1202. (my-python-display-python-buffer)
  1203. (local-set-key (kbd "<up>") 'comint-previous-input)
  1204. (local-set-key (kbd "<down>") 'comint-next-input))))
  1205. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1206. ;; GNU GLOBAL(gtags)
  1207. ;; http://uguisu.skr.jp/Windows/gtags.html
  1208. ;; http://eigyr.dip.jp/gtags.html
  1209. ;; http://cha.la.coocan.jp/doc/gnu_global.html
  1210. (let ((d "/opt/local/share/gtags/"))
  1211. (and (file-directory-p d)
  1212. (add-to-list 'load-path
  1213. d)))
  1214. (when (autoload-eval-lazily 'gtags '(gtags-mode))
  1215. (add-hook 'gtags-mode-hook
  1216. (lambda ()
  1217. (view-mode gtags-mode)
  1218. (setq gtags-select-buffer-single t)
  1219. ;; (local-set-key "\M-t" 'gtags-find-tag)
  1220. ;; (local-set-key "\M-r" 'gtags-find-rtag)
  1221. ;; (local-set-key "\M-s" 'gtags-find-symbol)
  1222. ;; (local-set-key "\C-t" 'gtags-pop-stack)
  1223. (define-key gtags-mode-map (kbd "C-x t h")
  1224. 'gtags-find-tag-from-here)
  1225. (define-key gtags-mode-map (kbd "C-x t t") 'gtags-find-tag)
  1226. (define-key gtags-mode-map (kbd "C-x t r") 'gtags-find-rtag)
  1227. (define-key gtags-mode-map (kbd "C-x t s") 'gtags-find-symbol)
  1228. (define-key gtags-mode-map (kbd "C-x t p") 'gtags-find-pattern)
  1229. (define-key gtags-mode-map (kbd "C-x t f") 'gtags-find-file)
  1230. (define-key gtags-mode-map (kbd "C-x t b") 'gtags-pop-stack) ;back
  1231. ))
  1232. (add-hook 'gtags-select-mode-hook
  1233. (lambda ()
  1234. (define-key gtags-select-mode-map (kbd "C-m") 'gtags-select-tag)
  1235. ))
  1236. )
  1237. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1238. ;; term mode
  1239. ;; (setq multi-term-program shell-file-name)
  1240. (when (autoload-eval-lazily 'multi-term)
  1241. (setq multi-term-switch-after-close nil)
  1242. (setq multi-term-dedicated-select-after-open-p t)
  1243. (setq multi-term-dedicated-window-height 20))
  1244. (when (autoload-eval-lazily 'term '(term ansi-term))
  1245. (defun my-term-quit-or-send-raw ()
  1246. ""
  1247. (interactive)
  1248. (if (get-buffer-process (current-buffer))
  1249. (call-interactively 'term-send-raw)
  1250. (kill-buffer)))
  1251. ;; http://d.hatena.ne.jp/goinger/20100416/1271399150
  1252. ;; (setq term-ansi-default-program shell-file-name)
  1253. (add-hook 'term-setup-hook
  1254. (lambda ()
  1255. (defvar-set term-display-table (make-display-table))))
  1256. (add-hook 'term-mode-hook
  1257. (lambda ()
  1258. (defvar term-raw-map)
  1259. (unless (memq (current-buffer)
  1260. (and (featurep 'multi-term)
  1261. (defvar multi-term-buffer-list)
  1262. ;; current buffer is not multi-term buffer
  1263. multi-term-buffer-list))
  1264. ;; (define-key term-raw-map "\C-q" 'move-beginning-of-line)
  1265. ;; (define-key term-raw-map "\C-r" 'term-send-raw)
  1266. ;; (define-key term-raw-map "\C-s" 'term-send-raw)
  1267. ;; (define-key term-raw-map "\C-f" 'forward-char)
  1268. ;; (define-key term-raw-map "\C-b" 'backward-char)
  1269. ;; (define-key term-raw-map "\C-t" 'set-mark-command)
  1270. (define-key term-raw-map
  1271. "\C-x" (lookup-key (current-global-map) "\C-x"))
  1272. (define-key term-raw-map
  1273. "\C-z" (lookup-key (current-global-map) "\C-z"))
  1274. )
  1275. ;; (define-key term-raw-map "\C-xl" 'term-line-mode)
  1276. ;; (define-key term-mode-map "\C-xc" 'term-char-mode)
  1277. (define-key term-raw-map (kbd "<up>") 'scroll-down-line)
  1278. (define-key term-raw-map (kbd "<down>") 'scroll-up-line)
  1279. (define-key term-raw-map (kbd "<right>") 'scroll-up)
  1280. (define-key term-raw-map (kbd "<left>") 'scroll-down)
  1281. (define-key term-raw-map (kbd "C-p") 'term-send-raw)
  1282. (define-key term-raw-map (kbd "C-n") 'term-send-raw)
  1283. (define-key term-raw-map "q" 'my-term-quit-or-send-raw)
  1284. ;; (define-key term-raw-map (kbd "ESC") 'term-send-raw)
  1285. (define-key term-raw-map [delete] 'term-send-raw)
  1286. (define-key term-raw-map (kbd "DEL") 'term-send-backspace)
  1287. (define-key term-raw-map "\C-y" 'term-paste)
  1288. (define-key term-raw-map
  1289. "\C-c" 'term-send-raw) ;; 'term-interrupt-subjob)
  1290. '(define-key term-mode-map (kbd "C-x C-q") 'term-pager-toggle)
  1291. ;; (dolist (key '("<up>" "<down>" "<right>" "<left>"))
  1292. ;; (define-key term-raw-map (read-kbd-macro key) 'term-send-raw))
  1293. ;; (define-key term-raw-map "\C-d" 'delete-char)
  1294. (set (make-local-variable 'scroll-margin) 0)
  1295. ;; (set (make-local-variable 'cua-enable-cua-keys) nil)
  1296. ;; (cua-mode 0)
  1297. ;; (and cua-mode
  1298. ;; (local-unset-key (kbd "C-c")))
  1299. ;; (define-key cua--prefix-override-keymap
  1300. ;;"\C-c" 'term-interrupt-subjob)
  1301. (set (make-local-variable (defvar hl-line-range-function))
  1302. (lambda ()
  1303. '(0 . 0)))
  1304. ))
  1305. ;; (add-hook 'term-exec-hook 'forward-char)
  1306. )
  1307. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1308. ;; buffer switching
  1309. (defvar bs-configurations)
  1310. (when (autoload-eval-lazily 'bs '(bs-show)
  1311. ;; (add-to-list 'bs-configurations
  1312. ;; '("processes" nil get-buffer-process ".*" nil nil))
  1313. (add-to-list 'bs-configurations
  1314. '("files-and-terminals" nil nil nil
  1315. (lambda (buf)
  1316. (and (bs-visits-non-file buf)
  1317. (save-excursion
  1318. (set-buffer buf)
  1319. (not (memq major-mode
  1320. '(term-mode
  1321. eshell-mode))))))))
  1322. ;; (setq bs-configurations (list
  1323. ;; '("processes" nil get-buffer-process ".*" nil nil)
  1324. ;; '("files-and-scratch" "^\\*scratch\\*$" nil nil
  1325. ;; bs-visits-non-file bs-sort-buffer-interns-are-last)))
  1326. )
  1327. ;; (global-set-key "\C-x\C-b" 'bs-show)
  1328. (defalias 'list-buffers 'bs-show)
  1329. (defvar-set bs-default-configuration "files-and-terminals")
  1330. (defvar-set bs-default-sort-name "by nothing")
  1331. (add-hook 'bs-mode-hook
  1332. (lambda ()
  1333. ;; (setq bs-default-configuration "files")
  1334. ;; (and bs--show-all
  1335. ;; (call-interactively 'bs-toggle-show-all))
  1336. (set (make-local-variable 'scroll-margin) 0))))
  1337. ;;(iswitchb-mode 1)
  1338. (icomplete-mode)
  1339. (defun iswitchb-buffer-display-other-window ()
  1340. "Do iswitchb in other window."
  1341. (interactive)
  1342. (let ((iswitchb-default-method 'display))
  1343. (call-interactively 'iswitchb-buffer)))
  1344. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1345. ;; sdic
  1346. (when (autoload-eval-lazily 'sdic '(sdic-describe-word-at-point))
  1347. ;; (define-key my-prefix-map "\C-w" 'sdic-describe-word)
  1348. (define-key my-prefix-map "\C-t" 'sdic-describe-word-at-point-echo)
  1349. (defun sdic-describe-word-at-point-echo ()
  1350. ""
  1351. (interactive)
  1352. (save-window-excursion
  1353. (sdic-describe-word-at-point))
  1354. (save-excursion
  1355. (set-buffer sdic-buffer-name)
  1356. (message (buffer-substring (point-min)
  1357. (progn (goto-char (point-min))
  1358. (or (and (re-search-forward "^\\w"
  1359. nil
  1360. t
  1361. 4)
  1362. (progn (previous-line) t)
  1363. (point-at-eol))
  1364. (point-max)))))))
  1365. (setq sdic-eiwa-dictionary-list '((sdicf-client "/usr/share/dict/gene.sdic")))
  1366. (setq sdic-waei-dictionary-list
  1367. '((sdicf-client "/usr/share/dict/jedict.sdic" (add-keys-to-headword t))))
  1368. (setq sdic-disable-select-window t)
  1369. (setq sdic-window-height 7))
  1370. ;;;;;;;;;;;;;;;;;;;;;;;;
  1371. ;; ilookup
  1372. (when (fetch-library
  1373. "https://raw.github.com/10sr/emacs-lisp/master/ilookup.el"
  1374. t)
  1375. (autoload-eval-lazily 'ilookup
  1376. '(ilookup-open)
  1377. (setq ilookup-dict-alist
  1378. '(
  1379. ("en" . (lambda (word)
  1380. (shell-command-to-string
  1381. (format "sdcv -n -u dictd_www.dict.org_gcide '%s'"
  1382. word))))
  1383. ("ja" . (lambda (word)
  1384. (shell-command-to-string
  1385. (format "sdcv -n -u EJ-GENE95 -u jmdict-en-ja '%s'"
  1386. word))))
  1387. ("jaj" . (lambda (word)
  1388. (shell-command-to-string
  1389. (format "sdcv -n -u jmdict-en-ja '%s'"
  1390. word))))
  1391. ("jag" .
  1392. (lambda (word)
  1393. (with-temp-buffer
  1394. (insert (shell-command-to-string
  1395. (format "sdcv -n -u 'Genius English-Japanese' '%s'"
  1396. word)))
  1397. (html2text)
  1398. (buffer-substring (point-min)
  1399. (point-max)))))
  1400. ("alc" . (lambda (word)
  1401. (shell-command-to-string
  1402. (format "alc '%s' | head -n 20"
  1403. word))))
  1404. ("app" . (lambda (word)
  1405. (shell-command-to-string
  1406. (format "dict_app '%s'"
  1407. word))))
  1408. ;; letters broken
  1409. ("ms" .
  1410. (lambda (word)
  1411. (let ((url (concat
  1412. "http://api.microsofttranslator.com/V2/Ajax.svc/"
  1413. "Translate?appId=%s&text=%s&to=%s"))
  1414. (apikey "3C9778666C5BA4B406FFCBEE64EF478963039C51")
  1415. (target "ja")
  1416. (eword (url-hexify-string word)))
  1417. (with-current-buffer (url-retrieve-synchronously
  1418. (format url
  1419. apikey
  1420. eword
  1421. target))
  1422. (message "")
  1423. (goto-char (point-min))
  1424. (search-forward-regexp "^$"
  1425. nil
  1426. t)
  1427. (url-unhex-string (buffer-substring-no-properties
  1428. (point)
  1429. (point-max)))))))
  1430. ))
  1431. ;; (funcall (cdr (assoc "ms"
  1432. ;; ilookup-alist))
  1433. ;; "dictionary")
  1434. ;; (switch-to-buffer (url-retrieve-synchronously "http://api.microsofttranslator.com/V2/Ajax.svc/Translate?appId=3C9778666C5BA4B406FFCBEE64EF478963039C51&text=dictionary&to=ja"))
  1435. ;; (switch-to-buffer (url-retrieve-synchronously "http://google.com"))
  1436. (setq ilookup-default "ja")
  1437. (when (locate-library "google-translate")
  1438. (add-to-list 'ilookup-dict-alist
  1439. '("gt" .
  1440. (lambda (word)
  1441. (save-excursion
  1442. (google-translate-translate "auto"
  1443. "ja"
  1444. word))
  1445. (with-current-buffer "*Google Translate*"
  1446. (buffer-substring-no-properties (point-min)
  1447. (point-max)))))))
  1448. ))
  1449. (when (autoload-eval-lazily 'google-translate '(google-translate-translate
  1450. google-translate-at-point))
  1451. (setq google-translate-default-source-language "auto")
  1452. (setq google-translate-default-target-language "ja"))
  1453. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1454. ;; vc
  1455. (require 'vc)
  1456. (setq vc-handled-backends '())
  1457. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1458. ;; gauche-mode
  1459. ;; http://d.hatena.ne.jp/kobapan/20090305/1236261804
  1460. ;; http://www.katch.ne.jp/~leque/software/repos/gauche-mode/gauche-mode.el
  1461. (when (and (fetch-library
  1462. "http://www.katch.ne.jp/~leque/software/repos/gauche-mode/gauche-mode.el"
  1463. t)
  1464. (autoload-eval-lazily 'gauche-mode '(gauche-mode run-scheme)))
  1465. (let ((s (executable-find "gosh")))
  1466. (setq scheme-program-name s
  1467. gauche-program-name s))
  1468. (defun run-gauche-other-window ()
  1469. "Run gauche on other window"
  1470. (interactive)
  1471. (switch-to-buffer-other-window
  1472. (get-buffer-create "*scheme*"))
  1473. (run-gauche))
  1474. (defun run-gauche ()
  1475. "run gauche"
  1476. (interactive)
  1477. (run-scheme gauche-program-name)
  1478. )
  1479. (defun scheme-send-buffer ()
  1480. ""
  1481. (interactive)
  1482. (scheme-send-region (point-min) (point-max))
  1483. (my-scheme-display-scheme-buffer)
  1484. )
  1485. (defun my-scheme-display-scheme-buffer ()
  1486. ""
  1487. (interactive)
  1488. (set-window-text-height (display-buffer scheme-buffer
  1489. t)
  1490. 7))
  1491. (add-hook 'scheme-mode-hook
  1492. (lambda ()
  1493. nil))
  1494. (add-hook 'inferior-scheme-mode-hook
  1495. (lambda ()
  1496. ;; (my-scheme-display-scheme-buffer)
  1497. ))
  1498. (setq auto-mode-alist
  1499. (cons '("\.gosh\\'" . gauche-mode) auto-mode-alist))
  1500. (setq auto-mode-alist
  1501. (cons '("\.gaucherc\\'" . gauche-mode) auto-mode-alist))
  1502. (add-hook 'gauche-mode-hook
  1503. (lambda ()
  1504. (define-key gauche-mode-map
  1505. (kbd "C-c C-z") 'run-gauche-other-window)
  1506. (define-key scheme-mode-map
  1507. (kbd "C-c C-c") 'scheme-send-buffer)
  1508. (define-key scheme-mode-map
  1509. (kbd "C-c C-b") 'my-scheme-display-scheme-buffer))))
  1510. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1511. ;; recentf-mode
  1512. (setq recentf-save-file (expand-file-name (concat user-emacs-directory
  1513. "recentf"))
  1514. recentf-max-menu-items 20
  1515. recentf-max-saved-items 30
  1516. recentf-show-file-shortcuts-flag nil)
  1517. (when (safe-require-or-eval 'recentf)
  1518. (add-to-list 'recentf-exclude
  1519. (regexp-quote recentf-save-file))
  1520. (add-to-list 'recentf-exclude
  1521. (regexp-quote (expand-file-name user-emacs-directory)))
  1522. (define-key ctl-x-map (kbd "C-r") 'recentf-open-files)
  1523. (remove-hook 'find-file-hook
  1524. 'recentf-track-opened-file)
  1525. (defun my-recentf-load-track-save-list ()
  1526. "Load current recentf list from file, track current visiting file, then save
  1527. the list."
  1528. (recentf-load-list)
  1529. (recentf-track-opened-file)
  1530. (recentf-save-list))
  1531. (add-hook 'find-file-hook
  1532. 'my-recentf-load-track-save-list)
  1533. (add-hook 'kill-emacs-hook
  1534. 'recentf-load-list)
  1535. ;;(run-with-idle-timer 5 t 'recentf-save-list)
  1536. ;; (add-hook 'find-file-hook
  1537. ;; (lambda ()
  1538. ;; (recentf-add-file default-directory)))
  1539. (and (fetch-library
  1540. "https://raw.github.com/10sr/emacs-lisp/master/recentf-show.el"
  1541. t)
  1542. (autoload-eval-lazily 'recentf-show)
  1543. (define-key ctl-x-map (kbd "C-r") 'recentf-show)
  1544. (add-hook 'recentf-show-before-listing-hook
  1545. 'recentf-load-list))
  1546. (recentf-mode 1)
  1547. (add-hook 'recentf-dialog-mode-hook
  1548. (lambda ()
  1549. ;; (recentf-save-list)
  1550. ;; (define-key recentf-dialog-mode-map (kbd "C-x C-f")
  1551. ;; 'my-recentf-cd-and-find-file)
  1552. (define-key recentf-dialog-mode-map (kbd "<up>") 'previous-line)
  1553. (define-key recentf-dialog-mode-map (kbd "<down>") 'next-line)
  1554. (define-key recentf-dialog-mode-map "p" 'previous-line)
  1555. (define-key recentf-dialog-mode-map "n" 'next-line)
  1556. (cd "~/"))))
  1557. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1558. ;; dired
  1559. (when (autoload-eval-lazily 'dired nil)
  1560. (defun my-dired-echo-file-head (arg)
  1561. ""
  1562. (interactive "P")
  1563. (let ((f (dired-get-filename)))
  1564. (message "%s"
  1565. (with-temp-buffer
  1566. (insert-file-contents f)
  1567. (buffer-substring-no-properties
  1568. (point-min)
  1569. (progn (goto-line (if arg
  1570. (prefix-numeric-value arg)
  1571. 7))
  1572. (point-at-eol)))))))
  1573. (defun my-dired-diff ()
  1574. ""
  1575. (interactive)
  1576. (let ((files (dired-get-marked-files nil nil nil t)))
  1577. (if (eq (car files)
  1578. t)
  1579. (diff (cadr files) (dired-get-filename))
  1580. (message "One files must be marked!"))))
  1581. (defun my-pop-to-buffer-erase-noselect (buffer-or-name)
  1582. "pop up buffer using `display-buffer' and return that buffer."
  1583. (let ((bf (get-buffer-create buffer-or-name)))
  1584. (with-current-buffer bf
  1585. (cd ".")
  1586. (erase-buffer))
  1587. (display-buffer bf)
  1588. bf))
  1589. (defun my-replace-nasi-none ()
  1590. ""
  1591. (save-excursion
  1592. (let ((buffer-read-only nil))
  1593. (goto-char (point-min))
  1594. (while (search-forward "なし" nil t)
  1595. (replace-match "none")))))
  1596. (defun dired-get-file-info ()
  1597. "dired get file info"
  1598. (interactive)
  1599. (let ((f (shell-quote-argument (dired-get-filename t))))
  1600. (if (file-directory-p f)
  1601. (progn
  1602. (message "Calculating disk usage...")
  1603. (shell-command (concat "du -hsD "
  1604. f)))
  1605. (shell-command (concat "file "
  1606. f)))))
  1607. (defun my-dired-scroll-up ()
  1608. ""
  1609. (interactive)
  1610. (my-dired-previous-line (- (window-height) 1)))
  1611. (defun my-dired-scroll-down ()
  1612. ""
  1613. (interactive)
  1614. (my-dired-next-line (- (window-height) 1)))
  1615. ;; (defun my-dired-forward-line (arg)
  1616. ;; ""
  1617. ;; (interactive "p"))
  1618. (defun my-dired-previous-line (arg)
  1619. ""
  1620. (interactive "p")
  1621. (if (> arg 0)
  1622. (progn
  1623. (if (eq (line-number-at-pos)
  1624. 1)
  1625. (goto-char (point-max))
  1626. (forward-line -1))
  1627. (my-dired-previous-line (if (or (dired-get-filename nil t)
  1628. (dired-get-subdir))
  1629. (- arg 1)
  1630. arg)))
  1631. (dired-move-to-filename)))
  1632. (defun my-dired-next-line (arg)
  1633. ""
  1634. (interactive "p")
  1635. (if (> arg 0)
  1636. (progn
  1637. (if (eq (point)
  1638. (point-max))
  1639. (goto-char (point-min))
  1640. (forward-line 1))
  1641. (my-dired-next-line (if (or (dired-get-filename nil t)
  1642. (dired-get-subdir))
  1643. (- arg 1)
  1644. arg)))
  1645. (dired-move-to-filename)))
  1646. (defun my-dired-print-current-dir-and-file ()
  1647. (message "%s %s"
  1648. default-directory
  1649. (buffer-substring-no-properties (point-at-bol)
  1650. (point-at-eol))))
  1651. (defun dired-do-execute-as-command ()
  1652. ""
  1653. (interactive)
  1654. (let ((file (dired-get-filename t)))
  1655. (if (file-executable-p file)
  1656. (start-process file nil file)
  1657. (when (y-or-n-p
  1658. "This file cant be executed. Mark as executable and go? ")
  1659. (set-file-modes file
  1660. (file-modes-symbolic-to-number "u+x" (file-modes file)))
  1661. (start-process file nil file)))))
  1662. ;;http://bach.istc.kobe-u.ac.jp/lect/tamlab/ubuntu/emacs.html
  1663. (defun my-dired-x-open ()
  1664. ""
  1665. (interactive)
  1666. (my-x-open (dired-get-filename t t)))
  1667. (if (eq window-system 'mac)
  1668. (setq dired-listing-switches "-lhF")
  1669. (setq dired-listing-switches "-lhF --time-style=long-iso")
  1670. )
  1671. (setq dired-listing-switches "-lhF")
  1672. (put 'dired-find-alternate-file 'disabled nil)
  1673. ;; when using dired-find-alternate-file
  1674. ;; reuse current dired buffer for the file to open
  1675. (defvar-set dired-ls-F-marks-symlinks t)
  1676. (when (safe-require-or-eval 'ls-lisp)
  1677. (setq ls-lisp-use-insert-directory-program nil) ; always use ls-lisp
  1678. (setq ls-lisp-dirs-first t)
  1679. (setq ls-lisp-use-localized-time-format t)
  1680. (setq ls-lisp-format-time-list
  1681. '("%Y-%m-%d %H:%M"
  1682. "%Y-%m-%d ")))
  1683. (defvar-set dired-dwim-target t)
  1684. (defvar-set dired-isearch-filenames t)
  1685. (defvar-set dired-hide-details-hide-symlink-targets nil)
  1686. (defvar-set dired-hide-details-hide-information-lines nil)
  1687. ;; (add-hook 'dired-after-readin-hook
  1688. ;; 'my-replace-nasi-none)
  1689. ;; (add-hook 'after-init-hook
  1690. ;; (lambda ()
  1691. ;; (dired ".")))
  1692. (add-hook 'dired-mode-hook
  1693. (lambda ()
  1694. (local-set-key "o" 'my-dired-x-open)
  1695. (local-set-key "i" 'dired-get-file-info)
  1696. (local-set-key "f" 'find-file)
  1697. (local-set-key "!" 'shell-command)
  1698. (local-set-key "&" 'async-shell-command)
  1699. (local-set-key "X" 'dired-do-async-shell-command)
  1700. (local-set-key "=" 'my-dired-diff)
  1701. (local-set-key "B" 'gtkbm-add-current-dir)
  1702. (local-set-key "b" 'gtkbm)
  1703. (local-set-key "h" 'my-dired-echo-file-head)
  1704. (local-set-key "@" (lambda ()
  1705. (interactive) (my-x-open ".")))
  1706. (local-set-key (kbd "TAB") 'other-window)
  1707. ;; (local-set-key "P" 'my-dired-do-pack-or-unpack)
  1708. (local-set-key "/" 'dired-isearch-filenames)
  1709. (local-set-key (kbd "DEL") 'dired-up-directory)
  1710. (local-set-key (kbd "C-h") 'dired-up-directory)
  1711. (substitute-key-definition 'dired-next-line
  1712. 'my-dired-next-line
  1713. (current-local-map))
  1714. (substitute-key-definition 'dired-previous-line
  1715. 'my-dired-previous-line
  1716. (current-local-map))
  1717. ;; (local-set-key (kbd "C-p") 'my-dired-previous-line)
  1718. ;; (local-set-key (kbd "p") 'my-dired-previous-line)
  1719. ;; (local-set-key (kbd "C-n") 'my-dired-next-line)
  1720. ;; (local-set-key (kbd "n") 'my-dired-next-line)
  1721. (local-set-key (kbd "<left>") 'my-dired-scroll-up)
  1722. (local-set-key (kbd "<right>") 'my-dired-scroll-down)
  1723. (local-set-key (kbd "ESC p") 'my-dired-scroll-up)
  1724. (local-set-key (kbd "ESC n") 'my-dired-scroll-down)
  1725. (when (fboundp 'dired-hide-details-mode)
  1726. (dired-hide-details-mode t)
  1727. (local-set-key "l" 'dired-hide-details-mode))
  1728. (let ((file "._Icon\015"))
  1729. (when nil (file-readable-p file)
  1730. (delete-file file)))))
  1731. (and (fetch-library "https://raw.github.com/10sr/emacs-lisp/master/pack.el"
  1732. t)
  1733. (autoload-eval-lazily 'pack '(dired-do-pack-or-unpack pack))
  1734. (add-hook 'dired-mode-hook
  1735. (lambda ()
  1736. (local-set-key "P" 'dired-do-pack-or-unpack))))
  1737. (and (fetch-library
  1738. "https://raw.github.com/10sr/emacs-lisp/master/dired-list-all-mode.el"
  1739. t)
  1740. (autoload-eval-lazily 'dired-list-all-mode)
  1741. (setq dired-listing-switches "-lhF")
  1742. (add-hook 'dired-mode-hook
  1743. (lambda ()
  1744. (local-set-key "a" 'dired-list-all-mode)
  1745. )))
  1746. ) ; when dired locate
  1747. ;; http://blog.livedoor.jp/tek_nishi/archives/4693204.html
  1748. (defvar dired-marker-char)
  1749. (defun my-dired-toggle-mark()
  1750. (let ((cur (cond ((eq (following-char) dired-marker-char) ?\040)
  1751. (t dired-marker-char))))
  1752. (delete-char 1)
  1753. (insert cur)))
  1754. (defun my-dired-mark (arg)
  1755. "Toggle mark the current (or next ARG) files.
  1756. If on a subdir headerline, mark all its files except `.' and `..'.
  1757. Use \\[dired-unmark-all-files] to remove all marks
  1758. and \\[dired-unmark] on a subdir to remove the marks in
  1759. this subdir."
  1760. (interactive "P")
  1761. (if (dired-get-subdir)
  1762. (save-excursion (dired-mark-subdir-files))
  1763. (let ((inhibit-read-only t))
  1764. (dired-repeat-over-lines
  1765. (prefix-numeric-value arg)
  1766. 'my-dired-toggle-mark))))
  1767. (defun my-dired-mark-backward (arg)
  1768. "In Dired, move up lines and toggle mark there.
  1769. Optional prefix ARG says how many lines to unflag; default is one line."
  1770. (interactive "p")
  1771. (my-dired-mark (- arg)))
  1772. (add-hook 'dired-mode-hook
  1773. (lambda ()
  1774. (local-set-key (kbd "SPC") 'my-dired-mark)
  1775. (local-set-key (kbd "S-SPC") 'my-dired-mark-backward))
  1776. )
  1777. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1778. ;; eshell
  1779. (autoload-eval-lazily 'eshell nil
  1780. (defvar-set eshell-banner-message (format "Welcome to the Emacs shell
  1781. %s
  1782. C-x t to toggling emacs-text-mode
  1783. "
  1784. (shell-command-to-string "uname -a")
  1785. ))
  1786. (defvar eshell-text-mode-map
  1787. (let ((map (make-sparse-keymap)))
  1788. (define-key map (kbd "C-x t") 'eshell-text-mode-toggle)
  1789. map))
  1790. (define-derived-mode eshell-text-mode text-mode
  1791. "Eshell-Text"
  1792. "Text-mode for Eshell."
  1793. nil)
  1794. (defun eshell-text-mode-toggle ()
  1795. "Toggle eshell-text-mode and eshell-mode."
  1796. (interactive)
  1797. (cond ((eq major-mode
  1798. 'eshell-text-mode)
  1799. (goto-char (point-max))
  1800. (message "Eshell text mode disabled")
  1801. (eshell-mode))
  1802. ((eq major-mode
  1803. 'eshell-mode)
  1804. (message "Eshell text mode enabled")
  1805. (eshell-write-history)
  1806. (eshell-text-mode))
  1807. (t
  1808. (message "Not in eshell buffer")
  1809. nil)))
  1810. (defun my-eshell-backward-delete-char ()
  1811. (interactive)
  1812. (when (< (save-excursion
  1813. (eshell-bol)
  1814. (point))
  1815. (point))
  1816. (backward-delete-char 1)))
  1817. (defun my-file-owner-p (file)
  1818. "t if FILE is owned by me."
  1819. (eq (user-uid) (nth 2 (file-attributes file))))
  1820. "http://www.bookshelf.jp/pukiwiki/pukiwiki.php\
  1821. ?Eshell%A4%F2%BB%C8%A4%A4%A4%B3%A4%CA%A4%B9"
  1822. ;; ;; written by Stefan Reichoer <reichoer@web.de>
  1823. ;; (defun eshell/less (&rest args)
  1824. ;; "Invoke `view-file' on the file.
  1825. ;; \"less +42 foo\" also goes to line 42 in the buffer."
  1826. ;; (if args
  1827. ;; (while args
  1828. ;; (if (string-match "\\`\\+\\([0-9]+\\)\\'" (car args))
  1829. ;; (let* ((line (string-to-number (match-string 1 (pop args))))
  1830. ;; (file (pop args)))
  1831. ;; (view-file file)
  1832. ;; (goto-line line))
  1833. ;; (view-file (pop args))))))
  1834. (defun eshell/o (&optional file)
  1835. (my-x-open (or file ".")))
  1836. ;; (defun eshell/vi (&rest args)
  1837. ;; "Invoke `find-file' on the file.
  1838. ;; \"vi +42 foo\" also goes to line 42 in the buffer."
  1839. ;; (while args
  1840. ;; (if (string-match "\\`\\+\\([0-9]+\\)\\'" (car args))
  1841. ;; (let* ((line (string-to-number (match-string 1 (pop args))))
  1842. ;; (file (pop args)))
  1843. ;; (find-file file)
  1844. ;; (goto-line line))
  1845. ;; (find-file (pop args)))))
  1846. (defun eshell/clear ()
  1847. "Clear the current buffer, leaving one prompt at the top."
  1848. (interactive)
  1849. (let ((inhibit-read-only t))
  1850. (erase-buffer)))
  1851. (defun eshell-clear ()
  1852. (interactive)
  1853. (let ((inhibit-read-only t))
  1854. (erase-buffer)
  1855. (insert (funcall eshell-prompt-function))))
  1856. (defun eshell/d (&optional dirname switches)
  1857. "if first arg is omitted open current directory."
  1858. (dired (or dirname ".") switches))
  1859. (defun eshell/v ()
  1860. (view-mode 1))
  1861. ;; (defun eshell/aaa (&rest args)
  1862. ;; (message "%S"
  1863. ;; args))
  1864. (defalias 'eshell/: 'ignore)
  1865. (defalias 'eshell/type 'eshell/which)
  1866. ;; (defalias 'eshell/vim 'eshell/vi)
  1867. (defalias 'eshell/ff 'find-file)
  1868. (defalias 'eshell/q 'eshell/exit)
  1869. (defun eshell-goto-prompt ()
  1870. ""
  1871. (interactive)
  1872. (goto-char (point-max)))
  1873. (defun eshell-delete-char-or-logout (n)
  1874. (interactive "p")
  1875. (if (equal (eshell-get-old-input)
  1876. "")
  1877. (progn
  1878. (insert "exit")
  1879. (eshell-send-input))
  1880. (delete-char n)))
  1881. (defun eshell-kill-input ()
  1882. (interactive)
  1883. (delete-region (point)
  1884. (progn (eshell-bol)
  1885. (point))))
  1886. (defalias 'eshell/logout 'eshell/exit)
  1887. (defun eshell-cd-default-directory (&optional eshell-buffer-or-name)
  1888. "open eshell and change wd
  1889. if arg given, use that eshell buffer, otherwise make new eshell buffer."
  1890. (interactive)
  1891. (let ((dir (expand-file-name default-directory)))
  1892. (switch-to-buffer (or eshell-buffer-or-name
  1893. (eshell t)))
  1894. (unless (equal dir (expand-file-name default-directory))
  1895. ;; (cd dir)
  1896. ;; (eshell-interactive-print (concat "cd " dir "\n"))
  1897. ;; (eshell-emit-prompt)
  1898. (goto-char (point-max))
  1899. (eshell-kill-input)
  1900. (insert "cd " dir)
  1901. (eshell-send-input))))
  1902. (defadvice eshell-next-matching-input-from-input
  1903. ;; do not cycle history
  1904. (around eshell-history-do-not-cycle activate)
  1905. (if (= 0
  1906. (or eshell-history-index
  1907. 0))
  1908. (progn
  1909. (delete-region eshell-last-output-end (point))
  1910. (insert-and-inherit eshell-matching-input-from-input-string)
  1911. (setq eshell-history-index nil))
  1912. ad-do-it))
  1913. (defvar-set eshell-directory-name (concat user-emacs-directory
  1914. "eshell/"))
  1915. (defvar-set eshell-term-name "eterm-color")
  1916. (defvar-set eshell-scroll-to-bottom-on-input t)
  1917. (defvar-set eshell-cmpl-ignore-case t)
  1918. (defvar-set eshell-cmpl-cycle-completions nil)
  1919. (defvar-set eshell-highlight-prompt nil)
  1920. (if (eq system-type 'darwin)
  1921. (defvar-set eshell-ls-initial-args '("-hCFG")
  1922. (defvar-set eshell-ls-initial-args '("-hCFG"
  1923. "--color=auto"
  1924. "--time-style=long-iso")) ; "-hF")
  1925. ))
  1926. (defvar-set eshell-prompt-function
  1927. 'my-eshell-prompt-function)
  1928. (defvar eshell-last-command-status)
  1929. (defun my-eshell-prompt-function()
  1930. "Prompt function.
  1931. It looks like:
  1932. :: [10sr@darwin:~/][ESHELL]
  1933. :: $
  1934. "
  1935. (concat ":: ["
  1936. (let ((str (concat user-login-name
  1937. "@"
  1938. (car (split-string system-name
  1939. "\\."))
  1940. )))
  1941. (put-text-property 0
  1942. (length str)
  1943. 'face
  1944. 'underline
  1945. str)
  1946. str)
  1947. ":"
  1948. (let ((str (abbreviate-file-name default-directory)))
  1949. (put-text-property 0
  1950. (length str)
  1951. 'face
  1952. 'underline
  1953. str)
  1954. str)
  1955. "][ESHELL]\n:: "
  1956. (if (eq 0
  1957. eshell-last-command-status)
  1958. ""
  1959. (format "[STATUS:%d] "
  1960. eshell-last-command-status))
  1961. (if (= (user-uid)
  1962. 0)
  1963. "# "
  1964. "$ ")
  1965. ))
  1966. (add-hook 'eshell-mode-hook
  1967. (lambda ()
  1968. ;; (define-key eshell-mode-map (kbd "C-x C-x") (lambda ()
  1969. ;; (interactive)
  1970. ;; (switch-to-buffer (other-buffer))))
  1971. ;; (define-key eshell-mode-map (kbd "C-g") (lambda ()
  1972. ;; (interactive)
  1973. ;; (eshell-goto-prompt)
  1974. ;; (keyboard-quit)))
  1975. (local-set-key (kbd "C-x t") 'eshell-text-mode-toggle)
  1976. (local-set-key (kbd "C-u") 'eshell-kill-input)
  1977. (local-set-key (kbd "C-d") 'eshell-delete-char-or-logout)
  1978. ;; (define-key eshell-mode-map (kbd "C-l")
  1979. ;; 'eshell-clear)
  1980. (local-set-key (kbd "DEL") 'my-eshell-backward-delete-char)
  1981. (local-set-key (kbd "<up>") 'scroll-down-line)
  1982. (local-set-key (kbd "<down>") 'scroll-up-line)
  1983. ;; (define-key eshell-mode-map
  1984. ;; (kbd "C-p") 'eshell-previous-matching-input-from-input)
  1985. ;; (define-key eshell-mode-map
  1986. ;; (kbd "C-n") 'eshell-next-matching-input-from-input)
  1987. (apply 'eshell/addpath exec-path)
  1988. (set (make-local-variable 'scroll-margin) 0)
  1989. ;; (eshell/export "GIT_PAGER=")
  1990. ;; (eshell/export "GIT_EDITOR=")
  1991. (eshell/export "LC_MESSAGES=C")
  1992. (switch-to-buffer (current-buffer)) ; move buffer top of list
  1993. (set (make-local-variable (defvar hl-line-range-function))
  1994. (lambda ()
  1995. '(0 . 0)))
  1996. (defvar eshell-virtual-targets)
  1997. (add-to-list 'eshell-virtual-targets
  1998. '("/dev/less"
  1999. (lambda (str)
  2000. (if str
  2001. (with-current-buffer nil)))
  2002. nil))
  2003. ))
  2004. (add-hook 'eshell-mode-hook
  2005. (lambda ()
  2006. (defvar eshell-visual-commands)
  2007. (defvar eshell-output-filter-functions)
  2008. (defvar eshell-command-aliases-list)
  2009. (add-to-list 'eshell-visual-commands "vim")
  2010. ;; (add-to-list 'eshell-visual-commands "git")
  2011. (add-to-list 'eshell-output-filter-functions
  2012. 'eshell-truncate-buffer)
  2013. (mapcar (lambda (alias)
  2014. (add-to-list 'eshell-command-aliases-list
  2015. alias))
  2016. '(
  2017. ;; ("ll" "ls -l $*")
  2018. ;; ("la" "ls -a $*")
  2019. ;; ("lla" "ls -al $*")
  2020. ("git" "git -c color.ui=always $*")
  2021. ("g" "git $*")
  2022. ("eless"
  2023. (concat "cat >>> (with-current-buffer "
  2024. "(get-buffer-create \"*eshell output\") "
  2025. "(erase-buffer) "
  2026. "(setq buffer-read-only nil) "
  2027. "(current-buffer)) "
  2028. "(view-buffer (get-buffer \"*eshell output*\"))"))
  2029. )
  2030. )))
  2031. ) ; eval after load eshell
  2032. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2033. ;; my-term
  2034. (defvar my-term nil
  2035. "My terminal buffer.")
  2036. (defvar my-term-function nil
  2037. "Function to create terminal buffer.
  2038. This function accept no argument and return newly created buffer of terminal.")
  2039. (defun my-term (&optional arg)
  2040. "Open terminal buffer and return that buffer.
  2041. If ARG is given or called with prefix argument, create new buffer."
  2042. (interactive "P")
  2043. (if (and (not arg)
  2044. my-term
  2045. (buffer-name my-term))
  2046. (pop-to-buffer my-term)
  2047. (setq my-term
  2048. (save-window-excursion
  2049. (funcall my-term-function)))
  2050. (and my-term
  2051. (my-term))))
  2052. ;; (setq my-term-function
  2053. ;; (lambda ()
  2054. ;; (if (eq system-type 'windows-nt)
  2055. ;; (eshell)
  2056. ;; (if (require 'multi-term nil t)
  2057. ;; (multi-term)
  2058. ;; (ansi-term shell-file-name)))))
  2059. (setq my-term-function (lambda () (eshell t)))
  2060. ;;(define-key my-prefix-map (kbd "C-s") 'my-term)
  2061. (define-key ctl-x-map "i" 'my-term)
  2062. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2063. ;; x open
  2064. (defvar my-filer nil)
  2065. (setq my-filer (or (executable-find "pcmanfm")
  2066. (executable-find "nautilus")))
  2067. (defun my-x-open (file)
  2068. "Open FILE."
  2069. (interactive "FOpen File: ")
  2070. (setq file (expand-file-name file))
  2071. (message "Opening %s..." file)
  2072. (cond ((eq system-type 'windows-nt)
  2073. (call-process "cmd.exe" nil 0 nil
  2074. "/c" "start" "" (convert-standard-filename file)))
  2075. ((eq system-type 'darwin)
  2076. (call-process "open" nil 0 nil file))
  2077. ((getenv "DISPLAY")
  2078. (call-process (or my-filer "xdg-open") nil 0 nil file))
  2079. (t
  2080. (find-file file))
  2081. )
  2082. ;; (recentf-add-file file)
  2083. (message "Opening %s...done" file))
  2084. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2085. ;; misc funcs
  2086. (defun my-git-apply-index-from-buffer (&optional buf)
  2087. "Git apply buffer. BUF is buffer to apply. nil to use current buffer."
  2088. (interactive)
  2089. (let ((buf (or buf
  2090. (current-buffer)))
  2091. (file (make-temp-file "git-apply-diff.emacs")))
  2092. (with-current-buffer buf
  2093. (write-region (point-min)
  2094. (point-max)
  2095. file)
  2096. (call-process "git"
  2097. nil
  2098. nil
  2099. nil
  2100. "apply"
  2101. "--cached"
  2102. file))))
  2103. (defun memo (&optional dir)
  2104. "Open memo.txt in DIR."
  2105. (interactive)
  2106. (pop-to-buffer (find-file-noselect (concat (if dir
  2107. (file-name-as-directory dir)
  2108. "")
  2109. "memo.txt"))))
  2110. (defvar my-rgrep-alist
  2111. `(
  2112. ;; the silver searcher
  2113. ("ag"
  2114. (executable-find "ag")
  2115. "ag --nocolor --nogroup --nopager ")
  2116. ;; ack
  2117. ("ack"
  2118. (executable-find "ack")
  2119. "ack --nocolor --nogroup --nopager --with-filename ")
  2120. ;; gnu global
  2121. ("global"
  2122. (and (require 'gtags nil t)
  2123. (executable-find "global")
  2124. (gtags-get-rootpath))
  2125. "global --result grep ")
  2126. ;; git grep
  2127. ("gitgrep"
  2128. (eq 0
  2129. (shell-command "git rev-parse --git-dir"))
  2130. "git --no-pager -c color.grep=false grep -nH -e ")
  2131. ;; grep
  2132. ("grep"
  2133. t
  2134. ,(concat "find . "
  2135. "-path '*/.git' -prune -o "
  2136. "-path '*/.svn' -prune -o "
  2137. "-type f -print0 | "
  2138. "xargs -0 grep -nH -e "))
  2139. )
  2140. "Alist of rgrep command.
  2141. Each element is in the form like (NAME SEXP COMMAND), where SEXP returns the
  2142. condition to choose COMMAND when evaluated.")
  2143. (defvar my-rgrep-default nil
  2144. "Default command name for my-rgrep.")
  2145. (defun my-rgrep-grep-command (&optional name alist)
  2146. "Return recursive grep command for current directory or nil.
  2147. If NAME is given, use that without testing.
  2148. Commands are searched from ALIST."
  2149. (if alist
  2150. (if name
  2151. ;; if name is given search that from alist and return the command
  2152. (nth 2 (assoc name
  2153. alist))
  2154. ;; if name is not given try test in 1th elem
  2155. (let ((car (car alist))
  2156. (cdr (cdr alist)))
  2157. (if (eval (nth 1 car))
  2158. ;; if the condition is true return the command
  2159. (nth 2 car)
  2160. ;; try next one
  2161. (and cdr
  2162. (my-rgrep-grep-command name cdr)))))
  2163. ;; if alist is not given set default value
  2164. (my-rgrep-grep-command name my-rgrep-alist)))
  2165. (defun my-rgrep (command-args)
  2166. "My recursive grep. Run COMMAND-ARGS."
  2167. (interactive (let ((cmd (my-rgrep-grep-command my-rgrep-default
  2168. nil)))
  2169. (if cmd
  2170. (list (read-shell-command "grep command: "
  2171. cmd
  2172. 'grep-find-history))
  2173. (error "My-Rgrep: Command for rgrep not found")
  2174. )))
  2175. (compilation-start command-args
  2176. 'grep-mode))
  2177. ;; (defun my-rgrep-symbol-at-point (command-args)
  2178. ;; "My recursive grep. Run COMMAND-ARGS."
  2179. ;; (interactive (list (read-shell-command "grep command: "
  2180. ;; (concat (my-rgrep-grep-command)
  2181. ;; " "
  2182. ;; (thing-at-point 'symbol))
  2183. ;; 'grep-find-history)))
  2184. ;; (compilation-start command-args
  2185. ;; 'grep-mode))
  2186. (defmacro define-my-rgrep (name)
  2187. "Define rgrep for NAME."
  2188. `(defun ,(intern (concat "my-rgrep-"
  2189. name)) ()
  2190. ,(format "My recursive grep by %s."
  2191. name)
  2192. (interactive)
  2193. (let ((my-rgrep-default ,name))
  2194. (if (called-interactively-p 'any)
  2195. (call-interactively 'my-rgrep)
  2196. (error "Not intended to be called noninteractively. Use `my-rgrep'"))))
  2197. )
  2198. (define-my-rgrep "ack")
  2199. (define-my-rgrep "ag")
  2200. (define-my-rgrep "gitgrep")
  2201. (define-my-rgrep "grep")
  2202. (define-my-rgrep "global")
  2203. (define-key ctl-x-map "s" 'my-rgrep)
  2204. ;; (defun make ()
  2205. ;; "Run \"make -k\" in current directory."
  2206. ;; (interactive)
  2207. ;; (compile "make -k"))
  2208. (defalias 'make 'compile)
  2209. (define-key ctl-x-map "c" 'compile)
  2210. (defvar sed-in-place-history nil
  2211. "History of `sed-in-place'.")
  2212. (defvar sed-in-place-command "sed --in-place=.bak -e")
  2213. (defun sed-in-place (command)
  2214. "Issue sed in place COMMAND."
  2215. (interactive (list (read-shell-command "sed in place: "
  2216. (concat sed-in-place-command " ")
  2217. 'sed-in-place-history)))
  2218. (shell-command command
  2219. "*sed in place*"))
  2220. (defun dired-do-sed-in-place (&optional arg)
  2221. "Issue sed in place dired. If ARG is given, use the next ARG files."
  2222. (interactive "p")
  2223. (require 'dired-aux)
  2224. (let* ((files (dired-get-marked-files t arg))
  2225. (expr (dired-mark-read-string "Run sed-in-place for %s: "
  2226. nil
  2227. 'sed-in-place
  2228. arg
  2229. files)))
  2230. (if (equal expr
  2231. "")
  2232. (error "No expression specified")
  2233. (shell-command (concat sed-in-place-command
  2234. " '"
  2235. expr
  2236. "' "
  2237. (mapconcat 'shell-quote-argument
  2238. files
  2239. " "))
  2240. "*sed in place*"))))
  2241. (defun dir-show (&optional dir)
  2242. "Show DIR list."
  2243. (interactive)
  2244. (let ((bf (get-buffer-create "*dir show*"))
  2245. (list-directory-brief-switches "-C"))
  2246. (with-current-buffer bf
  2247. (list-directory (or nil
  2248. default-directory)
  2249. nil))
  2250. ))
  2251. (defun my-convmv-sjis2utf8-test ()
  2252. "Run `convmv -r -f sjis -t utf8 *'.
  2253. this is test, does not rename files."
  2254. (interactive)
  2255. (shell-command "convmv -r -f sjis -t utf8 *"))
  2256. (defun my-convmv-sjis2utf8-notest ()
  2257. "Run `convmv -r -f sjis -t utf8 * --notest'."
  2258. (interactive)
  2259. (shell-command "convmv -r -f sjis -t utf8 * --notest"))
  2260. (defun kill-ring-save-buffer-file-name ()
  2261. "Get current filename."
  2262. (interactive)
  2263. (let ((file buffer-file-name))
  2264. (if file
  2265. (progn (kill-new file)
  2266. (message file))
  2267. (message "not visiting file."))))
  2268. (defvar kill-ring-buffer-name "*kill-ring*"
  2269. "Buffer name for `kill-ring-buffer'.")
  2270. (defun open-kill-ring-buffer ()
  2271. "Open kill- ring buffer."
  2272. (interactive)
  2273. (pop-to-buffer
  2274. (with-current-buffer (get-buffer-create kill-ring-buffer-name)
  2275. (erase-buffer)
  2276. (yank)
  2277. (text-mode)
  2278. (current-local-map)
  2279. (goto-char (point-min))
  2280. (yank)
  2281. (current-buffer))))
  2282. (defun set-terminal-header (string)
  2283. "Set terminal header STRING."
  2284. (let ((savepos "\033[s")
  2285. (restorepos "\033[u")
  2286. (movecursor "\033[0;%dH")
  2287. (inverse "\033[7m")
  2288. (restorecolor "\033[0m")
  2289. (cols (frame-parameter nil 'width))
  2290. (length (length string)))
  2291. ;; (redraw-frame (selected-frame))
  2292. (send-string-to-terminal (concat savepos
  2293. (format movecursor
  2294. (1+ (- cols length)))
  2295. inverse
  2296. string
  2297. restorecolor
  2298. restorepos))
  2299. ))
  2300. (defun my-set-terminal-header ()
  2301. "Set terminal header."
  2302. (set-terminal-header (concat " "
  2303. user-login-name
  2304. "@"
  2305. (car (split-string system-name
  2306. "\\."))
  2307. " "
  2308. (format-time-string "%Y/%m/%d %T %z")
  2309. " ")))
  2310. ;; (run-with-timer
  2311. ;; 0.1
  2312. ;; 1
  2313. ;; 'my-set-terminal-header)
  2314. ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2315. ;; ;; savage emacs
  2316. ;; ;; when enabled emacs fails to complete
  2317. ;; ;; http://e-arrows.sakura.ne.jp/2010/05/emacs-should-be-more-savage.html
  2318. ;; (defadvice message (before message-for-stupid (arg &rest arg2) activate)
  2319. ;; (setq arg
  2320. ;; (concat arg
  2321. ;; (if (eq nil
  2322. ;; (string-match "\\. *$"
  2323. ;; arg))
  2324. ;; ".")
  2325. ;; " Stupid!")))
  2326. ;; TODO: make these a library
  2327. (defvar info-in-prompt
  2328. nil
  2329. "System info in the form of \"[user@host] \".")
  2330. (setq info-in-prompt
  2331. (concat "["
  2332. user-login-name
  2333. "@"
  2334. (car (split-string system-name
  2335. "\\."))
  2336. "]"))
  2337. (defun my-real-function-subr-p (function)
  2338. "Return t if FUNCTION is a built-in function even if it is advised."
  2339. (let* ((advised (and (symbolp function)
  2340. (featurep 'advice)
  2341. (ad-get-advice-info function)))
  2342. (real-function
  2343. (or (and advised (let ((origname (cdr (assq 'origname advised))))
  2344. (and (fboundp origname)
  2345. origname)))
  2346. function))
  2347. (def (if (symbolp real-function)
  2348. (symbol-function real-function)
  2349. function)))
  2350. (subrp def)))
  2351. ;; (my-real-function-subr-p 'my-real-function-subr-p)
  2352. ;; (defadvice read-from-minibuffer (before info-in-prompt activate)
  2353. ;; "Show system info when use `read-from-minibuffer'."
  2354. ;; (ad-set-arg 0
  2355. ;; (concat my-system-info
  2356. ;; (ad-get-arg 0))))
  2357. ;; (defadvice read-string (before info-in-prompt activate)
  2358. ;; "Show system info when use `read-string'."
  2359. ;; (ad-set-arg 0
  2360. ;; (concat my-system-info
  2361. ;; (ad-get-arg 0))))
  2362. ;; (when (< emacs-major-version 24)
  2363. ;; (defadvice completing-read (before info-in-prompt activate)
  2364. ;; "Show system info when use `completing-read'."
  2365. ;; (ad-set-arg 0
  2366. ;; (concat my-system-info
  2367. ;; (ad-get-arg 0)))))
  2368. (defmacro info-in-prompt-set (&rest functions)
  2369. "Set info-in-prompt advices for FUNCTIONS."
  2370. `(progn
  2371. ,@(mapcar (lambda (f)
  2372. `(defadvice ,f (before info-in-prompt activate)
  2373. "Show info in prompt."
  2374. (let ((orig (ad-get-arg 0)))
  2375. (unless (string-match-p (regexp-quote info-in-prompt)
  2376. orig)
  2377. (ad-set-arg 0
  2378. (concat info-in-prompt
  2379. " "
  2380. orig))))))
  2381. functions)))
  2382. (info-in-prompt-set read-from-minibuffer
  2383. read-string
  2384. completing-read)
  2385. ;;; emacs.el ends here