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.
 
 
 
 
 
 

2722 regels
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. (run-scheme gauche-program-name)
  1477. )
  1478. (defun scheme-send-buffer ()
  1479. ""
  1480. (interactive)
  1481. (scheme-send-region (point-min) (point-max))
  1482. (my-scheme-display-scheme-buffer)
  1483. )
  1484. (defun my-scheme-display-scheme-buffer ()
  1485. ""
  1486. (interactive)
  1487. (set-window-text-height (display-buffer scheme-buffer
  1488. t)
  1489. 7))
  1490. (add-hook 'scheme-mode-hook
  1491. (lambda ()
  1492. nil))
  1493. (add-hook 'inferior-scheme-mode-hook
  1494. (lambda ()
  1495. ;; (my-scheme-display-scheme-buffer)
  1496. ))
  1497. (setq auto-mode-alist
  1498. (cons '("\.gosh\\'" . gauche-mode) auto-mode-alist))
  1499. (setq auto-mode-alist
  1500. (cons '("\.gaucherc\\'" . gauche-mode) auto-mode-alist))
  1501. (add-hook 'gauche-mode-hook
  1502. (lambda ()
  1503. (define-key gauche-mode-map
  1504. (kbd "C-c C-z") 'run-gauche-other-window)
  1505. (define-key scheme-mode-map
  1506. (kbd "C-c C-c") 'scheme-send-buffer)
  1507. (define-key scheme-mode-map
  1508. (kbd "C-c C-b") 'my-scheme-display-scheme-buffer))))
  1509. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1510. ;; recentf-mode
  1511. (setq recentf-save-file (expand-file-name (concat user-emacs-directory
  1512. "recentf"))
  1513. recentf-max-menu-items 20
  1514. recentf-max-saved-items 30
  1515. recentf-show-file-shortcuts-flag nil)
  1516. (when (safe-require-or-eval 'recentf)
  1517. (add-to-list 'recentf-exclude
  1518. (regexp-quote recentf-save-file))
  1519. (add-to-list 'recentf-exclude
  1520. (regexp-quote (expand-file-name user-emacs-directory)))
  1521. (define-key ctl-x-map (kbd "C-r") 'recentf-open-files)
  1522. (remove-hook 'find-file-hook
  1523. 'recentf-track-opened-file)
  1524. (defun my-recentf-load-track-save-list ()
  1525. "Load current recentf list from file, track current visiting file, then save
  1526. the list."
  1527. (recentf-load-list)
  1528. (recentf-track-opened-file)
  1529. (recentf-save-list))
  1530. (add-hook 'find-file-hook
  1531. 'my-recentf-load-track-save-list)
  1532. (add-hook 'kill-emacs-hook
  1533. 'recentf-load-list)
  1534. ;;(run-with-idle-timer 5 t 'recentf-save-list)
  1535. ;; (add-hook 'find-file-hook
  1536. ;; (lambda ()
  1537. ;; (recentf-add-file default-directory)))
  1538. (and (fetch-library
  1539. "https://raw.github.com/10sr/emacs-lisp/master/recentf-show.el"
  1540. t)
  1541. (autoload-eval-lazily 'recentf-show)
  1542. (define-key ctl-x-map (kbd "C-r") 'recentf-show)
  1543. (add-hook 'recentf-show-before-listing-hook
  1544. 'recentf-load-list))
  1545. (recentf-mode 1)
  1546. (add-hook 'recentf-dialog-mode-hook
  1547. (lambda ()
  1548. ;; (recentf-save-list)
  1549. ;; (define-key recentf-dialog-mode-map (kbd "C-x C-f")
  1550. ;; 'my-recentf-cd-and-find-file)
  1551. (define-key recentf-dialog-mode-map (kbd "<up>") 'previous-line)
  1552. (define-key recentf-dialog-mode-map (kbd "<down>") 'next-line)
  1553. (define-key recentf-dialog-mode-map "p" 'previous-line)
  1554. (define-key recentf-dialog-mode-map "n" 'next-line)
  1555. (cd "~/"))))
  1556. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1557. ;; dired
  1558. (when (autoload-eval-lazily 'dired nil)
  1559. (defun my-dired-echo-file-head (arg)
  1560. ""
  1561. (interactive "P")
  1562. (let ((f (dired-get-filename)))
  1563. (message "%s"
  1564. (with-temp-buffer
  1565. (insert-file-contents f)
  1566. (buffer-substring-no-properties
  1567. (point-min)
  1568. (progn (goto-line (if arg
  1569. (prefix-numeric-value arg)
  1570. 7))
  1571. (point-at-eol)))))))
  1572. (defun my-dired-diff ()
  1573. ""
  1574. (interactive)
  1575. (let ((files (dired-get-marked-files nil nil nil t)))
  1576. (if (eq (car files)
  1577. t)
  1578. (diff (cadr files) (dired-get-filename))
  1579. (message "One files must be marked!"))))
  1580. (defun my-pop-to-buffer-erase-noselect (buffer-or-name)
  1581. "pop up buffer using `display-buffer' and return that buffer."
  1582. (let ((bf (get-buffer-create buffer-or-name)))
  1583. (with-current-buffer bf
  1584. (cd ".")
  1585. (erase-buffer))
  1586. (display-buffer bf)
  1587. bf))
  1588. (defun my-replace-nasi-none ()
  1589. ""
  1590. (save-excursion
  1591. (let ((buffer-read-only nil))
  1592. (goto-char (point-min))
  1593. (while (search-forward "なし" nil t)
  1594. (replace-match "none")))))
  1595. (defun dired-get-file-info ()
  1596. "dired get file info"
  1597. (interactive)
  1598. (let ((f (shell-quote-argument (dired-get-filename t))))
  1599. (if (file-directory-p f)
  1600. (progn
  1601. (message "Calculating disk usage...")
  1602. (shell-command (concat "du -hsD "
  1603. f)))
  1604. (shell-command (concat "file "
  1605. f)))))
  1606. (defun my-dired-scroll-up ()
  1607. ""
  1608. (interactive)
  1609. (my-dired-previous-line (- (window-height) 1)))
  1610. (defun my-dired-scroll-down ()
  1611. ""
  1612. (interactive)
  1613. (my-dired-next-line (- (window-height) 1)))
  1614. ;; (defun my-dired-forward-line (arg)
  1615. ;; ""
  1616. ;; (interactive "p"))
  1617. (defun my-dired-previous-line (arg)
  1618. ""
  1619. (interactive "p")
  1620. (if (> arg 0)
  1621. (progn
  1622. (if (eq (line-number-at-pos)
  1623. 1)
  1624. (goto-char (point-max))
  1625. (forward-line -1))
  1626. (my-dired-previous-line (if (or (dired-get-filename nil t)
  1627. (dired-get-subdir))
  1628. (- arg 1)
  1629. arg)))
  1630. (dired-move-to-filename)))
  1631. (defun my-dired-next-line (arg)
  1632. ""
  1633. (interactive "p")
  1634. (if (> arg 0)
  1635. (progn
  1636. (if (eq (point)
  1637. (point-max))
  1638. (goto-char (point-min))
  1639. (forward-line 1))
  1640. (my-dired-next-line (if (or (dired-get-filename nil t)
  1641. (dired-get-subdir))
  1642. (- arg 1)
  1643. arg)))
  1644. (dired-move-to-filename)))
  1645. (defun my-dired-print-current-dir-and-file ()
  1646. (message "%s %s"
  1647. default-directory
  1648. (buffer-substring-no-properties (point-at-bol)
  1649. (point-at-eol))))
  1650. (defun dired-do-execute-as-command ()
  1651. ""
  1652. (interactive)
  1653. (let ((file (dired-get-filename t)))
  1654. (if (file-executable-p file)
  1655. (start-process file nil file)
  1656. (when (y-or-n-p
  1657. "This file cant be executed. Mark as executable and go? ")
  1658. (set-file-modes file
  1659. (file-modes-symbolic-to-number "u+x" (file-modes file)))
  1660. (start-process file nil file)))))
  1661. ;;http://bach.istc.kobe-u.ac.jp/lect/tamlab/ubuntu/emacs.html
  1662. (defun my-dired-x-open ()
  1663. ""
  1664. (interactive)
  1665. (my-x-open (dired-get-filename t t)))
  1666. (if (eq window-system 'mac)
  1667. (setq dired-listing-switches "-lhF")
  1668. (setq dired-listing-switches "-lhF --time-style=long-iso")
  1669. )
  1670. (setq dired-listing-switches "-lhF")
  1671. (put 'dired-find-alternate-file 'disabled nil)
  1672. ;; when using dired-find-alternate-file
  1673. ;; reuse current dired buffer for the file to open
  1674. (defvar-set dired-ls-F-marks-symlinks t)
  1675. (when (safe-require-or-eval 'ls-lisp)
  1676. (setq ls-lisp-use-insert-directory-program nil) ; always use ls-lisp
  1677. (setq ls-lisp-dirs-first t)
  1678. (setq ls-lisp-use-localized-time-format t)
  1679. (setq ls-lisp-format-time-list
  1680. '("%Y-%m-%d %H:%M"
  1681. "%Y-%m-%d ")))
  1682. (defvar-set dired-dwim-target t)
  1683. (defvar-set dired-isearch-filenames t)
  1684. (defvar-set dired-hide-details-hide-symlink-targets nil)
  1685. (defvar-set dired-hide-details-hide-information-lines nil)
  1686. ;; (add-hook 'dired-after-readin-hook
  1687. ;; 'my-replace-nasi-none)
  1688. ;; (add-hook 'after-init-hook
  1689. ;; (lambda ()
  1690. ;; (dired ".")))
  1691. (add-hook 'dired-mode-hook
  1692. (lambda ()
  1693. (local-set-key "o" 'my-dired-x-open)
  1694. (local-set-key "i" 'dired-get-file-info)
  1695. (local-set-key "f" 'find-file)
  1696. (local-set-key "!" 'shell-command)
  1697. (local-set-key "&" 'async-shell-command)
  1698. (local-set-key "X" 'dired-do-async-shell-command)
  1699. (local-set-key "=" 'my-dired-diff)
  1700. (local-set-key "B" 'gtkbm-add-current-dir)
  1701. (local-set-key "b" 'gtkbm)
  1702. (local-set-key "h" 'my-dired-echo-file-head)
  1703. (local-set-key "@" (lambda ()
  1704. (interactive) (my-x-open ".")))
  1705. (local-set-key (kbd "TAB") 'other-window)
  1706. ;; (local-set-key "P" 'my-dired-do-pack-or-unpack)
  1707. (local-set-key "/" 'dired-isearch-filenames)
  1708. (local-set-key (kbd "DEL") 'dired-up-directory)
  1709. (local-set-key (kbd "C-h") 'dired-up-directory)
  1710. (substitute-key-definition 'dired-next-line
  1711. 'my-dired-next-line
  1712. (current-local-map))
  1713. (substitute-key-definition 'dired-previous-line
  1714. 'my-dired-previous-line
  1715. (current-local-map))
  1716. ;; (local-set-key (kbd "C-p") 'my-dired-previous-line)
  1717. ;; (local-set-key (kbd "p") 'my-dired-previous-line)
  1718. ;; (local-set-key (kbd "C-n") 'my-dired-next-line)
  1719. ;; (local-set-key (kbd "n") 'my-dired-next-line)
  1720. (local-set-key (kbd "<left>") 'my-dired-scroll-up)
  1721. (local-set-key (kbd "<right>") 'my-dired-scroll-down)
  1722. (local-set-key (kbd "ESC p") 'my-dired-scroll-up)
  1723. (local-set-key (kbd "ESC n") 'my-dired-scroll-down)
  1724. (when (fboundp 'dired-hide-details-mode)
  1725. (dired-hide-details-mode t)
  1726. (local-set-key "l" 'dired-hide-details-mode))
  1727. (let ((file "._Icon\015"))
  1728. (when nil (file-readable-p file)
  1729. (delete-file file)))))
  1730. (and (fetch-library "https://raw.github.com/10sr/emacs-lisp/master/pack.el"
  1731. t)
  1732. (autoload-eval-lazily 'pack '(dired-do-pack-or-unpack pack))
  1733. (add-hook 'dired-mode-hook
  1734. (lambda ()
  1735. (local-set-key "P" 'dired-do-pack-or-unpack))))
  1736. (and (fetch-library
  1737. "https://raw.github.com/10sr/emacs-lisp/master/dired-list-all-mode.el"
  1738. t)
  1739. (autoload-eval-lazily 'dired-list-all-mode)
  1740. (setq dired-listing-switches "-lhF")
  1741. (add-hook 'dired-mode-hook
  1742. (lambda ()
  1743. (local-set-key "a" 'dired-list-all-mode)
  1744. )))
  1745. ) ; when dired locate
  1746. ;; http://blog.livedoor.jp/tek_nishi/archives/4693204.html
  1747. (defvar dired-marker-char)
  1748. (defun my-dired-toggle-mark()
  1749. (let ((cur (cond ((eq (following-char) dired-marker-char) ?\040)
  1750. (t dired-marker-char))))
  1751. (delete-char 1)
  1752. (insert cur)))
  1753. (defun my-dired-mark (arg)
  1754. "Toggle mark the current (or next ARG) files.
  1755. If on a subdir headerline, mark all its files except `.' and `..'.
  1756. Use \\[dired-unmark-all-files] to remove all marks
  1757. and \\[dired-unmark] on a subdir to remove the marks in
  1758. this subdir."
  1759. (interactive "P")
  1760. (if (dired-get-subdir)
  1761. (save-excursion (dired-mark-subdir-files))
  1762. (let ((inhibit-read-only t))
  1763. (dired-repeat-over-lines
  1764. (prefix-numeric-value arg)
  1765. 'my-dired-toggle-mark))))
  1766. (defun my-dired-mark-backward (arg)
  1767. "In Dired, move up lines and toggle mark there.
  1768. Optional prefix ARG says how many lines to unflag; default is one line."
  1769. (interactive "p")
  1770. (my-dired-mark (- arg)))
  1771. (add-hook 'dired-mode-hook
  1772. (lambda ()
  1773. (local-set-key (kbd "SPC") 'my-dired-mark)
  1774. (local-set-key (kbd "S-SPC") 'my-dired-mark-backward))
  1775. )
  1776. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1777. ;; eshell
  1778. (autoload-eval-lazily 'eshell nil
  1779. (defvar-set eshell-banner-message (format "Welcome to the Emacs shell
  1780. %s
  1781. C-x t to toggling emacs-text-mode
  1782. "
  1783. (shell-command-to-string "uname -a")
  1784. ))
  1785. (defvar eshell-text-mode-map
  1786. (let ((map (make-sparse-keymap)))
  1787. (define-key map (kbd "C-x t") 'eshell-text-mode-toggle)
  1788. map))
  1789. (define-derived-mode eshell-text-mode text-mode
  1790. "Eshell-Text"
  1791. "Text-mode for Eshell."
  1792. nil)
  1793. (defun eshell-text-mode-toggle ()
  1794. "Toggle eshell-text-mode and eshell-mode."
  1795. (interactive)
  1796. (cond ((eq major-mode
  1797. 'eshell-text-mode)
  1798. (goto-char (point-max))
  1799. (message "Eshell text mode disabled")
  1800. (eshell-mode))
  1801. ((eq major-mode
  1802. 'eshell-mode)
  1803. (message "Eshell text mode enabled")
  1804. (eshell-write-history)
  1805. (eshell-text-mode))
  1806. (t
  1807. (message "Not in eshell buffer")
  1808. nil)))
  1809. (defun my-eshell-backward-delete-char ()
  1810. (interactive)
  1811. (when (< (save-excursion
  1812. (eshell-bol)
  1813. (point))
  1814. (point))
  1815. (backward-delete-char 1)))
  1816. (defun my-file-owner-p (file)
  1817. "t if FILE is owned by me."
  1818. (eq (user-uid) (nth 2 (file-attributes file))))
  1819. "http://www.bookshelf.jp/pukiwiki/pukiwiki.php\
  1820. ?Eshell%A4%F2%BB%C8%A4%A4%A4%B3%A4%CA%A4%B9"
  1821. ;; ;; written by Stefan Reichoer <reichoer@web.de>
  1822. ;; (defun eshell/less (&rest args)
  1823. ;; "Invoke `view-file' on the file.
  1824. ;; \"less +42 foo\" also goes to line 42 in the buffer."
  1825. ;; (if args
  1826. ;; (while args
  1827. ;; (if (string-match "\\`\\+\\([0-9]+\\)\\'" (car args))
  1828. ;; (let* ((line (string-to-number (match-string 1 (pop args))))
  1829. ;; (file (pop args)))
  1830. ;; (view-file file)
  1831. ;; (goto-line line))
  1832. ;; (view-file (pop args))))))
  1833. (defun eshell/o (&optional file)
  1834. (my-x-open (or file ".")))
  1835. ;; (defun eshell/vi (&rest args)
  1836. ;; "Invoke `find-file' on the file.
  1837. ;; \"vi +42 foo\" also goes to line 42 in the buffer."
  1838. ;; (while args
  1839. ;; (if (string-match "\\`\\+\\([0-9]+\\)\\'" (car args))
  1840. ;; (let* ((line (string-to-number (match-string 1 (pop args))))
  1841. ;; (file (pop args)))
  1842. ;; (find-file file)
  1843. ;; (goto-line line))
  1844. ;; (find-file (pop args)))))
  1845. (defun eshell/clear ()
  1846. "Clear the current buffer, leaving one prompt at the top."
  1847. (interactive)
  1848. (let ((inhibit-read-only t))
  1849. (erase-buffer)))
  1850. (defun eshell-clear ()
  1851. (interactive)
  1852. (let ((inhibit-read-only t))
  1853. (erase-buffer)
  1854. (insert (funcall eshell-prompt-function))))
  1855. (defun eshell/d (&optional dirname switches)
  1856. "if first arg is omitted open current directory."
  1857. (dired (or dirname ".") switches))
  1858. (defun eshell/v ()
  1859. (view-mode 1))
  1860. ;; (defun eshell/aaa (&rest args)
  1861. ;; (message "%S"
  1862. ;; args))
  1863. (defalias 'eshell/: 'ignore)
  1864. (defalias 'eshell/type 'eshell/which)
  1865. ;; (defalias 'eshell/vim 'eshell/vi)
  1866. (defalias 'eshell/ff 'find-file)
  1867. (defalias 'eshell/q 'eshell/exit)
  1868. (defun eshell-goto-prompt ()
  1869. ""
  1870. (interactive)
  1871. (goto-char (point-max)))
  1872. (defun eshell-delete-char-or-logout (n)
  1873. (interactive "p")
  1874. (if (equal (eshell-get-old-input)
  1875. "")
  1876. (progn
  1877. (insert "exit")
  1878. (eshell-send-input))
  1879. (delete-char n)))
  1880. (defun eshell-kill-input ()
  1881. (interactive)
  1882. (delete-region (point)
  1883. (progn (eshell-bol)
  1884. (point))))
  1885. (defalias 'eshell/logout 'eshell/exit)
  1886. (defun eshell-cd-default-directory (&optional eshell-buffer-or-name)
  1887. "open eshell and change wd
  1888. if arg given, use that eshell buffer, otherwise make new eshell buffer."
  1889. (interactive)
  1890. (let ((dir (expand-file-name default-directory)))
  1891. (switch-to-buffer (or eshell-buffer-or-name
  1892. (eshell t)))
  1893. (unless (equal dir (expand-file-name default-directory))
  1894. ;; (cd dir)
  1895. ;; (eshell-interactive-print (concat "cd " dir "\n"))
  1896. ;; (eshell-emit-prompt)
  1897. (goto-char (point-max))
  1898. (eshell-kill-input)
  1899. (insert "cd " dir)
  1900. (eshell-send-input))))
  1901. (defadvice eshell-next-matching-input-from-input
  1902. ;; do not cycle history
  1903. (around eshell-history-do-not-cycle activate)
  1904. (if (= 0
  1905. (or eshell-history-index
  1906. 0))
  1907. (progn
  1908. (delete-region eshell-last-output-end (point))
  1909. (insert-and-inherit eshell-matching-input-from-input-string)
  1910. (setq eshell-history-index nil))
  1911. ad-do-it))
  1912. (defvar-set eshell-directory-name (concat user-emacs-directory
  1913. "eshell/"))
  1914. (defvar-set eshell-term-name "eterm-color")
  1915. (defvar-set eshell-scroll-to-bottom-on-input t)
  1916. (defvar-set eshell-cmpl-ignore-case t)
  1917. (defvar-set eshell-cmpl-cycle-completions nil)
  1918. (defvar-set eshell-highlight-prompt nil)
  1919. (if (eq system-type 'darwin)
  1920. (defvar-set eshell-ls-initial-args '("-hCFG")
  1921. (defvar-set eshell-ls-initial-args '("-hCFG"
  1922. "--color=auto"
  1923. "--time-style=long-iso")) ; "-hF")
  1924. ))
  1925. (defvar-set eshell-prompt-function
  1926. 'my-eshell-prompt-function)
  1927. (defvar eshell-last-command-status)
  1928. (defun my-eshell-prompt-function()
  1929. "Prompt function.
  1930. It looks like:
  1931. :: [10sr@darwin:~/][ESHELL]
  1932. :: $
  1933. "
  1934. (concat ":: ["
  1935. (let ((str (concat user-login-name
  1936. "@"
  1937. (car (split-string system-name
  1938. "\\."))
  1939. )))
  1940. (put-text-property 0
  1941. (length str)
  1942. 'face
  1943. 'underline
  1944. str)
  1945. str)
  1946. ":"
  1947. (let ((str (abbreviate-file-name default-directory)))
  1948. (put-text-property 0
  1949. (length str)
  1950. 'face
  1951. 'underline
  1952. str)
  1953. str)
  1954. "][ESHELL]\n:: "
  1955. (if (eq 0
  1956. eshell-last-command-status)
  1957. ""
  1958. (format "[STATUS:%d] "
  1959. eshell-last-command-status))
  1960. (if (= (user-uid)
  1961. 0)
  1962. "# "
  1963. "$ ")
  1964. ))
  1965. (add-hook 'eshell-mode-hook
  1966. (lambda ()
  1967. ;; (define-key eshell-mode-map (kbd "C-x C-x") (lambda ()
  1968. ;; (interactive)
  1969. ;; (switch-to-buffer (other-buffer))))
  1970. ;; (define-key eshell-mode-map (kbd "C-g") (lambda ()
  1971. ;; (interactive)
  1972. ;; (eshell-goto-prompt)
  1973. ;; (keyboard-quit)))
  1974. (local-set-key (kbd "C-x t") 'eshell-text-mode-toggle)
  1975. (local-set-key (kbd "C-u") 'eshell-kill-input)
  1976. (local-set-key (kbd "C-d") 'eshell-delete-char-or-logout)
  1977. ;; (define-key eshell-mode-map (kbd "C-l")
  1978. ;; 'eshell-clear)
  1979. (local-set-key (kbd "DEL") 'my-eshell-backward-delete-char)
  1980. (local-set-key (kbd "<up>") 'scroll-down-line)
  1981. (local-set-key (kbd "<down>") 'scroll-up-line)
  1982. ;; (define-key eshell-mode-map
  1983. ;; (kbd "C-p") 'eshell-previous-matching-input-from-input)
  1984. ;; (define-key eshell-mode-map
  1985. ;; (kbd "C-n") 'eshell-next-matching-input-from-input)
  1986. (apply 'eshell/addpath exec-path)
  1987. (set (make-local-variable 'scroll-margin) 0)
  1988. ;; (eshell/export "GIT_PAGER=")
  1989. ;; (eshell/export "GIT_EDITOR=")
  1990. (eshell/export "LC_MESSAGES=C")
  1991. (switch-to-buffer (current-buffer)) ; move buffer top of list
  1992. (set (make-local-variable (defvar hl-line-range-function))
  1993. (lambda ()
  1994. '(0 . 0)))
  1995. (defvar eshell-virtual-targets)
  1996. (add-to-list 'eshell-virtual-targets
  1997. '("/dev/less"
  1998. (lambda (str)
  1999. (if str
  2000. (with-current-buffer nil)))
  2001. nil))
  2002. ))
  2003. (add-hook 'eshell-mode-hook
  2004. (lambda ()
  2005. (defvar eshell-visual-commands)
  2006. (defvar eshell-output-filter-functions)
  2007. (defvar eshell-command-aliases-list)
  2008. (add-to-list 'eshell-visual-commands "vim")
  2009. ;; (add-to-list 'eshell-visual-commands "git")
  2010. (add-to-list 'eshell-output-filter-functions
  2011. 'eshell-truncate-buffer)
  2012. (mapcar (lambda (alias)
  2013. (add-to-list 'eshell-command-aliases-list
  2014. alias))
  2015. '(
  2016. ;; ("ll" "ls -l $*")
  2017. ;; ("la" "ls -a $*")
  2018. ;; ("lla" "ls -al $*")
  2019. ("git" "git -c color.ui=always $*")
  2020. ("g" "git $*")
  2021. ("eless"
  2022. (concat "cat >>> (with-current-buffer "
  2023. "(get-buffer-create \"*eshell output\") "
  2024. "(erase-buffer) "
  2025. "(setq buffer-read-only nil) "
  2026. "(current-buffer)) "
  2027. "(view-buffer (get-buffer \"*eshell output*\"))"))
  2028. )
  2029. )))
  2030. ) ; eval after load eshell
  2031. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2032. ;; my-term
  2033. (defvar my-term nil
  2034. "My terminal buffer.")
  2035. (defvar my-term-function nil
  2036. "Function to create terminal buffer.
  2037. This function accept no argument and return newly created buffer of terminal.")
  2038. (defun my-term (&optional arg)
  2039. "Open terminal buffer and return that buffer.
  2040. If ARG is given or called with prefix argument, create new buffer."
  2041. (interactive "P")
  2042. (if (and (not arg)
  2043. my-term
  2044. (buffer-name my-term))
  2045. (pop-to-buffer my-term)
  2046. (setq my-term
  2047. (save-window-excursion
  2048. (funcall my-term-function)))
  2049. (and my-term
  2050. (my-term))))
  2051. ;; (setq my-term-function
  2052. ;; (lambda ()
  2053. ;; (if (eq system-type 'windows-nt)
  2054. ;; (eshell)
  2055. ;; (if (require 'multi-term nil t)
  2056. ;; (multi-term)
  2057. ;; (ansi-term shell-file-name)))))
  2058. (setq my-term-function (lambda () (eshell t)))
  2059. ;;(define-key my-prefix-map (kbd "C-s") 'my-term)
  2060. (define-key ctl-x-map "i" 'my-term)
  2061. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2062. ;; x open
  2063. (defvar my-filer nil)
  2064. (setq my-filer (or (executable-find "pcmanfm")
  2065. (executable-find "nautilus")))
  2066. (defun my-x-open (file)
  2067. "Open FILE."
  2068. (interactive "FOpen File: ")
  2069. (setq file (expand-file-name file))
  2070. (message "Opening %s..." file)
  2071. (cond ((eq system-type 'windows-nt)
  2072. (call-process "cmd.exe" nil 0 nil
  2073. "/c" "start" "" (convert-standard-filename file)))
  2074. ((eq system-type 'darwin)
  2075. (call-process "open" nil 0 nil file))
  2076. ((getenv "DISPLAY")
  2077. (call-process (or my-filer "xdg-open") nil 0 nil file))
  2078. (t
  2079. (find-file file))
  2080. )
  2081. ;; (recentf-add-file file)
  2082. (message "Opening %s...done" file))
  2083. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2084. ;; misc funcs
  2085. (defun my-git-apply-index-from-buffer (&optional buf)
  2086. "Git apply buffer. BUF is buffer to apply. nil to use current buffer."
  2087. (interactive)
  2088. (let ((buf (or buf
  2089. (current-buffer)))
  2090. (file (make-temp-file "git-apply-diff.emacs")))
  2091. (with-current-buffer buf
  2092. (write-region (point-min)
  2093. (point-max)
  2094. file)
  2095. (call-process "git"
  2096. nil
  2097. nil
  2098. nil
  2099. "apply"
  2100. "--cached"
  2101. file))))
  2102. (defun memo (&optional dir)
  2103. "Open memo.txt in DIR."
  2104. (interactive)
  2105. (pop-to-buffer (find-file-noselect (concat (if dir
  2106. (file-name-as-directory dir)
  2107. "")
  2108. "memo.txt"))))
  2109. (defvar my-rgrep-alist
  2110. `(
  2111. ;; the silver searcher
  2112. ("ag"
  2113. (executable-find "ag")
  2114. "ag --nocolor --nogroup --nopager ")
  2115. ;; ack
  2116. ("ack"
  2117. (executable-find "ack")
  2118. "ack --nocolor --nogroup --nopager --with-filename ")
  2119. ;; gnu global
  2120. ("global"
  2121. (and (require 'gtags nil t)
  2122. (executable-find "global")
  2123. (gtags-get-rootpath))
  2124. "global --result grep ")
  2125. ;; git grep
  2126. ("gitgrep"
  2127. (eq 0
  2128. (shell-command "git rev-parse --git-dir"))
  2129. "git --no-pager -c color.grep=false grep -nH -e ")
  2130. ;; grep
  2131. ("grep"
  2132. t
  2133. ,(concat "find . "
  2134. "-path '*/.git' -prune -o "
  2135. "-path '*/.svn' -prune -o "
  2136. "-type f -print0 | "
  2137. "xargs -0 grep -nH -e "))
  2138. )
  2139. "Alist of rgrep command.
  2140. Each element is in the form like (NAME SEXP COMMAND), where SEXP returns the
  2141. condition to choose COMMAND when evaluated.")
  2142. (defvar my-rgrep-default nil
  2143. "Default command name for my-rgrep.")
  2144. (defun my-rgrep-grep-command (&optional name alist)
  2145. "Return recursive grep command for current directory or nil.
  2146. If NAME is given, use that without testing.
  2147. Commands are searched from ALIST."
  2148. (if alist
  2149. (if name
  2150. ;; if name is given search that from alist and return the command
  2151. (nth 2 (assoc name
  2152. alist))
  2153. ;; if name is not given try test in 1th elem
  2154. (let ((car (car alist))
  2155. (cdr (cdr alist)))
  2156. (if (eval (nth 1 car))
  2157. ;; if the condition is true return the command
  2158. (nth 2 car)
  2159. ;; try next one
  2160. (and cdr
  2161. (my-rgrep-grep-command name cdr)))))
  2162. ;; if alist is not given set default value
  2163. (my-rgrep-grep-command name my-rgrep-alist)))
  2164. (defun my-rgrep (command-args)
  2165. "My recursive grep. Run COMMAND-ARGS."
  2166. (interactive (let ((cmd (my-rgrep-grep-command my-rgrep-default
  2167. nil)))
  2168. (if cmd
  2169. (list (read-shell-command "grep command: "
  2170. cmd
  2171. 'grep-find-history))
  2172. (error "My-Rgrep: Command for rgrep not found")
  2173. )))
  2174. (compilation-start command-args
  2175. 'grep-mode))
  2176. ;; (defun my-rgrep-symbol-at-point (command-args)
  2177. ;; "My recursive grep. Run COMMAND-ARGS."
  2178. ;; (interactive (list (read-shell-command "grep command: "
  2179. ;; (concat (my-rgrep-grep-command)
  2180. ;; " "
  2181. ;; (thing-at-point 'symbol))
  2182. ;; 'grep-find-history)))
  2183. ;; (compilation-start command-args
  2184. ;; 'grep-mode))
  2185. (defmacro define-my-rgrep (name)
  2186. "Define rgrep for NAME."
  2187. `(defun ,(intern (concat "my-rgrep-"
  2188. name)) ()
  2189. ,(format "My recursive grep by %s."
  2190. name)
  2191. (interactive)
  2192. (let ((my-rgrep-default ,name))
  2193. (if (called-interactively-p 'any)
  2194. (call-interactively 'my-rgrep)
  2195. (error "Not intended to be called noninteractively. Use `my-rgrep'"))))
  2196. )
  2197. (define-my-rgrep "ack")
  2198. (define-my-rgrep "ag")
  2199. (define-my-rgrep "gitgrep")
  2200. (define-my-rgrep "grep")
  2201. (define-my-rgrep "global")
  2202. (define-key ctl-x-map "s" 'my-rgrep)
  2203. ;; (defun make ()
  2204. ;; "Run \"make -k\" in current directory."
  2205. ;; (interactive)
  2206. ;; (compile "make -k"))
  2207. (defalias 'make 'compile)
  2208. (defvar sed-in-place-history nil
  2209. "History of `sed-in-place'.")
  2210. (defvar sed-in-place-command "sed --in-place=.bak -e")
  2211. (defun sed-in-place (command)
  2212. "Issue sed in place COMMAND."
  2213. (interactive (list (read-shell-command "sed in place: "
  2214. (concat sed-in-place-command " ")
  2215. 'sed-in-place-history)))
  2216. (shell-command command
  2217. "*sed in place*"))
  2218. (defun dired-do-sed-in-place (&optional arg)
  2219. "Issue sed in place dired. If ARG is given, use the next ARG files."
  2220. (interactive "p")
  2221. (require 'dired-aux)
  2222. (let* ((files (dired-get-marked-files t arg))
  2223. (expr (dired-mark-read-string "Run sed-in-place for %s: "
  2224. nil
  2225. 'sed-in-place
  2226. arg
  2227. files)))
  2228. (if (equal expr
  2229. "")
  2230. (error "No expression specified")
  2231. (shell-command (concat sed-in-place-command
  2232. " '"
  2233. expr
  2234. "' "
  2235. (mapconcat 'shell-quote-argument
  2236. files
  2237. " "))
  2238. "*sed in place*"))))
  2239. (defun dir-show (&optional dir)
  2240. "Show DIR list."
  2241. (interactive)
  2242. (let ((bf (get-buffer-create "*dir show*"))
  2243. (list-directory-brief-switches "-C"))
  2244. (with-current-buffer bf
  2245. (list-directory (or nil
  2246. default-directory)
  2247. nil))
  2248. ))
  2249. (defun my-convmv-sjis2utf8-test ()
  2250. "Run `convmv -r -f sjis -t utf8 *'.
  2251. this is test, does not rename files."
  2252. (interactive)
  2253. (shell-command "convmv -r -f sjis -t utf8 *"))
  2254. (defun my-convmv-sjis2utf8-notest ()
  2255. "Run `convmv -r -f sjis -t utf8 * --notest'."
  2256. (interactive)
  2257. (shell-command "convmv -r -f sjis -t utf8 * --notest"))
  2258. (defun kill-ring-save-buffer-file-name ()
  2259. "Get current filename."
  2260. (interactive)
  2261. (let ((file buffer-file-name))
  2262. (if file
  2263. (progn (kill-new file)
  2264. (message file))
  2265. (message "not visiting file."))))
  2266. (defvar kill-ring-buffer-name "*kill-ring*"
  2267. "Buffer name for `kill-ring-buffer'.")
  2268. (defun open-kill-ring-buffer ()
  2269. "Open kill- ring buffer."
  2270. (interactive)
  2271. (pop-to-buffer
  2272. (with-current-buffer (get-buffer-create kill-ring-buffer-name)
  2273. (erase-buffer)
  2274. (yank)
  2275. (text-mode)
  2276. (current-local-map)
  2277. (goto-char (point-min))
  2278. (yank)
  2279. (current-buffer))))
  2280. (defun set-terminal-header (string)
  2281. "Set terminal header STRING."
  2282. (let ((savepos "\033[s")
  2283. (restorepos "\033[u")
  2284. (movecursor "\033[0;%dH")
  2285. (inverse "\033[7m")
  2286. (restorecolor "\033[0m")
  2287. (cols (frame-parameter nil 'width))
  2288. (length (length string)))
  2289. ;; (redraw-frame (selected-frame))
  2290. (send-string-to-terminal (concat savepos
  2291. (format movecursor
  2292. (1+ (- cols length)))
  2293. inverse
  2294. string
  2295. restorecolor
  2296. restorepos))
  2297. ))
  2298. (defun my-set-terminal-header ()
  2299. "Set terminal header."
  2300. (set-terminal-header (concat " "
  2301. user-login-name
  2302. "@"
  2303. (car (split-string system-name
  2304. "\\."))
  2305. " "
  2306. (format-time-string "%Y/%m/%d %T %z")
  2307. " ")))
  2308. ;; (run-with-timer
  2309. ;; 0.1
  2310. ;; 1
  2311. ;; 'my-set-terminal-header)
  2312. ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2313. ;; ;; savage emacs
  2314. ;; ;; when enabled emacs fails to complete
  2315. ;; ;; http://e-arrows.sakura.ne.jp/2010/05/emacs-should-be-more-savage.html
  2316. ;; (defadvice message (before message-for-stupid (arg &rest arg2) activate)
  2317. ;; (setq arg
  2318. ;; (concat arg
  2319. ;; (if (eq nil
  2320. ;; (string-match "\\. *$"
  2321. ;; arg))
  2322. ;; ".")
  2323. ;; " Stupid!")))
  2324. ;; TODO: make these a library
  2325. (defvar info-in-prompt
  2326. nil
  2327. "System info in the form of \"[user@host] \".")
  2328. (setq info-in-prompt
  2329. (concat "["
  2330. user-login-name
  2331. "@"
  2332. (car (split-string system-name
  2333. "\\."))
  2334. "]"))
  2335. (defun my-real-function-subr-p (function)
  2336. "Return t if FUNCTION is a built-in function even if it is advised."
  2337. (let* ((advised (and (symbolp function)
  2338. (featurep 'advice)
  2339. (ad-get-advice-info function)))
  2340. (real-function
  2341. (or (and advised (let ((origname (cdr (assq 'origname advised))))
  2342. (and (fboundp origname)
  2343. origname)))
  2344. function))
  2345. (def (if (symbolp real-function)
  2346. (symbol-function real-function)
  2347. function)))
  2348. (subrp def)))
  2349. ;; (my-real-function-subr-p 'my-real-function-subr-p)
  2350. ;; (defadvice read-from-minibuffer (before info-in-prompt activate)
  2351. ;; "Show system info when use `read-from-minibuffer'."
  2352. ;; (ad-set-arg 0
  2353. ;; (concat my-system-info
  2354. ;; (ad-get-arg 0))))
  2355. ;; (defadvice read-string (before info-in-prompt activate)
  2356. ;; "Show system info when use `read-string'."
  2357. ;; (ad-set-arg 0
  2358. ;; (concat my-system-info
  2359. ;; (ad-get-arg 0))))
  2360. ;; (when (< emacs-major-version 24)
  2361. ;; (defadvice completing-read (before info-in-prompt activate)
  2362. ;; "Show system info when use `completing-read'."
  2363. ;; (ad-set-arg 0
  2364. ;; (concat my-system-info
  2365. ;; (ad-get-arg 0)))))
  2366. (defmacro info-in-prompt-set (&rest functions)
  2367. "Set info-in-prompt advices for FUNCTIONS."
  2368. `(progn
  2369. ,@(mapcar (lambda (f)
  2370. `(defadvice ,f (before info-in-prompt activate)
  2371. "Show info in prompt."
  2372. (let ((orig (ad-get-arg 0)))
  2373. (unless (string-match-p (regexp-quote info-in-prompt)
  2374. orig)
  2375. (ad-set-arg 0
  2376. (concat info-in-prompt
  2377. " "
  2378. orig))))))
  2379. functions)))
  2380. (info-in-prompt-set read-from-minibuffer
  2381. read-string
  2382. completing-read)
  2383. ;;; emacs.el ends here