From d573b7413e267aae0c32e083cec45d583ccf0562 Mon Sep 17 00:00:00 2001 From: Alexander Sulfrian Date: Wed, 13 Jan 2010 06:25:15 +0100 Subject: heavy update of emacs configs --- emacs.d/lisp/auto-complete/auto-complete-etags.el | 60 ++ emacs.d/lisp/auto-complete/auto-complete.el | 1138 ++++++++++++++++++++ emacs.d/lisp/cursor-chg.el | 348 ++++++ emacs.d/lisp/delphi-mode-ench.el | 8 +- emacs.d/lisp/etags-table.el | 157 +++ .../delphi-mode/constructor, destructor.yasnippet | 2 +- emacs.d/snippets/delphi-mode/dbg.yasnippet | 6 + .../snippets/delphi-mode/func-prototype.yasnippet | 4 +- emacs.d/snippets/delphi-mode/func.yasnippet | 2 +- .../delphi-mode/procedure-prototype.yasnippet | 4 +- emacs.d/snippets/delphi-mode/procedure.yasnippet | 2 +- emacs.d/templates/TEMPLATE.hpp.tpl | 32 + emacs.d/update-etags | 18 + 13 files changed, 1773 insertions(+), 8 deletions(-) create mode 100644 emacs.d/lisp/auto-complete/auto-complete-etags.el create mode 100644 emacs.d/lisp/auto-complete/auto-complete.el create mode 100644 emacs.d/lisp/cursor-chg.el create mode 100644 emacs.d/lisp/etags-table.el create mode 100644 emacs.d/snippets/delphi-mode/dbg.yasnippet create mode 100644 emacs.d/templates/TEMPLATE.hpp.tpl create mode 100755 emacs.d/update-etags (limited to 'emacs.d') 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 +;; 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 . + +;;; 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 ) +;; * 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 +;; * 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 , 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 +;; * 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 ) +;; - 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 . Joe Casadonte +;; 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 . +(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 . +(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 , 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 +;; Maintainer: Scott Frazer +;; 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 diff --git a/emacs.d/snippets/delphi-mode/constructor, destructor.yasnippet b/emacs.d/snippets/delphi-mode/constructor, destructor.yasnippet index 33a52ed..114f30e 100644 --- a/emacs.d/snippets/delphi-mode/constructor, destructor.yasnippet +++ b/emacs.d/snippets/delphi-mode/constructor, destructor.yasnippet @@ -6,4 +6,4 @@ # -- constructor Create(${1:}); destructor Destroy; override; -$0 \ No newline at end of file + $0$> \ No newline at end of file diff --git a/emacs.d/snippets/delphi-mode/dbg.yasnippet b/emacs.d/snippets/delphi-mode/dbg.yasnippet new file mode 100644 index 0000000..66fc15f --- /dev/null +++ b/emacs.d/snippets/delphi-mode/dbg.yasnippet @@ -0,0 +1,6 @@ +# -*- mode: snippet -*- +# contributor : Alexander Sulfrian +# name: dbg +# -- +DebugWriteln($1); + $0$> \ No newline at end of file diff --git a/emacs.d/snippets/delphi-mode/func-prototype.yasnippet b/emacs.d/snippets/delphi-mode/func-prototype.yasnippet index cae55d7..2344f07 100644 --- a/emacs.d/snippets/delphi-mode/func-prototype.yasnippet +++ b/emacs.d/snippets/delphi-mode/func-prototype.yasnippet @@ -4,5 +4,5 @@ # key: func # condition: (delphi-in-class-definition) # -- -function ${1:Name$(capitalize text)}($2): $3; -$0 \ No newline at end of file +function ${1:Name$(upcase-initials text)}($2): $3; + $0$> \ No newline at end of file diff --git a/emacs.d/snippets/delphi-mode/func.yasnippet b/emacs.d/snippets/delphi-mode/func.yasnippet index a42a598..31fe413 100644 --- a/emacs.d/snippets/delphi-mode/func.yasnippet +++ b/emacs.d/snippets/delphi-mode/func.yasnippet @@ -4,7 +4,7 @@ # key: func # condition: (not (delphi-in-class-definition)) # -- -function ${1:$$(yas/choose-value (let (value) (dolist (element (delphi-get-classes) value) (setq value (cons (concat element ".") value)))))}${2:Name$(capitalize text)}($3): $4; +function ${1:$$(yas/choose-value (let (value) (dolist (element (delphi-get-classes) value) (setq value (cons (concat element ".") value)))))}${2:Name$(upcase-initials text)}($3): $4; begin $0 end; \ No newline at end of file diff --git a/emacs.d/snippets/delphi-mode/procedure-prototype.yasnippet b/emacs.d/snippets/delphi-mode/procedure-prototype.yasnippet index 09927ac..3c1d8cb 100644 --- a/emacs.d/snippets/delphi-mode/procedure-prototype.yasnippet +++ b/emacs.d/snippets/delphi-mode/procedure-prototype.yasnippet @@ -4,5 +4,5 @@ # key: proc # condition: (delphi-in-class-definition) # -- -procedure ${1:Name$(capitalize text)}($2); -$0 \ No newline at end of file +procedure ${1:Name$(upcase-initials text)}($2); + $0$> \ No newline at end of file diff --git a/emacs.d/snippets/delphi-mode/procedure.yasnippet b/emacs.d/snippets/delphi-mode/procedure.yasnippet index 9e3a08e..6039ad8 100644 --- a/emacs.d/snippets/delphi-mode/procedure.yasnippet +++ b/emacs.d/snippets/delphi-mode/procedure.yasnippet @@ -4,7 +4,7 @@ # key: proc # condition: (not (delphi-in-class-definition)) # -- -procedure ${1:$$(yas/choose-value (let (value) (dolist (element (delphi-get-classes) value) (setq value (cons (concat element ".") value)))))}${2:Name$(capitalize text)}($3); +procedure ${1:$$(yas/choose-value (let (value) (dolist (element (delphi-get-classes) value) (setq value (cons (concat element ".") value)))))}${2:Name$(upcase-initials text)}($3); begin $0 end; \ No newline at end of file diff --git a/emacs.d/templates/TEMPLATE.hpp.tpl b/emacs.d/templates/TEMPLATE.hpp.tpl new file mode 100644 index 0000000..02fc06f --- /dev/null +++ b/emacs.d/templates/TEMPLATE.hpp.tpl @@ -0,0 +1,32 @@ +/* + * UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * 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 + * 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; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ + +#ifndef (>>>FILE_UPCASE<<<)_HPP +#define (>>>FILE_UPCASE<<<)_HPP + +(>>>POINT<<<) + +#endif diff --git a/emacs.d/update-etags b/emacs.d/update-etags new file mode 100755 index 0000000..88cc4f4 --- /dev/null +++ b/emacs.d/update-etags @@ -0,0 +1,18 @@ +#!/bin/bash + +LANGUAGE=$1 +ACCEPTED_EXTENSION="$(echo $2|sed 's/|/ /g')" +BASE_DIR=$3 +FILE_EXT=${4##*.} + +echo "test1" | logger + +[[ -z ${FILE_EXT} ]] && exit + +processing= +for extension in $ACCEPTED_EXTENSION;do + [[ $extension == $FILE_EXT ]] && processing=true +done + +echo "test" | logger +find ${BASE_DIR} ! -wholename './.git/*' -a ! -wholename './.svn/*' -a ! -name '*.pyc' -a ! -name '*~' -a ! -name '*#' -a ! -name '*.o' -a ! -name '*.ppu' -print0 | xargs -0 etags -o ${BASE_DIR}/TAGS 2>/dev/null >/dev/null -- cgit v1.2.3