summaryrefslogtreecommitdiffstats
path: root/emacs.d/lisp
diff options
context:
space:
mode:
Diffstat (limited to 'emacs.d/lisp')
-rw-r--r--emacs.d/lisp/auto-complete/auto-complete-etags.el60
-rw-r--r--emacs.d/lisp/auto-complete/auto-complete.el1138
-rw-r--r--emacs.d/lisp/cursor-chg.el348
-rw-r--r--emacs.d/lisp/delphi-mode-ench.el8
-rw-r--r--emacs.d/lisp/etags-table.el157
5 files changed, 1710 insertions, 1 deletions
diff --git a/emacs.d/lisp/auto-complete/auto-complete-etags.el b/emacs.d/lisp/auto-complete/auto-complete-etags.el
new file mode 100644
index 0000000..1f0f3cf
--- /dev/null
+++ b/emacs.d/lisp/auto-complete/auto-complete-etags.el
@@ -0,0 +1,60 @@
+;;; auto-complete-etags.el ---
+
+;; Copyright 2009 Yen-Chin,Lee
+;;
+;; Author: Yen-Chin,Lee
+;; Version: $Id: auto-complete-etags.el,v 0.2 2009/04/23 00:38:01 coldnew Exp $
+;; Keywords:
+;; X-URL: not distributed yet
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with this program; if not, write to the Free Software
+;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+;;; Commentary:
+
+;;
+
+;; Put this file into your load-path and the following into your ~/.emacs:
+;; (require 'auto-complete-etags)
+
+;;; Code:
+
+(provide 'auto-complete-etags)
+(require 'auto-complete)
+(eval-when-compile
+ (require 'cl))
+
+
+;;;;##########################################################################
+;;;; User Options, Variables
+;;;;##########################################################################
+
+(defface ac-etags-candidate-face
+ '((t (:background "gainsboro" :foreground "deep sky blue")))
+ "Face for etags candidate")
+
+(defface ac-etags-selection-face
+ '((t (:background "deep sky blue" :foreground "white")))
+ "Face for the etags selected candidate.")
+
+(defvar ac-source-etags
+ '((candidates . (lambda ()
+ (all-completions ac-target (tags-completion-table))))
+ (candidate-face . ac-etags-candidate-face)
+ (selection-face . ac-etags-selection-face)
+ (requires . 3))
+ "Source for etags.")
+
+
+;;; auto-complete-etags.el ends here
diff --git a/emacs.d/lisp/auto-complete/auto-complete.el b/emacs.d/lisp/auto-complete/auto-complete.el
new file mode 100644
index 0000000..cdc4e86
--- /dev/null
+++ b/emacs.d/lisp/auto-complete/auto-complete.el
@@ -0,0 +1,1138 @@
+;;; auto-complete.el --- Inline auto completion
+
+;; Copyright (C) 2008, 2009 MATSUYAMA Tomohiro
+
+;; Author: MATSUYAMA Tomohiro <t.matsuyama.pub@gmail.com>
+;; Keywords: convenience
+;; Version: 0.2.0
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; This extension provides a way to complete with popup menu like:
+;;
+;; def-!-
+;; +-----------------+
+;; |defun::::::::::::|
+;; |defvar |
+;; |defmacro |
+;; | ... |
+;; +-----------------+
+;;
+;; You can complete by typing and selecting menu.
+;; Enjoy!
+
+;;; Qualification:
+;;
+;; This extension can work property on GNU Emacs 22 or higher.
+
+;;; Installation:
+;;
+;; To use this extension, locate all .el files of this package to your load-path directory.
+;;
+;; $ cp auto-complete-x.x.x/*.el ~/.emacs.d/
+;;
+;; And write following code into your .emacs.
+;;
+;; (require 'auto-complete)
+;; (global-auto-complete-mode t)
+
+;;; Tips:
+;;
+;; Use C-n/C-p to select candidates
+;; --------------------------------
+;;
+;; Add following code to your .emacs.
+;;
+;; (define-key ac-complete-mode-map "\C-n" 'ac-next)
+;; (define-key ac-complete-mode-map "\C-p" 'ac-previous)
+;;
+;;
+;; Don't start completion automatically
+;; ------------------------------------
+;;
+;; Add following code to your .emacs.
+;;
+;; (setq ac-auto-start nil)
+;; (global-set-key "\M-/" 'ac-start)
+;;
+;; or
+;;
+;; ;; start completion when entered 3 characters
+;; (setq ac-auto-start 3)
+;;
+;;
+;; Stop completion
+;; ---------------
+;;
+;; Add following code to your .emacs.
+;;
+;; (define-key ac-complete-mode-map "\M-/" 'ac-stop)
+;;
+;; Now you can stop completion by pressing M-/.
+;;
+;;
+;; Completion by TAB
+;; -----------------
+;;
+;; Add following code to your .emacs.
+;;
+;; (define-key ac-complete-mode-map "\t" 'ac-complete)
+;; (define-key ac-complete-mode-map "\r" nil)
+;;
+;;
+;; Do What I Mean mode
+;; -------------------
+;;
+;; If DWIM (Do What I Mean) mode is enabled,
+;; the following features is available:
+;;
+;; a. TAB (ac-expand) behave as completion (ac-complete)
+;; when only one candidate is left
+;; b. TAB (ac-expand) behave as completion (ac-complete)
+;; after you select candidate
+;; c. Disapear automatically when you
+;; complete a candidate.
+;;
+;; DWIM mode is enabled by default.
+;; You can enable this feature by
+;; setting `ac-dwim' to t.
+;;
+;; (setq ac-dwim t)
+;;
+;;
+;; Change default sources
+;; ----------------------
+;;
+;; (setq-default ac-sources '(ac-source-abbrev ac-source-words-in-buffer))
+;;
+;;
+;; Change sources for particular mode
+;; ----------------------------------
+;;
+;; (add-hook 'emacs-lisp-mode-hook
+;; (lambda ()
+;; (setq ac-sources '(ac-source-words-in-buffer ac-source-symbols))))
+
+;;; History:
+;;
+;; 2008-03-18
+;; * auto-complete.el 0.2.0 released
+;;
+;; 2008-03-04
+;; * fixed menu position bug
+;;
+;; 2008-03-02
+;; * made a source be able to be just a function which returns candidates
+;; * added ac-source-words-in-all-buffer
+;;
+;; 2008-03-01
+;; * added basic cache facility
+;;
+;; 2008-02-20
+;; * fixed menu position bug at long line (thanks rubikitch <rubikitch@ruby-lang.org>)
+;; * made dictionary source generator (ac-define-dictionary-source)
+;; * devided into some files (auto-complete-ruby.el, auto-complete-yasnippet.el, etc)
+;;
+;; 2008-02-19
+;; * added ac-trigger-commands switch
+;;
+;; 2008-02-10
+;; * added ac-stop function (suggestion from Andy Stewart)
+;; * added ac-override-local-map switch (suggestion from Andy Stewart)
+;;
+;; 2008-02-03
+;; * omni completion redesign
+;; * ac-sources is now buffer local for every buffer
+;; * fixed a menu position bug (thanks Andy Stewart)
+;; * fixed byte-compile warnings (thanks Andy Stewart)
+;;
+;; 2008-01-22
+;; * added face/selection-face property for sources
+;; * supported menu scroll
+;;
+;; 2008-01-20
+;; * omni completion
+;;
+;; 2008-12-24
+;; * suppress errors on command hook
+;;
+;; 2008-12-03
+;; * changed ac-dwim to nil by default
+;; * made menu to be able to adjust width
+;;
+;; 2008-12-03
+;; * renamed ac-find-function to ac-prefix-function
+;; * renamed ac-target to ac-prefix
+;;
+;; 2008-11-26
+;; * auto-complete.el 0.1.0 released
+;;
+;; 2008-11-19
+;; * thanks for Taiki SUGAWARA <buzz.taiki@gmail.com>
+;; * added source ac-source-abbrev
+;; * added source ac-source-symbols
+;; * added ac-expand-common to expand common part
+;;
+;; 2008-11-18
+;; * added ac-auto-start switch
+;; * added ac-dwim switch
+;; * changed menu popup behavior at end of window
+;; * thanks rubikitch <rubikitch@ruby-lang.org>, kazu-yamamoto.
+;; * fixed canceler bug
+;; * changed to use overriding-local-map instead of minor mode map
+;; * changed default key bindings
+;;
+;; 2008-11-16
+;; * supported candidates by using sources
+;; * added automatically start swtich
+;; * fixed some bug
+;; * added source ac-source-files-in-current-dir
+;; * added source ac-source-words-in-buffer
+;; * added source ac-source-yasnippet
+;; * renamed ac-enum-candidates-function to ac-candidate-function
+;; * renamed ac-find-target-function to ac-find-function
+;; * ac-find-function and ac-candidate-function is not buffer local variable now
+;; * made candidates visible when you are end of line
+;;
+;; 2008-11-11
+;; * by reporting from rubikitch <rubikitch@ruby-lang.org>
+;; * renamed hook name
+;; * registered backward-delete-char as special command
+;; * fixed code for creating candidates
+;; * made auto-complete disabled when isearch-mode enabled
+;; * added some major-mode into ac-modes
+;;
+;; 2008-11-09
+;; * auto-complete.el 0.0.1 released
+;; * fixed double-width character displaying problem
+;; * fixed menu position following tab character
+;; * made candidates visible when you are end of window
+
+;;; TODO:
+;;
+;; - test facility
+;; - support composed chars
+;; - fuzzy match
+;; - minibuffer completion
+;; - dictionary
+;; - documentation
+;; - performance issue (cache issue)
+;; - fix narrowing bug (reported by Yuto Hayamizu <y.hayamizu@gmail.com>)
+;; - care about undo (buffer-disable-undo)
+;; - scroll bar (visual)
+;; - show description
+;; - semantic
+;; - use cl
+;; - icon
+;; - refactoring (especially menu)
+;; - linum.el bug (reported by Andy Stewart)
+;; - flymake bug (reported by TiagoCamargo)
+
+;;; Code:
+
+
+
+(defgroup auto-complete nil
+ "Auto completion with popup menu"
+ :group 'convenience
+ :prefix "auto-complete-")
+
+(defcustom ac-candidate-menu-height 10
+ "Max height of candidate menu."
+ :type 'number
+ :group 'auto-complete)
+
+(defcustom ac-candidate-max 10
+ "Max of number of candidates."
+ :type 'number
+ :group 'auto-complete)
+
+(defcustom ac-modes
+ '(emacs-lisp-mode lisp-interaction-mode
+ c-mode cc-mode c++-mode java-mode
+ perl-mode cperl-mode python-mode ruby-mode
+ ecmascript-mode javascript-mode js2-mode php-mode css-mode
+ makefile-mode sh-mode fortran-mode f90-mode ada-mode
+ xml-mode sgml-mode)
+ "Major modes `auto-complete-mode' can run on."
+ :type '(list symbol)
+ :group 'auto-complete)
+
+(defcustom ac-trigger-commands
+ '(self-insert-command)
+ "Trigger commands that specify whether `auto-complete' should start or not."
+ :type '(list symbol)
+ :group 'auto-complete)
+
+(defcustom ac-auto-start t
+ "Non-nil means completion will be started automatically.
+Positive integer means if a length of a word you entered is larger than the value,
+completion will be started automatically.
+If you specify `nil', never be started automatically."
+ :group 'auto-complete)
+
+(defcustom ac-dwim nil
+ "Non-nil means `auto-complete' works based on Do What I Mean."
+ :type 'boolean
+ :group 'auto-complete)
+
+(defcustom ac-override-local-map nil
+ "Non-nil mean use `ac-complete-mode-map' override local map.
+Please set it to non-nil only if you faced to some problem about
+minor-mode keymap conflicts."
+ :type 'boolean
+ :group 'auto-complete)
+
+(defface ac-candidate-face
+ '((t (:background "lightgray" :foreground "black")))
+ "Face for candidate."
+ :group 'auto-complete)
+
+(defface ac-selection-face
+ '((t (:background "blue" :foreground "white")))
+ "Face for the selected candidate."
+ :group 'auto-complete)
+
+(defvar auto-complete-mode-hook nil
+ "Hook for `auto-complete-mode'.")
+
+(defvar ac-menu nil
+ "Menu instance.")
+
+(defvar ac-menu-direction 1
+ "Positive integer means `ac-menu' grows forward.
+Or, `ac-menu' grows backward.")
+
+(defvar ac-menu-offset 0
+ "Offset to contents.")
+
+(defvar ac-menu-scroll 0
+ "Scroll top of `ac-menu'.")
+
+(defvar ac-completing nil
+ "Non-nil means `auto-complete-mode' is now working on completion.")
+
+(defvar ac-saved-window-start nil
+ "Saved window start value for restore.")
+
+(defvar ac-saved-window-hscroll nil
+ "Saved window hscroll value for restore.")
+
+(defvar ac-buffer nil
+ "A buffer where auto-complete is started.")
+
+(defvar ac-point nil
+ "Start point of prefix.")
+
+(defvar ac-old-point nil
+ "Previous start point of prefix.")
+
+(defvar ac-prefix nil
+ "Prefix.")
+(defvaralias 'ac-target 'ac-prefix)
+
+(defvar ac-limit 0
+ "Limit of number of candidates.")
+
+(defvar ac-candidates nil
+ "Current candidates.")
+
+(defvar ac-selection nil
+ "Current candidate index.")
+
+(defvar ac-dwim-enable nil
+ "Non-nil means DWIM completion will be allowed.")
+
+(defvar ac-setup-function 'ac-sources-setup
+ "This function will be called when `auto-complete-mode' is enabled.")
+
+(defvar ac-prefix-function 'ac-sources-prefix
+ "When `auto-complete-mode' finds it can start completion
+or update candidates, it will call this function to find a
+start point of the prefix.
+
+If this function returns a point `auto-complete-mode'
+will set the substring between the point and current point to `ac-prefix'.
+And also it will start completion or update candidates by using
+the `ac-prefix'.
+
+If this function returns `nil', `auto-complete-mode'
+ignore starting completion or stop completing.")
+(defvaralias 'ac-find-function 'ac-prefix-function)
+
+(defvar ac-init-function 'ac-sources-init
+ "This function will be called when candidate menu is setupped.")
+
+(defvar ac-cleanup-function 'ac-sources-cleanup
+ "This function will be called when candidate menu is cleanupped")
+
+(defvar ac-candidate-function 'ac-sources-candidate
+ "This function can return candidates as list by
+using the `TARGET' that is given as a first argument.")
+
+(defvar ac-complete-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "\t" 'ac-expand)
+ (define-key map "\r" 'ac-complete)
+
+ (define-key map [down] 'ac-next)
+ (define-key map [up] 'ac-previous)
+
+ map)
+ "Keymap for completion.")
+
+(defvar ac-saved-local-map nil
+ "Old keymap before `auto-complete' activated.")
+
+
+
+;;;; Auto completion
+
+(defun ac-setup-menu (point width)
+ "Setup popup menu."
+ (when ac-menu
+ ;; reposition
+ (ac-menu-delete ac-menu)
+ (setq ac-menu nil))
+ (save-excursion
+ (goto-char point)
+ (let ((column (ac-current-physical-column))
+ (line (line-number-at-pos)))
+ (setq ac-saved-window-start (window-start))
+ (setq ac-saved-window-hscroll (window-hscroll))
+ (setq ac-menu-direction
+ (if (and (> line ac-candidate-menu-height)
+ (> ac-candidate-menu-height
+ (-
+ (max 1 (- (window-height)
+ (if mode-line-format 1 0)
+ (if header-line-format 1 0)))
+ (count-lines (window-start) (point)))))
+ -1
+ 1))
+ (let ((window-width (window-width))
+ (right (- (+ column width)
+ (window-hscroll))))
+ (if (and (> right window-width)
+ (>= right width)
+ (>= column width))
+ (setq column (- column width))))
+ (if (> ac-menu-direction 0)
+ (progn
+ (forward-line)
+ (if (eq line (line-number-at-pos))
+ (newline)
+ (forward-line -1))
+ (setq ac-menu (ac-menu-create (1+ line) column width ac-candidate-menu-height))
+ (setq ac-point point))
+ (setq ac-menu (ac-menu-create (- line ac-candidate-menu-height) column width ac-candidate-menu-height))
+ (setq ac-point point)))))
+
+(defun ac-cleanup ()
+ "Destroy popup menu."
+ (ac-deactivate-mode-map)
+ (when ac-menu
+ (ac-menu-delete ac-menu)
+ (set-window-start (selected-window) ac-saved-window-start)
+ (set-window-hscroll (selected-window) ac-saved-window-hscroll))
+ (setq ac-menu nil)
+ (setq ac-menu-scroll 0)
+ (setq ac-completing nil)
+ (setq ac-point nil)
+ (setq ac-candidates nil)
+ (setq ac-selection 0)
+ (setq ac-selection-scroll-top 0)
+ (funcall ac-cleanup-function))
+
+(defun ac-activate-mode-map ()
+ "Activate `ac-complete-mode-map'."
+ (if ac-override-local-map
+ (progn
+ (setq ac-saved-local-map overriding-terminal-local-map)
+ (if (eq ac-saved-local-map ac-complete-mode-map)
+ ;; maybe never reach here
+ (setq ac-saved-local-map nil))
+ (setq overriding-terminal-local-map ac-complete-mode-map))
+ ;; rearrange ac-mode-map pair first
+ (assq-delete-all 'ac-completing minor-mode-map-alist)
+ (push (cons 'ac-completing ac-complete-mode-map) minor-mode-map-alist)))
+
+(defun ac-deactivate-mode-map ()
+ "Deactivate `ac-complete-mode-map'."
+ (when (and ac-override-local-map
+ (eq overriding-terminal-local-map ac-complete-mode-map))
+ (setq overriding-terminal-local-map ac-saved-local-map)
+ (setq ac-saved-local-map nil)))
+
+(defun ac-next ()
+ "Select next candidate."
+ (interactive)
+ (if (interactive-p)
+ (setq ac-dwim-enable t))
+ (if ac-candidates
+ (ac-select-candidate
+ (let ((selection (1+ ac-selection)))
+ (if (= selection (+ ac-menu-offset (min ac-candidate-menu-height (length ac-candidates))))
+ (if (< (+ (- ac-selection ac-menu-offset) ac-menu-scroll) (1- (length ac-candidates)))
+ (prog1 ac-selection
+ (setq ac-menu-scroll (1+ ac-menu-scroll))
+ (ac-redraw-candidates))
+ (setq ac-menu-scroll 0)
+ (ac-redraw-candidates)
+ ac-menu-offset)
+ selection)))))
+
+(defun ac-previous ()
+ "Select previous candidate."
+ (interactive)
+ (if (interactive-p)
+ (setq ac-dwim-enable t))
+ (if ac-candidates
+ (ac-select-candidate
+ (let ((selection (1- ac-selection)))
+ (if (< selection ac-menu-offset)
+ (if (= ac-menu-scroll 0)
+ (prog1 (1- (+ ac-menu-offset (min ac-candidate-menu-height (length ac-candidates))))
+ (setq ac-menu-scroll (- (length ac-candidates) (min ac-candidate-menu-height (length ac-candidates))))
+ (ac-redraw-candidates))
+ (setq ac-menu-scroll (1- ac-menu-scroll))
+ (ac-redraw-candidates)
+ ac-selection)
+ selection)))))
+
+(defun ac-expand-1 ()
+ "Try expansion."
+ (let ((string (overlay-get (ac-menu-line-overlay ac-menu ac-selection) 'real-string)))
+ (delete-region ac-point (point))
+ (insert string)
+ (setq ac-prefix string)))
+
+(defun ac-expand ()
+ "Try expansion but select next if expanded twice."
+ (interactive)
+ (if (and ac-dwim ac-dwim-enable)
+ (ac-complete)
+ (let ((target ac-prefix)
+ (string (ac-expand-1)))
+ (when (equal target string)
+ (ac-next)
+ (ac-expand-1)))))
+
+(defun ac-expand-common ()
+ "Try expansion common part."
+ (interactive)
+ (let ((common (try-completion ac-prefix ac-candidates))
+ (buffer-undo-list t))
+ (when (stringp common)
+ (delete-region ac-point (point))
+ (insert common)
+ (setq ac-prefix common))))
+
+(defun ac-complete ()
+ "Try completion."
+ (interactive)
+ (let* ((candidate (ac-get-selected-candidate))
+ (action (ac-get-candidate-action candidate)))
+ (ac-expand-1)
+ (if action
+ (funcall action))
+ (ac-abort)))
+
+(defun ac-abort ()
+ "Abort completion."
+ (ac-cleanup))
+
+(defun ac-stop ()
+ "Stop completiong."
+ (interactive)
+ (ac-abort))
+
+(defun ac-redraw-candidates ()
+ "Redraw the menu contents."
+ (let ((i ac-menu-offset))
+ ;; show line and set string to the line
+ (mapc
+ (lambda (candidate)
+ (when (< i ac-candidate-menu-height)
+ (ac-menu-show-line ac-menu i)
+ (ac-menu-set-line-string ac-menu i candidate
+ (if (= i ac-selection)
+ (or (ac-get-candidate-property 'selection-face candidate) 'ac-selection-face)
+ (or (ac-get-candidate-property 'candidate-face candidate) 'ac-candidate-face)))
+ (setq i (1+ i))))
+ (nthcdr ac-menu-scroll ac-candidates))
+ ;; ensure lines visible
+ (if (and (> ac-menu-direction 0)
+ (> i (-
+ (max 1 (- (window-height)
+ (if mode-line-format 1 0)
+ (if header-line-format 1 0)))
+ (count-lines (window-start) (point)))))
+ (recenter (- (1+ i))))
+ (if (> i ac-menu-offset)
+ (let ((window-width (window-width))
+ (right (- (+ (ac-menu-column ac-menu) (ac-menu-width ac-menu))
+ (window-hscroll))))
+ (if (> right window-width)
+ (scroll-left (- right window-width)))))
+ ;; hide remaining lines
+ (if (> ac-menu-direction 0)
+ (while (< i ac-candidate-menu-height)
+ (ac-menu-hide-line ac-menu i)
+ (setq i (1+ i)))
+ (dotimes (i ac-menu-offset)
+ (ac-menu-hide-line ac-menu i)))))
+
+(defun ac-update-candidates (candidates)
+ "Update candidates of popup menu."
+ (setq ac-menu-offset (if (> ac-menu-direction 0)
+ 0
+ (- ac-candidate-menu-height
+ (min ac-candidate-menu-height
+ (length candidates)))))
+ (setq ac-selection ac-menu-offset)
+ (setq ac-candidates candidates)
+ (setq ac-dwim-enable (= (length candidates) 1))
+ (if candidates
+ (progn
+ (setq ac-completing t)
+ (ac-activate-mode-map))
+ (setq ac-completing nil)
+ (ac-deactivate-mode-map))
+ (ac-redraw-candidates))
+
+(defun ac-get-selected-candidate ()
+ (overlay-get (ac-menu-line-overlay ac-menu ac-selection) 'real-string))
+
+(defun ac-get-candidate-action (candidate)
+ (ac-get-candidate-property 'action candidate))
+
+(defun ac-propertize-candidate (candidate &rest properties)
+ (apply 'propertize candidate properties))
+
+(defun ac-get-candidate-property (prop candidate)
+ (get-text-property 0 prop candidate))
+
+(defun ac-select-candidate (selection)
+ "Select candidate pointed by `SELECTION'."
+ (when ac-candidates
+ (let ((c1 (nth (+ (- ac-selection ac-menu-offset) ac-menu-scroll) ac-candidates))
+ (c2 (nth (+ (- selection ac-menu-offset) ac-menu-scroll) ac-candidates)))
+ (ac-menu-set-line-string ac-menu ac-selection c1
+ (or (ac-get-candidate-property 'candidate-face c1)
+ 'ac-candidate-face))
+ (ac-menu-set-line-string ac-menu selection c2
+ (or (ac-get-candidate-property 'selection-face c2)
+ 'ac-selection-face))
+ (setq ac-selection selection))))
+
+(defun ac-start ()
+ "Start completion."
+ (interactive)
+ (let* ((point (save-excursion (funcall ac-prefix-function)))
+ (reposition (not (equal ac-point point))))
+ (if (null point)
+ (ac-abort)
+ (setq ac-buffer (current-buffer))
+ (setq ac-point point)
+ (when (not (equal ac-point ac-old-point))
+ (setq ac-old-point point))
+ (setq ac-prefix (buffer-substring-no-properties point (point)))
+ (setq ac-limit ac-candidate-max)
+ (if (or reposition (null ac-menu))
+ (save-excursion
+ (funcall ac-init-function)))
+ (let* ((candidates
+ (if (or ac-completing
+ (not (integerp ac-auto-start))
+ (>= (length ac-prefix) ac-auto-start))
+ (save-excursion
+ (funcall ac-candidate-function))))
+ (current-width (if ac-menu (ac-menu-width ac-menu) 0))
+ (width (let ((w '(0)) s)
+ (dotimes (i ac-candidate-menu-height)
+ (setq s (nth i candidates))
+ (if (stringp s) (push (string-width s) w)))
+ (apply 'max w))))
+ (if (or reposition
+ (null ac-menu)
+ (> width current-width)
+ (< width (- current-width 10)))
+ (ac-setup-menu point (* (ceiling (/ width 10.0)) 10)))
+ (if (and ac-dwim
+ (= (length candidates) 1)
+ (equal (car candidates) ac-prefix)
+ (null (ac-get-candidate-action (car candidates))))
+ (setq candidates nil))
+ (ac-update-candidates candidates)))))
+
+(defun ac-trigger-command-p ()
+ "Return non-nil if `this-command' is a trigger command."
+ (or (memq this-command ac-trigger-commands)
+ (and ac-completing
+ (memq this-command
+ '(delete-backward-char
+ backward-delete-char
+ backward-delete-char-untabify)))))
+
+(defun ac-current-physical-column ()
+ "Current physical column. (not logical column)"
+ (- (point) (save-excursion (vertical-motion 0) (point))))
+
+(defun ac-on-pre-command ()
+ (progn ; ignore-errors
+ (if (and (not (ac-trigger-command-p))
+ (or (not (symbolp this-command))
+ (not (string-match "^ac-" (symbol-name this-command)))))
+ (ac-abort))))
+
+(defun ac-on-post-command ()
+ (progn ; ignore-errors
+ (if (and (or ac-auto-start
+ ac-completing)
+ (not isearch-mode)
+ (ac-trigger-command-p))
+ (ac-start))))
+
+(defun auto-complete-mode-maybe ()
+ "What buffer `auto-complete-mode' prefers."
+ (if (and (not (minibufferp (current-buffer)))
+ (memq major-mode ac-modes))
+ (auto-complete-mode 1)))
+
+(require 'easy-mmode)
+
+(define-minor-mode auto-complete-mode
+ "AutoComplete mode"
+ :lighter " AC"
+ :group 'auto-complete
+ (if auto-complete-mode
+ (progn
+ (funcall ac-setup-function)
+ (add-hook 'post-command-hook 'ac-on-post-command nil t)
+ (add-hook 'pre-command-hook 'ac-on-pre-command nil t)
+ (run-hooks 'auto-complete-mode-hook))
+ (remove-hook 'post-command-hook 'ac-on-post-command t)
+ (remove-hook 'pre-command-hook 'ac-on-pre-command t)
+ (ac-abort)))
+
+(define-global-minor-mode global-auto-complete-mode
+ auto-complete-mode auto-complete-mode-maybe
+ :group 'auto-complete)
+
+
+
+;;;; Basic cache facility
+
+(defvar ac-clear-variables-after-save nil)
+
+(defun ac-clear-variable-after-save (variable)
+ (push variable ac-clear-variables-after-save))
+
+(defun ac-clear-variables-after-save ()
+ (dolist (variable ac-clear-variables-after-save)
+ (set variable nil)))
+
+
+
+;;;; Sources implementation
+
+(defvar ac-sources '(ac-source-words-in-buffer)
+ "Sources for completion.
+
+Source takes a form of just function which returns candidates or alist:
+
+init INIT-FUNC
+ INIT-FUNC will be called before creating candidate every time.
+
+candidates CANDIDATE-FUNC
+ CANDIDATE-FUNC will return a list of string as candidates.
+CANDIDATE-FUNC should care about `ac-limit' that is specified at limit for performance.
+
+action ACTION-FUNC
+ ACTION-FUNC will be called when `ac-complete' is called.
+
+limit LIMIT-NUM
+ A limit of candidates.
+
+requires REQUIRES-NUM
+ This source will be included when `ac-prefix' length is larger than REQUIRES-NUM.")
+(make-variable-buffer-local 'ac-sources)
+
+(defvar ac-sources-prefix-function 'ac-sources-prefix-default
+ "Default prefix function for sources.
+You should override this variable instead of ac-prefix-function.")
+
+(defvar ac-current-sources nil
+ "Current working sources.")
+
+(defvar ac-omni-completion-sources nil
+ "An alist of REGEXP and SOURCES.
+If matched regexp, switch to omni-completion mode and
+use SOURCES as `ac-sources'.")
+(make-variable-buffer-local 'ac-omni-completion-sources)
+
+(defvar ac-sources-omni-completion nil
+ "Non-nil means `auto-complete-mode' is now working on omni-completion.")
+
+(defun ac-sources-setup ()
+ "Implementation for `ac-setup-function' by sources."
+ (make-local-variable 'ac-clear-variables-after-save)
+ (add-hook 'after-save-hook 'ac-clear-variables-after-save nil t))
+
+(defun ac-sources-init ()
+ "Implementation for `ac-init-function' by sources."
+ (or ac-current-sources (setq ac-current-sources ac-sources))
+ (dolist (source ac-current-sources)
+ (let ((init-function (ac-get-source-property 'init source)))
+ (if init-function
+ (funcall init-function)))))
+
+(defun ac-sources-cleanup ()
+ "Implementation for `ac-cleanup-function' by sources."
+ (setq ac-current-sources nil)
+ (setq ac-sources-omni-completion nil))
+
+(defun ac-sources-prefix ()
+ "Implemention for `ac-prefix-function' by sources."
+ (let (point)
+ (dolist (pair ac-omni-completion-sources)
+ (when (looking-back (car pair))
+ (setq ac-current-sources (cdr pair))
+ (setq ac-sources-omni-completion t)
+ (setq ac-completing t)
+ (setq point (match-end 0))))
+ (or point
+ (if (and ac-completing ac-sources-omni-completion)
+ ac-point
+ (setq ac-current-sources ac-sources)
+ (setq ac-sources-omni-completion nil)
+ (funcall ac-sources-prefix-function)))))
+
+(defun ac-sources-prefix-default ()
+ "Default implementation for `ac-sources-prefix-function'."
+ (require 'thingatpt)
+ (car-safe (bounds-of-thing-at-point 'symbol)))
+
+(defun ac-sources-candidate ()
+ "Implementation for `ac-cadidates-function' by sources."
+ (let (candidates)
+ (dolist (source ac-current-sources)
+ (let* ((ac-limit (or (ac-get-source-property 'limit source) ac-limit))
+ (requires (ac-get-source-property 'requires source))
+ cand)
+ (when (or ac-sources-omni-completion
+ (>= (length ac-prefix)
+ (if (integerp requires)
+ requires
+ 1)))
+ (setq cand
+ (delq nil
+ (mapcar (lambda (candidate)
+ (ac-propertize-candidate candidate
+ 'action (ac-get-source-property 'action source)
+ 'face (ac-get-source-property 'candidate-face source)
+ 'candidate-face (ac-get-source-property 'candidate-face source)
+ 'selection-face (ac-get-source-property 'selection-face source)))
+ (funcall (ac-get-source-property 'candidates source))))))
+ (if (and (> ac-limit 1)
+ (> (length cand) ac-limit))
+ (setcdr (nthcdr (1- ac-limit) (copy-sequence cand)) nil))
+ (setq candidates (append candidates cand))))
+ (delete-dups candidates)))
+
+(defun ac-get-source-property (property source)
+ (if (symbolp source)
+ (setq source (symbol-value source)))
+ (if (and (functionp source)
+ (eq property 'candidates))
+ source
+ (if (consp source)
+ (assoc-default property source))))
+
+
+
+;;;; Standard sources
+
+(defun ac-candidate-words-in-buffer ()
+ "Default implemention for `ac-candidate-function'."
+ (if (> (length ac-prefix) 0)
+ (let ((i 0)
+ candidate
+ candidates
+ (regexp (concat "\\b" (regexp-quote ac-prefix) "\\(\\s_\\|\\sw\\)*\\b")))
+ (save-excursion
+ ;; search backward
+ (goto-char ac-point)
+ (while (and (< i ac-limit)
+ (re-search-backward regexp nil t))
+ (setq candidate (match-string-no-properties 0))
+ (unless (member candidate candidates)
+ (push candidate candidates)
+ (setq i (1+ i))))
+ ;; search backward
+ (goto-char (+ ac-point (length ac-prefix)))
+ (while (and (< i ac-limit)
+ (re-search-forward regexp nil t))
+ (setq candidate (match-string-no-properties 0))
+ (unless (member candidate candidates)
+ (push candidate candidates)
+ (setq i (1+ i))))
+ (nreverse candidates)))))
+
+(defvar ac-source-words-in-buffer
+ '((candidates . ac-candidate-words-in-buffer))
+ "Source for completing words in current buffer.")
+
+(defvar ac-word-index nil
+ "Word index for individual buffer.")
+
+(ac-clear-variable-after-save 'ac-word-index)
+
+(defvar ac-source-words-in-all-buffer
+ '((init
+ . (lambda ()
+ (dolist (buffer (buffer-list))
+ (with-current-buffer buffer
+ (if (not (local-variable-p 'ac-word-index))
+ (make-local-variable 'ac-word-index))
+ (if (eq buffer ac-buffer)
+ (setq ac-word-index (ac-candidate-words-in-buffer))
+ (if (and (null ac-word-index)
+ (< (buffer-size) 102400))
+ (save-excursion
+ (goto-char (point-min))
+ (while (re-search-forward "\\b\\(\\s_\\|\\sw\\)+\\b" nil t)
+ (let ((candidate (match-string-no-properties 0)))
+ (if (not (member candidate ac-word-index))
+ (push candidate ac-word-index))))
+ (setq ac-word-index (nreverse ac-word-index)))))))))
+ (candidates
+ . (lambda ()
+ (let ((candidates)
+ (buffers (buffer-list)))
+ (while (and (< (length candidates) ac-limit)
+ buffers)
+ (setq candidates (append candidates (all-completions ac-prefix (buffer-local-value 'ac-word-index (car buffers)))))
+ (setq buffers (cdr buffers)))
+ candidates))))
+ "Source for completing words in all buffer.")
+
+(defvar ac-source-symbols
+ '((candidates
+ . (lambda ()
+ (all-completions ac-prefix obarray))))
+ "Source for Emacs lisp symbols.")
+
+(defvar ac-source-abbrev
+ `((candidates
+ . (lambda ()
+ (all-completions ac-prefix local-abbrev-table)))
+ (action
+ . expand-abbrev))
+ "Source for abbrev.")
+
+(defvar ac-source-files-in-current-dir
+ '((candidates
+ . (lambda ()
+ (all-completions ac-prefix (directory-files default-directory)))))
+ "Source for listing files in current directory.")
+
+(defun ac-filename-candidate ()
+ (let ((dir (file-name-directory ac-prefix)))
+ (ignore-errors
+ (delq nil
+ (mapcar (lambda (file)
+ (if (not (member file '("./" "../")))
+ (concat dir file)))
+ (file-name-all-completions
+ (file-name-nondirectory ac-prefix) dir))))))
+
+(defvar ac-source-filename
+ '((candidates . ac-filename-candidate))
+ "Source for completing file name.")
+
+(defvar ac-imenu-index nil
+ "Imenu index.")
+
+(defun ac-imenu-candidate ()
+ (require 'imenu)
+ (let ((i 0)
+ (stack ac-imenu-index)
+ candidates
+ node)
+ (while (and stack
+ (< i ac-limit))
+ (setq node (pop stack))
+ (when (consp node)
+ (let ((car (car node))
+ (cdr (cdr node)))
+ (if (consp cdr)
+ (mapc (lambda (child)
+ (push child stack))
+ cdr)
+ (when (and (stringp car)
+ (string-match (concat "^" (regexp-quote ac-prefix)) car))
+ (push car candidates)
+ (setq i (1+ i)))))))
+ (nreverse candidates)))
+
+(defvar ac-source-imenu
+ '((init
+ . (lambda ()
+ (require 'imenu)
+ (setq ac-imenu-index
+ (ignore-errors (imenu--make-index-alist)))))
+ (candidates . ac-imenu-candidate))
+ "Source for imenu.")
+
+(defmacro ac-define-dictionary-source (name list)
+ "Define dictionary source named `NAME'.
+`LIST' is a list of string.
+This is useful if you just want to define a dictionary/keywords source."
+ `(defvar ,name
+ '((candidates . (lambda () (all-completions ac-prefix ,list))))))
+
+
+
+;;;; Popup menu
+
+(defun ac-menu-line (menu)
+ "Line number of `MENU'."
+ (nth 0 menu))
+
+(defun ac-menu-column (menu)
+ "Column of `MENU'."
+ (nth 1 menu))
+
+(defun ac-menu-width (menu)
+ "Popup menu width of `MENU'."
+ (nth 2 menu))
+
+(defun ac-menu-height (menu)
+ "Popup menu height of `MENU'."
+ (nth 3 menu))
+
+(defun ac-menu-overlays (menu)
+ "Overlays that `MENU' contains."
+ (nth 4 menu))
+
+(defun ac-menu-line-overlay (menu line)
+ "Return a overlay of `MENU' at `LINE'."
+ (aref (ac-menu-overlays menu) line))
+
+(defun ac-menu-hide-line (menu line)
+ "Hide `LINE' in `MENU'."
+ (let ((overlay (ac-menu-line-overlay menu line)))
+ (overlay-put overlay 'invisible nil)
+ (overlay-put overlay 'after-string nil)))
+
+(defun ac-menu-show-line (menu line)
+ "Show `LINE' in `MENU'."
+ (let ((overlay (ac-menu-line-overlay menu line)))
+ (overlay-put overlay 'invisible t)))
+
+(defun ac-menu-set-line-string (menu line string &optional face)
+ "Set contents of `LINE' in `MENU'."
+ (let ((overlay (ac-menu-line-overlay menu line)))
+ (overlay-put overlay 'real-string string)
+ (funcall (overlay-get overlay 'set-string-function) menu overlay string face)))
+
+(defun ac-menu-create-line-string (menu string)
+ "Adjust `STRING' into `MENU'."
+ (let ((length 0)
+ (width 0)
+ (menu-width (ac-menu-width menu))
+ (chars (append string nil)))
+ (while (and
+ chars
+ (<= (setq width (+ width (char-width (car chars)))) menu-width))
+ (setq length (1+ length))
+ (setq chars (cdr chars)))
+ (if (< length (length string))
+ (setq string (substring string 0 length)))
+ (let ((string-width (string-width string)))
+ (if (< string-width menu-width)
+ (setq string (concat string
+ (make-string (- menu-width string-width) ? )))))
+ string))
+
+(defun ac-menu-hide (menu)
+ "Hide `MENU'."
+ (dotimes (i (ac-menu-height menu))
+ (ac-menu-hide-line menu i)))
+
+(defun ac-menu-last-line-of-buffer ()
+ (save-excursion
+ (not (eq (forward-line) 0))))
+
+(defun ac-menu-create (line column width height)
+ "Create popup menu."
+ (save-excursion
+ (let ((overlays (make-vector height nil))
+ (window (selected-window)))
+ (goto-line line)
+ (dotimes (i height)
+ (move-to-column column)
+ (let (overlay begin w current-column (prefix "") (postfix ""))
+ (setq current-column (current-column))
+ (cond
+ ((> current-column column)
+ (backward-char)
+ (setq current-column (current-column))
+ (if (< current-column column)
+ (setq prefix (make-string (- column current-column) ? ))))
+ ((< current-column column)
+ (setq prefix (make-string (- column current-column) ? ))))
+
+ (setq begin (point))
+ (setq w (+ width (length prefix)))
+ (while (and (not (eolp))
+ (> w 0))
+ (setq w (- w (char-width (char-after))))
+ (forward-char))
+ (if (< w 0)
+ (setq postfix (make-string (- w) ? )))
+ (if (ac-menu-last-line-of-buffer)
+ (setq postfix (concat postfix "\n")))
+
+ (setq overlay (make-overlay begin (point)))
+ (overlay-put overlay 'window window)
+ (overlay-put overlay 'prefix prefix)
+ (overlay-put overlay 'postfix postfix)
+ (overlay-put overlay 'width width)
+ (overlay-put overlay 'set-string-function
+ (lambda (menu overlay string &optional face)
+ (overlay-put overlay
+ 'after-string
+ (concat (overlay-get overlay 'prefix)
+ (propertize (ac-menu-create-line-string menu string) 'face face)
+ (overlay-get overlay 'postfix)))))
+ (aset overlays i overlay))
+ (forward-line))
+ (let ((i 100))
+ (mapc (lambda (overlay)
+ (overlay-put overlay 'priority i)
+ (setq i (1+ i)))
+ (nreverse (append overlays nil))))
+ (list line column width height overlays))))
+
+(defun ac-menu-delete (menu)
+ "Delete `MENU'."
+ (mapcar 'delete-overlay (ac-menu-overlays menu)))
+
+(provide 'auto-complete)
+;;; auto-complete.el ends here
diff --git a/emacs.d/lisp/cursor-chg.el b/emacs.d/lisp/cursor-chg.el
new file mode 100644
index 0000000..159d4e1
--- /dev/null
+++ b/emacs.d/lisp/cursor-chg.el
@@ -0,0 +1,348 @@
+;;; cursor-chg.el --- Change cursor dynamically, depending on the context.
+;;
+;; Filename: cursor-chg.el
+;; Description: Change cursor dynamically, depending on the context.
+;; Author: Drew Adams
+;; Maintainer: Drew Adams
+;; Copyright (C) 2006-2009, Drew Adams, all rights reserved.
+;; Created: Tue Aug 29 11:23:06 2006
+;; Version: 20.1
+;; Last-Updated: Sat Aug 1 15:14:46 2009 (-0700)
+;; By: dradams
+;; Update #: 191
+;; URL: http://www.emacswiki.org/cgi-bin/wiki/cursor-chg.el
+;; Keywords: cursor, accessibility
+;; Compatibility: GNU Emacs: 20.x, 21.x, 22.x, 23.x
+;;
+;; Features that might be required by this library:
+;;
+;; None
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;; Commentary:
+;;
+;; This library provides three kinds of changes to the text cursor:
+;;
+;; 1. When a buffer is read-only or is in overwrite mode, the cursor
+;; type changes to `curchg-overwrite/read-only-cursor-type'. This
+;; is controlled by command `change-cursor-mode' and user option
+;; `curchg-change-cursor-on-overwrite/read-only-flag'.
+;;
+;; 2. When an input method is in use, the cursor color changes to
+;; `curchg-input-method-cursor-color'. This is controlled by
+;; command `change-cursor-mode' and user option
+;; `curchg-change-cursor-on-input-method-flag'.
+;;
+;; 3. When Emacs is idle, the cursor type changes to
+;; `curchg-idle-cursor-type'. This is controlled by command
+;; `toggle-cursor-type-when-idle'.
+;;
+;; To turn on all three types of cursor change by default, put the
+;; following in your Emacs init file (~/.emacs):
+;;
+;; (require 'cursor-chg) ; Load this library
+;; (change-cursor-mode 1) ; On for overwrite/read-only/input mode
+;; (toggle-cursor-type-when-idle 1) ; On when idle
+;;
+;; Note: Library `oneonone.el' provides the same functionality as
+;; library `cursor-chg.el', and more. If you use library
+;; `oneonone.el', then do NOT also use library `cursor-chg.el'.
+;;
+;; Note for Emacs 20: There is a bug in Emacs 20 which can lead to a
+;; fatal error (Emacs crash) when using `query-replace' with
+;; idle-cursor change enabled. If you use Emacs 20, then consider
+;; using `toggle-cursor-type-when-idle' to disable idle-cursor change
+;; while you use `query-replace'.
+;;
+;; User options defined here:
+;;
+;; `curchg-change-cursor-on-input-method-flag',
+;; `curchg-change-cursor-on-overwrite/read-only-flag',
+;; `curchg-default-cursor-color', `curchg-default-cursor-type',
+;; `curchg-idle-cursor-type', `curchg-input-method-cursor-color',
+;; `curchg-overwrite/read-only-cursor-type'.
+;;
+;; Commands defined here:
+;;
+;; `change-cursor-mode', `curchg-change-cursor-when-idle-interval',
+;; `curchg-set-cursor-type', `curchg-toggle-cursor-type-when-idle',
+;; `set-cursor-type', `toggle-cursor-type-when-idle'.
+;;
+;; Internal variables defined here:
+;;
+;; `curchg-change-cursor-when-idle-p', `curchg-idle-interval',
+;; `curchg-idle-timer', `curchg-last-cursor-type'.
+;;
+;; Non-interactive functions defined here:
+;;
+;; `curchg-change-cursor-on-input-method',
+;; `curchg-change-cursor-on-overwrite/read-only',
+;; `curchg-change-cursor-to-idle-type',
+;; `curchg-change-cursor-to-idle-type-off'.
+;;
+;; Acknowledgements:
+;;
+;; The cursor-changing on input method and read-only was inspired by
+;; Juri Linkov <juri@jurta.org>. Joe Casadonte <joc@netaxs.com>
+;; wrote a similar hook (`joc-cursor-type-set-hook'), which he got
+;; from Steve Kemp...
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;; Change log:
+;;
+;; 2006/10/28 dadams
+;; curchg-default-cursor-color, curchg-input-method-cursor-color:
+;; Changed :type to 'color for Emacs 21+.
+;; 2006/09/04 dadams
+;; curchg-idle-timer: Cancel beforehand, and cancel after defining.
+;; curchg-toggle-cursor-type-when-idle:
+;; Use curchg-change-cursor-to-idle-type-off on pre-command-hook.
+;; Don't read an event; just turn it on.
+;; Added: curchg-change-cursor-to-idle-type-off.
+;; 2006/09/03 dadams
+;; Created.
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2, or
+;; (at your option) any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+;; General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with this program; see the file COPYING. If not, write to
+;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
+;; Floor, Boston, MA 02110-1301, USA.
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;; Code:
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;;------- User Options -------------------------------------
+
+;; Emacs 20 only
+(unless (fboundp 'define-minor-mode)
+ (defcustom change-cursor-mode nil
+ "*Toggle changing cursor type and color.
+Setting this variable directly does not take effect;
+use either \\[customize] or command `change-cursor-mode'."
+ :set (lambda (symbol value) (change-cursor-mode (if value 1 -1)))
+ :initialize 'custom-initialize-default
+ :type 'boolean :group 'cursor :require 'cursor-chg))
+
+(defcustom curchg-change-cursor-on-input-method-flag t
+ "*Non-nil means to use a different cursor when using an input method."
+ :type 'boolean :group 'cursor)
+
+(defcustom curchg-change-cursor-on-overwrite/read-only-flag t
+ "*Non-nil means use a different cursor for overwrite mode or read-only."
+ :type 'boolean :group 'cursor)
+
+(defcustom curchg-default-cursor-color (or (cdr (assq 'cursor-color default-frame-alist))
+ "Red")
+ "*Default text cursor color for non-special frames."
+ :type (if (>= emacs-major-version 21) 'color 'string) :group 'cursor)
+
+(defcustom curchg-default-cursor-type 'bar "*Default text cursor type."
+ :type 'symbol :group 'cursor)
+
+(defcustom curchg-idle-cursor-type 'box
+ "*Text cursor type when Emacs is idle."
+ :type 'symbol :group 'cursor)
+
+(defcustom curchg-input-method-cursor-color "Orange"
+ "*Default cursor color if using an input method.
+This has no effect if `curchg-change-cursor-on-input-method-flag' is nil."
+ :type (if (>= emacs-major-version 21) 'color 'string) :group 'cursor)
+
+(defcustom curchg-overwrite/read-only-cursor-type 'box
+ "*Default text cursor type for overwrite mode or read-only buffer.
+This applies only to non-special frames. This has no effect if
+`curchg-change-cursor-on-overwrite/read-only-flag' is nil."
+ :type 'symbol :group 'cursor)
+
+
+;;------- Internal Variables -------------------------------
+
+(defvar curchg-last-cursor-type curchg-default-cursor-type "Saved last cursor type.")
+
+(defvar curchg-idle-interval 2
+ "Number of seconds to wait before changing to alternate cursor type.
+The alternate cursor type is `curchg-idle-cursor-type'.
+Do NOT change this yourself to change the wait period; instead, use
+`\\[curchg-change-cursor-when-idle-interval]'.")
+
+(defvar curchg-idle-timer
+ (progn ; Cancel to prevent duplication.
+ (when (boundp 'curchg-idle-timer) (cancel-timer curchg-idle-timer))
+ (run-with-idle-timer curchg-idle-interval t 'curchg-change-cursor-to-idle-type))
+ "Timer used to change the cursor to alternate type when Emacs is idle.")
+
+;; Turn it off, by default. You must use `toggle-cursor-type-when-idle' to turn it on.
+(cancel-timer curchg-idle-timer)
+
+(defvar curchg-change-cursor-when-idle-p nil
+ "Non-nil means to use an alternate cursor type whenever Emacs is idle.
+Do NOT change this yourself; instead, use `\\[toggle-cursor-type-when-idle]'.")
+
+
+;;------- Commands -----------------------------------------
+
+(unless (fboundp 'set-cursor-type) (defalias 'set-cursor-type 'curchg-set-cursor-type))
+;; This is essentially from Juri Linkov <juri@jurta.org>.
+(defun curchg-set-cursor-type (cursor-type)
+ "Set the cursor type of the selected frame to CURSOR-TYPE.
+When called interactively, prompt for the type to use.
+To get the frame's current cursor type, use `frame-parameters'."
+ (interactive
+ (list (intern (completing-read "Cursor type: "
+ (mapcar 'list '("box" "hollow" "bar" "hbar" nil))))))
+ (modify-frame-parameters (selected-frame) (list (cons 'cursor-type cursor-type))))
+
+(defalias 'toggle-cursor-type-when-idle 'curchg-toggle-cursor-type-when-idle)
+(defun curchg-toggle-cursor-type-when-idle (&optional arg)
+"Turn on or off automatically changing cursor type when Emacs is idle.
+When on, use `curchg-idle-cursor-type' whenever Emacs is idle.
+With prefix argument, turn on if ARG > 0; else turn off."
+ (interactive "P")
+ (setq curchg-change-cursor-when-idle-p
+ (if arg (> (prefix-numeric-value arg) 0) (not curchg-change-cursor-when-idle-p)))
+ (cond (curchg-change-cursor-when-idle-p
+ (timer-activate-when-idle curchg-idle-timer)
+ (add-hook 'pre-command-hook 'curchg-change-cursor-to-idle-type-off)
+ (message "Turned ON changing cursor when Emacs is idle."))
+ (t
+ (cancel-timer curchg-idle-timer)
+ (remove-hook 'pre-command-hook 'curchg-change-cursor-to-idle-type-off)
+ (message "Turned OFF changing cursor when Emacs is idle."))))
+
+(defun curchg-change-cursor-when-idle-interval (secs)
+ "Set wait until automatically change cursor type when Emacs is idle.
+Whenever Emacs is idle for this many seconds, the cursor type will
+change to `curchg-idle-cursor-type'.
+
+To turn on or off automatically changing the cursor type when idle,
+use `\\[toggle-cursor-type-when-idle]."
+ (interactive
+ "nSeconds to idle, before changing cursor type: ")
+ (timer-set-idle-time curchg-idle-timer
+ (setq curchg-idle-interval secs)
+ t))
+
+(if (fboundp 'define-minor-mode)
+ ;; Emacs 21 and later.
+ (define-minor-mode change-cursor-mode
+ "Toggle changing cursor type and color.
+With numeric ARG, turn cursor changing on if and only if ARG is positive.
+
+When this mode is on, `curchg-change-cursor-on-input-method' and
+`curchg-change-cursor-on-overwrite/read-only-flag' control cursor
+changing."
+ :init-value nil :global t :group 'frames
+ :link `(url-link :tag "Send Bug Report"
+ ,(concat "mailto:" "drew.adams" "@" "oracle" ".com?subject=\
+cursor-chg.el bug: \
+&body=Describe bug here, starting with `emacs -q'. \
+Don't forget to mention your Emacs and library versions."))
+ :link '(url-link :tag "Other Libraries by Drew"
+ "http://www.emacswiki.org/cgi-bin/wiki/DrewsElispLibraries")
+ :link '(url-link :tag "Download" "http://www.emacswiki.org/cgi-bin/wiki/cursor-chg.el")
+ :link '(url-link :tag "Description"
+ "http://www.emacswiki.org/cgi-bin/wiki/ChangingCursorDynamically")
+ :link '(emacs-commentary-link :tag "Commentary" "cursor-chg")
+ (cond (change-cursor-mode
+ (if curchg-change-cursor-on-overwrite/read-only-flag
+ (add-hook 'post-command-hook 'curchg-change-cursor-on-overwrite/read-only)
+ (curchg-set-cursor-type curchg-default-cursor-type)
+ (remove-hook 'post-command-hook 'curchg-change-cursor-on-overwrite/read-only))
+ (if curchg-change-cursor-on-input-method-flag
+ (add-hook 'post-command-hook 'curchg-change-cursor-on-input-method)
+ (setq current-input-method nil)
+ (curchg-change-cursor-on-input-method)
+ (remove-hook 'post-command-hook 'curchg-change-cursor-on-input-method)))
+ (t
+ (curchg-set-cursor-type curchg-default-cursor-type)
+ (setq current-input-method nil)
+ (curchg-change-cursor-on-input-method)
+ (remove-hook 'post-command-hook 'curchg-change-cursor-on-overwrite/read-only)
+ (remove-hook 'post-command-hook 'curchg-change-cursor-on-input-method))))
+
+ ;; Emacs 20
+ (defun change-cursor-mode (&optional arg)
+ "Toggle changing cursor type and color.
+With numeric ARG, turn cursor changing on if and only if ARG is positive.
+
+When this mode is on, `curchg-change-cursor-on-input-method' and
+`curchg-change-cursor-on-overwrite/read-only-flag' control cursor
+changing."
+ (interactive "P")
+ (setq change-cursor-mode
+ (if arg (> (prefix-numeric-value arg) 0) (not change-cursor-mode)))
+ (cond (change-cursor-mode
+ (if curchg-change-cursor-on-overwrite/read-only-flag
+ (add-hook 'post-command-hook 'curchg-change-cursor-on-overwrite/read-only)
+ (curchg-set-cursor-type curchg-default-cursor-type)
+ (remove-hook 'post-command-hook 'curchg-change-cursor-on-overwrite/read-only))
+ (if curchg-change-cursor-on-input-method-flag
+ (add-hook 'post-command-hook 'curchg-change-cursor-on-input-method)
+ (setq current-input-method nil)
+ (curchg-change-cursor-on-input-method)
+ (remove-hook 'post-command-hook 'curchg-change-cursor-on-input-method))
+ (message "Change cursor on overwrite/read-only: %s; on input method: %s"
+ (if curchg-change-cursor-on-overwrite/read-only-flag "ON" "OFF")
+ (if curchg-change-cursor-on-input-method-flag "ON" "OFF")))
+ (t
+ (curchg-set-cursor-type curchg-default-cursor-type)
+ (setq current-input-method nil)
+ (curchg-change-cursor-on-input-method)
+ (remove-hook 'post-command-hook 'curchg-change-cursor-on-overwrite/read-only)
+ (remove-hook 'post-command-hook 'curchg-change-cursor-on-input-method)
+ (message "Turned OFF changing cursor on overwrite/read-only and input method")))))
+
+
+;;------- Non-Interactive Functions ------------------------
+
+;; This is inspired by code from Juri Linkov <juri@jurta.org>.
+(defun curchg-change-cursor-on-input-method ()
+ "Set cursor type depending on whether an input method is used or not."
+ (set-cursor-color (if current-input-method
+ curchg-input-method-cursor-color
+ curchg-default-cursor-color)))
+
+;; This is from Juri Linkov <juri@jurta.org>, with read-only added.
+(defun curchg-change-cursor-on-overwrite/read-only ()
+ "Set cursor type differently for overwrite mode and read-only buffer.
+That is, use one cursor type for overwrite mode and read-only buffers,
+and another cursor type otherwise."
+ (curchg-set-cursor-type (if (or buffer-read-only overwrite-mode)
+ curchg-overwrite/read-only-cursor-type
+ curchg-default-cursor-type)))
+
+(defun curchg-change-cursor-to-idle-type ()
+ "Change the cursor to `curchg-idle-cursor-type' when Emacs is idle."
+ (let ((type (cdr (assoc 'cursor-type (frame-parameters)))))
+ (unless (eq type curchg-idle-cursor-type)
+ (setq curchg-last-cursor-type type)
+ (curchg-set-cursor-type curchg-idle-cursor-type))))
+
+(defun curchg-change-cursor-to-idle-type-off ()
+ "Turn off changing the cursor to `curchg-idle-cursor-type' when idle."
+ (when curchg-last-cursor-type (curchg-set-cursor-type curchg-last-cursor-type)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(provide 'cursor-chg)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; cursor-chg.el ends here
diff --git a/emacs.d/lisp/delphi-mode-ench.el b/emacs.d/lisp/delphi-mode-ench.el
index 04e017a..fcbb3ae 100644
--- a/emacs.d/lisp/delphi-mode-ench.el
+++ b/emacs.d/lisp/delphi-mode-ench.el
@@ -1,4 +1,10 @@
;;; delphi-mode-ench.el
+(require 'compile)
+(pushnew '("^\\([-a-zA-Z0-9\\.\\/_~]+\\)(\\([0-9]+\\),\\([0-9]+\\))\s\\([Ff]atal:\\|[Nn]ote:\\|[Ww]arning:\\|[Ee]rror:\\)\s\\(.*$\\)" 1 2 3)
+ compilation-error-regexp-alist)
+
+(setq auto-mode-alist (cons '("\\.pas" . delphi-mode) auto-mode-alist))
+
(setq delphi-unit-sections
'(implementation program library package))
@@ -55,7 +61,7 @@
(if pos (goto-char pos))
(re-search-forward "\\(begin\\|implementation\\)" nil t)
(let ((match (match-string-no-properties 1)))
- (if (or (equal match "implementation") (equal match "end")) 't 'nil)))))
+ (if (equal match "implementation") 't 'nil)))))
(defun delphi-in-class-definition (&optional pos)
(if pos (goto-char pos))
diff --git a/emacs.d/lisp/etags-table.el b/emacs.d/lisp/etags-table.el
new file mode 100644
index 0000000..5c33c8c
--- /dev/null
+++ b/emacs.d/lisp/etags-table.el
@@ -0,0 +1,157 @@
+;;; etags-table.el --- Set tags table(s) based on current file
+
+;; Copyright (C) 2008 Scott Frazer
+
+;; Author: Scott Frazer <frazer.scott@gmail.com>
+;; Maintainer: Scott Frazer <frazer.scott@gmail.com>
+;; Created: 28 Oct 2008
+;; Version: 1.1
+;; Keywords: etags tags tag
+
+;; This file is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; This file is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING. If not, write to
+;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; This extension sets the tags table(s) based on the current file.
+;; `etags-table-alist' is a list of lists, where the car of each sublist is
+;; compared to the current filename. If it matches, all the rest of the list
+;; elements are put on `tags-table-list'. If `etags-table-search-up-depth' is
+;; an integer, the file path will be searched upwards for a tags file. If one
+;; is found, it will be added to the tags table list; this is actually done
+;; first so the local TAGS file is at the head of the list.
+;;
+;; When you switch files and do something tag-related, the tags table list is
+;; automatically recomputed.
+
+;;; Change log:
+;;
+;; 27 Mar 2009 -- v1.1
+;; Add ability to use backreferences in etags-table-alist
+;; Change files to true names when adding to table
+;; Fix the way parent directories are found
+;;
+;; 28 Oct 2008 -- v1.0
+;; Initial release
+
+;;; Code:
+
+(require 'custom)
+(require 'etags)
+
+;;;###autoload
+(defgroup etags-table nil
+ "*etags table"
+ :group 'etags)
+
+;;;###autoload
+(defcustom etags-table-alist nil
+ "*Map filename to tag file(s)
+
+Example:
+
+(setq etags-table-alist
+ (list
+ \'(\"/home/me/Projects/foo/.*\\\\.[ch]$\" \"/home/me/Projects/lib1/TAGS\" \"/home/me/Projects/lib2/TAGS\")
+ \'(\"/home/me/Projects/bar/.*\\\\.py$\" \"/home/me/Projects/python/common/TAGS\")
+ \'(\".*\\\\.[ch]$\" \"/usr/local/include/TAGS\")
+ ))
+
+A file named, for example, \"/home/me/Projects/foo/main.c\" would set the
+`tags-table-list' to a list of:
+
+\"/home/me/Projects/lib1/TAGS\"
+\"/home/me/Projects/lib2/TAGS\"
+\"/usr/local/include/TAGS\"
+
+and possibly a local tags file at the head of the list if `etags-table-search-up-depth'
+is non-nil. You can use \\&, \\1, etc. in the tag file names to substitute pieces
+captured with \\(\\) in the key.
+"
+ :group 'etags-table
+ :type 'alist)
+
+;;;###autoload
+(defcustom etags-table-search-up-depth nil
+ "*Max depth to search up for a tags file. nil means don't search."
+ :group 'etags-table
+ :type 'integer)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar etags-table-last-table-list nil
+ "Save the last table list so it can be reused if a new one is not found")
+
+(defun etags-table-build-table-list (filename)
+ "Build tags table list based on a filename"
+ (let (tables)
+
+ ;; Search up
+ (when etags-table-search-up-depth
+ (let ((depth etags-table-search-up-depth)
+ (dir (file-name-directory filename)))
+ (while (and (>= depth 0) dir)
+ (when (file-exists-p (concat dir "TAGS"))
+ (setq tables (list (concat dir "TAGS")))
+ (setq depth 0))
+ (setq dir (file-name-directory (directory-file-name dir)))
+ (setq depth (1- depth)))))
+
+ ;; Go through mapping alist
+ (mapc (lambda (mapping)
+ (let ((key (car mapping))
+ (tag-files (cdr mapping)))
+ (when (string-match key filename)
+ (mapc (lambda (tag-file)
+ (add-to-list 'tables (file-truename (replace-match tag-file t nil filename)) t))
+ tag-files))))
+ etags-table-alist)
+
+ ;; Return result or the original list
+ (setq etags-table-last-table-list
+ (or tables tags-table-list etags-table-last-table-list))))
+
+(defun etags-table-recompute ()
+ (when (and (or etags-table-alist etags-table-search-up-depth) (buffer-file-name))
+ (setq tags-table-list (etags-table-build-table-list (buffer-file-name)))))
+
+(defadvice visit-tags-table-buffer (before etags-table-recompute activate)
+ "Recompute `tags-table-list'"
+ (etags-table-recompute))
+
+(defadvice tags-completion-table (before etags-table-clear-completion-table activate)
+ "Clear the completion table (maybe)"
+ (etags-table-recompute)
+ (unless (equal tags-table-computed-list-for (mapcar 'tags-expand-table-name tags-table-list))
+ (etags-table-clear-completion-table)))
+
+(defun etags-table-clear-completion-table ()
+ "Clear the tags completion table"
+ (interactive)
+ (setq tags-completion-table nil))
+
+(eval-after-load "etags-select"
+ '(progn
+ (defadvice etags-select-get-tag-files (before etags-table-recompute activate)
+ "Recompute `tags-table-list'"
+ (etags-table-recompute))
+ (defadvice etags-select-find-tag (before etags-table-clear-completion-table activate)
+ "Clear the completion table (maybe)"
+ (etags-table-recompute)
+ (unless (equal tags-table-computed-list-for (mapcar 'tags-expand-table-name tags-table-list))
+ (setq tags-completion-table nil)))))
+
+(provide 'etags-table)
+;;; etags-table.el ends here
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-19 20:18:18 +0000