Added emacs config

This commit is contained in:
Tom Willemsen 2010-12-05 12:41:38 +01:00
parent 6081172251
commit 15d8264356
25 changed files with 32610 additions and 14 deletions

5
.gitignore vendored
View file

@ -1,10 +1,11 @@
*~ *~
*session.* *session.*
*\#* *\#*
.emacs.d/ac-comphist.dat *.dat
local_* local_*
local_rc.lua
feeds feeds
fetchlog fetchlog
log log
error.log error.log
*.elc
auto-save-list

314
emacs Normal file
View file

@ -0,0 +1,314 @@
;; -*- mode: Emacs-Lisp; mode: whitespace -*-
(add-to-list 'load-path "~/.emacs.d")
;; Requires
(require 'paren)
(require 'uniquify)
(require 'autopair)
(require 'color-theme)
(require 'flymake)
(require 'org-install)
(require 'zenburn)
(require 'lua-mode)
(require 'tabbar)
(require 'minimap)
(require 'manage-org)
;; Auto complete
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "~/.emacs.d//ac-dict")
(ac-config-default)
;; Autoloads
(autoload 'vala-mode
"vala-mode.elc" "A Major mode for editing Vala files" t)
(autoload 'csharp-mode
"csharp-mode.elc" "A Major mode for editing C# files" t)
(autoload 'javascript-mode
"javascript.elc" "A Major mode for editing JavaScript files" t)
(autoload 'sqlplus-mode
"sqlplus,elc" "A Major mode for communicating with Oracle" t)
(autoload 'batch-mode
"batch-mode.elc" "A Major mode for editing Batch files" t)
(autoload 'rainbow-mode
"rainbow-mode.elc" "A Minor mode for showing colors inline" t)
;; Functions
(require 'functions)
;; Platform specifics
(if (eq system-type 'gnu/linux) ; if we're running linux
(set-frame-font "-xos4-terminus-medium-*-*-*-14-*-*-*-*-*-*-*"))
;; Variables
(setq
inhibit-startup-message t ; don't show welcom screen
require-final-newline t ; always append a newline to a file, if
; it doesn't have one
font-lock-maximum-decoration t ; denotes my interest in maximum
; possible fontification
uniquify-buffer-name-style 'reverse ; reverse uniquify file names
backup-directory-alist `((".*" . ,temporary-file-directory))
; backup file location
auto-save-file-name-transforms `((".*" ,temporary-file-directory t))
; autosave file location
whitespace-line-column 80 ; change color after the 80th column
whitespace-style '(tabs trailing lines-tail)
inhibit-default-init t)
(setq org-todo-keywords (quote ((sequence "TODO(t)"
"NEXT(n)"
"|" "Done(d!/!)")
(sequence "WAITING(w@/!)"
"SOMEDAY(s!)"
"|" "CANCELLED(c@/!)")
(sequence "QUOTE(q!)"
"QUOTED(Q!)"
"|" "APPROVED(A@)"
"EXPIRED(E@)"
"REJECTED(R@)")
(sequence "OPEN(O)"
"|" "CLOSED(C)")) ))
(setq org-todo-keyword-faces
(quote (("TODO" :foreground "red" :weight bold)
("NEXT" :foreground "blue" :weight bold)
("DONE" :foreground "forest green" :weight bold)
("WAITING" :foreground "yellow" :weight bold)
("SOMEDAY" :foreground "goldenrod" :weight bold)
("CANCELLED" :foreground "orangered" :weight bold)
("QUOTE" :foreground "hotpink" :weight bold)
("QUOTED" :foreground "indianred1" :weight bold)
("APPROVED" :foreground "forest green" :weight bold)
("EXPIRED" :foreground "olivedrab1" :weight bold)
("REJECTED" :foreground "olivedrab" :weight bold)
("OPEN" :foreground "magenta" :weight bold)
("CLOSED" :foreground "forest green" :weight bold))))
(setq org-use-fast-todo-selection t)
(setq org-todo-state-tags-triggers
(quote (("CANCELLED"
("CANCELLED" . t))
("WAITING"
("WAITING" . t))
("SOMEDAY"
("WAITING" . t))
(done
("WAITING"))
("TODO"
("WAITING")
("CANCELLED"))
("NEXT"
("WAITING"))
("DONE"
("WAITING")
("CANCELED")))))
(setq org-default-notes-file "~/prj/org/refile.org")
(setq org-capture-templates
(quote (("t" "todo" entry (file "~/prj/org/refile.org") "* TODO %?
%U
%a" :clock-in t :clock-resume t)
("n" "note" entry (file "~/prj/org/refile.org") "* %?
%U
%a
:CLOCK:
:END:" :clock-in t :clock-resume t))))
(setq org-completion-use-ido t) ; Use IDO for target completion
(setq org-refile-targets
(quote ((org-agenda-files :maxlevel . 5) (nil :maxlevel . 5))))
; Targets include this file and any file
; and any file contributing to the
; agenda - up to 5 levels deep
(setq org-refile-use-outline-path (quote file))
; Targets start with the file name -
; allows creating level 1 tasks
(setq org-outline-path-complete-in-steps t)
; Targets complete in steps so we start
; with filename, TAB shows the next
; level of targets etc
(setq org-refile-allow-creating-parent-nodes (quote confirm))
; Allow refile to create parent tasks
; with confirmation
(setq org-agenda-custom-commands
(quote
(("w" "Tasks waiting on something"
tags "WAITING/!"
((org-use-tag-inheritance nil)
(org-agenda-todo-ignore-scheduled nil)
(org-agenda-todo-ignore-deadlines nil)
(org-agenda-todo-ignore-with-date nil)
(org-agenda-overriding-header "Waiting Tasks")))
("r" "Refile New Notes and Tasks"
tags "LEVEL=1+REFILE"
((org-agenda-todo-ignore-with-date nil)
(org-agenda-todo-ignore-deadlines nil)
(org-agenda-todo-ignore-scheduled nil)
(org-agenda-overriding-header "Tasks to Refile")))
("N" "Notes"
tags "NOTE"
((org-agenda-overriding-header "Notes")))
("n" "Next"
tags-todo "-WAITING-CANCELLED/!NEXT"
((org-agenda-overriding-heaer "Next Tasks")))
("p" "Projects"
tags-todo "LEVEL=2-REFILE|LEVEL=1+REFILE/!-DONE-CANCELLED"
(;(org-agenda-skip-function 'bh/skip-non-projects)
(org-agenda-overriding-header "Projects")))
("o" "other (Non-Project) tasks"
tags-todo "LEVEL=2-REFILE|LEVEL=1+REFILE/!-DONE-CANCELLED"
(;(org-agenda-skip-function 'bh/skip-projects)
(org-agenda-overriding-header "Other Non-Project Tasks")))
("A" "Tasks to be Archived"
tags "LEVEL=2-REFILE/DONE|CANCELLED"
((org-agenda-overriding-header "Tasks to Archive")))
("h" "Habits"
tags "STYLE=\"habit\""
((org-agenda-todo-ignore-with-date nil)
(org-agenda-todo-ignore-scheduled nil)
(org-agenda-todo-ignore-deadlines nil)
(org-agenda-overriding-header "Habits")))
("#" "Stuck Projects"
tags-todo "LEVEL=2-REFILE|LEVEL=1+REFILE/!-DONE-CANCELLED"
((org-agenda-skip-function 'bh/skip-non-stuck-projects)
(org-agenda-overriding-header "Stuck Projects")))
("c" "Select default clocking task"
tags "LEVEL=2-REFILE"
((org-agenda-skip-function
'(org-agenda-skip-subree-if 'notregexp "^\\*\\* Organization"))
(org-agenda-overriding-header
"Set default clocking task with C-u C-u I"))))))
(setq-default indent-tabs-mode nil) ; spaces, no tabs
(fset 'yes-or-no-p 'y-or-n-p) ; switch yes or no answers to y or n
; answers
;; Mode settings
( tool-bar-mode -1) ; no toolbar
( menu-bar-mode -1) ; no menu
( line-number-mode -1) ; don't show line numbers in splitter
( global-linum-mode t) ; show line numbers in gutter
( column-number-mode t) ; show column numbers in splitter
(global-font-lock-mode t) ; show syntax highlighting
( show-paren-mode t) ; show matching parens
( autopair-global-mode ) ; enable autopair mode
(delete-selection-mode t) ; delete selection upon typing
(global-auto-complete-mode -1) ; don't enable autocomplete for
; everything
;; Keybindings
(global-set-key "\C-m" 'newline-and-indent) ; Automatically indent on newline
;;; Org Mode
(global-set-key "\C-cl" 'org-store-link )
(global-set-key "\C-ca" 'org-agenda )
(global-set-key "\C-cb" 'org-iswitchb )
(global-set-key (kbd "<f12>") 'org-agenda )
;(global-set-key (kbd "<f5>") 'bh/org-todo )
;(global-set-key (kbd "<S-f5>") 'bh/widen )
(global-set-key (kbd "<f7>") 'set-truncate-lines )
(global-set-key (kbd "<f8>") 'org-cycle-agenda-files )
;(global-set-key (kbd "<f9> b") 'bbdb )
(global-set-key (kbd "<f9> c") 'calendar )
(global-set-key (kbd "<f9> f") 'boxquote-insert-file )
;(global-set-key (kbd "<f9> g") 'gnus )
(global-set-key (kbd "<f9> h") 'bh/hide-other )
;(global-set-key (kbd "<f9> i") 'bh/org-info )
;(global-set-key (kbd "<f9> I") 'bh/clock-in )
;(global-set-key (kbd "<f9> O") 'bh/clock-out )
(global-set-key (kbd "<f9> r") 'boxquote-region )
(global-set-key (kbd "<f9> s") 'bh/go-to-scratch )
;(global-set-key (kbd "<f9> t") 'bh/insert-inactive-timestamp)
(global-set-key (kbd "<f9> u") 'bh/untabify )
(global-set-key (kbd "<f9> v") 'visible-mode )
;(global-set-key (kbd "<f9> SPC") 'bh/clock-in-last-task )
(global-set-key (kbd "C-<f9>") 'previous-buffer )
(global-set-key (kbd "C-x n r") 'narrow-to-region )
(global-set-key (kbd "C-<f10>") 'next-buffer )
(global-set-key (kbd "<f11>") 'org-clock-goto )
(global-set-key (kbd "C-<f11>") 'org-clock-in )
(global-set-key (kbd "C-s-<f12>") 'bh/save-then-publish )
(global-set-key (kbd "M-<f11>") 'org-resolve-clocks )
(global-set-key (kbd "C-M-r") 'org-capture )
(global-set-key (kbd "M-<f9>") 'bh/killframe )
(global-set-key [C-next] 'tabbar-forward )
(global-set-key [C-prior] 'tabbar-backward )
(global-set-key [C-tab] 'hs-toggle-hiding )
;; File associations
(add-to-list 'auto-mode-alist '("\\.vala$" . vala-mode))
(add-to-list 'auto-mode-alist '("\\.vapi$" . vala-mode))
(add-to-list 'auto-mode-alist '("\\.cs$" . csharp-mode))
(add-to-list 'auto-mode-alist '("\\.bat$" . batch-mode))
(add-to-list 'file-coding-system-alist '("\\.vala$" . utf-8))
(add-to-list 'file-coding-system-alist '("\\.vapi$" . utf-8))
(add-to-list 'compilation-finish-functions 'my-comp-finish-function)
;; Color theme
;;(require 'color-theme-weirdness)
(color-theme-zenburn)
;; Hooks
(add-hook 'find-file-hook 'flymake-find-file-hook)
(add-hook 'find-file-hook
(lambda ()
(whitespace-mode t)))
(add-hook 'after-save-hook
(lambda ()
(setq fname (buffer-file-name))
(setq suffix (file-name-extension fname))
(if (string-equal suffix "el")
(byte-compile-file fname))))
;;; C
(add-hook 'c-mode-hook
(lambda ()
(whitespace-mode t)
(hs-minor-mode t)))
;;; CSS
(add-hook 'css-mode-hook
(lambda ()
(rainbow-mode)))
;;; Emacs Lisp
(add-hook 'emacs-lisp-mode-hook
(lambda ()
(whitespace-mode t)
(auto-complete-mode t)))
;;; Interactive Lisp
(add-hook 'lisp-interaction-mode-hook
(lambda ()
(whitespace-mode t)
(auto-complete-mode t)))
;;; Org
(add-hook 'org-mode-hook
(lambda ()
(flyspell-mode 1)
(auto-fill-mode 1)
(message "org-mode started")))
(defvar org-loaded nil)
(add-hook 'org-agenda-mode-hook
(lambda ()
(if (not org-loaded)
(progn
(add-hook 'kill-emacs-hook
(lambda ()
(save-org-files)
(push-org-files)))
(get-org-files)
(setq org-loaded t)))))
(if (not (file-exists-p "~/prj/org"))
(clone-org-files))
(custom-set-variables
;; custom-set-variables was added by Custom.
;; If you edit it by hand, you could mess it up, so be careful.
;; Your init file should contain only one such instance.
;; If there is more than one, they won't work right.
'(org-agenda-files (quote ("~/prj/org/iactor.org" "~/prj/org/peitsman.org" "~/prj/org/tgn.org" "~/Documents/iACTOR/tasks.org" "~/prj/org/seiko.org" "~/prj/org/projects.org" "~/prj/org/refile.org" "~/prj/org/aethon.org")))
'(tabbar-mode t nil (tabbar)))
(custom-set-faces
;; custom-set-faces was added by Custom.
;; If you edit it by hand, you could mess it up, so be careful.
;; Your init file should contain only one such instance.
;; If there is more than one, they won't work right.
'(tabbar-selected ((t (:inherit tabbar-default :background "#1E2320" :foreground "#F0DFAF"))))
'(tabbar-unselected ((nil (:background "#3F3F3F" :foreground "#DCDCCC")))))

View file

@ -0,0 +1,480 @@
;;; auto-complete-config.el --- auto-complete additional configuations
;; Copyright (C) 2009, 2010 Tomohiro Matsuyama
;; Author: Tomohiro Matsuyama <m2ym.pub@gmail.com>
;; Keywords: convenience
;; Version: 1.3
;; 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:
;;
;;; Code:
(eval-when-compile
(require 'cl))
(require 'auto-complete)
;;;; Additional sources
;; imenu
(defvar ac-imenu-index nil)
(ac-clear-variable-every-10-minutes 'ac-imenu-index)
(defun ac-imenu-candidates ()
(loop with i = 0
with stack = (progn
(unless (local-variable-p 'ac-imenu-index)
(make-local-variable 'ac-imenu-index))
(or ac-imenu-index
(setq ac-imenu-index
(ignore-errors
(with-no-warnings
(imenu--make-index-alist))))))
with result
while (and stack (or (not (integerp ac-limit))
(< i ac-limit)))
for node = (pop stack)
if (consp node)
do
(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))
;; Remove extra characters
(if (string-match "^.*\\(()\\|=\\|<>\\)$" car)
(setq car (substring car 0 (match-beginning 1))))
(push car result)
(incf i))))
finally return (nreverse result)))
(ac-define-source imenu
'((depends imenu)
(candidates . ac-imenu-candidates)
(symbol . "s")))
;; gtags
(defface ac-gtags-candidate-face
'((t (:background "lightgray" :foreground "navy")))
"Face for gtags candidate"
:group 'auto-complete)
(defface ac-gtags-selection-face
'((t (:background "navy" :foreground "white")))
"Face for the gtags selected candidate."
:group 'auto-complete)
(defun ac-gtags-candidate ()
(ignore-errors
(split-string (shell-command-to-string (format "global -ci %s" ac-prefix)) "\n")))
(ac-define-source gtags
'((candidates . ac-gtags-candidate)
(candidate-face . ac-gtags-candidate-face)
(selection-face . ac-gtags-selection-face)
(requires . 3)
(symbol . "s")))
;; yasnippet
(defface ac-yasnippet-candidate-face
'((t (:background "sandybrown" :foreground "black")))
"Face for yasnippet candidate."
:group 'auto-complete)
(defface ac-yasnippet-selection-face
'((t (:background "coral3" :foreground "white")))
"Face for the yasnippet selected candidate."
:group 'auto-complete)
(defun ac-yasnippet-table-hash (table)
(cond
((fboundp 'yas/snippet-table-hash)
(yas/snippet-table-hash table))
((fboundp 'yas/table-hash)
(yas/table-hash table))))
(defun ac-yasnippet-table-parent (table)
(cond
((fboundp 'yas/snippet-table-parent)
(yas/snippet-table-parent table))
((fboundp 'yas/table-parent)
(yas/table-parent table))))
(defun ac-yasnippet-candidate-1 (table)
(with-no-warnings
(let ((hashtab (ac-yasnippet-table-hash table))
(parent (ac-yasnippet-table-parent table))
candidates)
(maphash (lambda (key value)
(push key candidates))
hashtab)
(setq candidates (all-completions ac-prefix (nreverse candidates)))
(if parent
(setq candidates
(append candidates (ac-yasnippet-candidate-1 parent))))
candidates)))
(defun ac-yasnippet-candidates ()
(with-no-warnings
(if (fboundp 'yas/get-snippet-tables)
;; >0.6.0
(apply 'append (mapcar 'ac-yasnippet-candidate-1 (yas/get-snippet-tables major-mode)))
(let ((table
(if (fboundp 'yas/snippet-table)
;; <0.6.0
(yas/snippet-table major-mode)
;; 0.6.0
(yas/current-snippet-table))))
(if table
(ac-yasnippet-candidate-1 table))))))
(ac-define-source yasnippet
'((depends yasnippet)
(candidates . ac-yasnippet-candidates)
(action . yas/expand)
(candidate-face . ac-yasnippet-candidate-face)
(selection-face . ac-yasnippet-selection-face)
(symbol . "a")))
;; semantic
(defun ac-semantic-candidates (prefix)
(with-no-warnings
(delete "" ; semantic sometimes returns an empty string
(mapcar 'semantic-tag-name
(ignore-errors
(or (semantic-analyze-possible-completions
(semantic-analyze-current-context))
(senator-find-tag-for-completion prefix)))))))
(ac-define-source semantic
'((available . (or (require 'semantic-ia nil t)
(require 'semantic/ia nil t)))
(candidates . (ac-semantic-candidates ac-prefix))
(prefix . c-dot-ref)
(requires . 0)
(symbol . "m")))
(ac-define-source semantic-raw
'((available . (or (require 'semantic-ia nil t)
(require 'semantic/ia nil t)))
(candidates . (ac-semantic-candidates ac-prefix))
(symbol . "s")))
;; eclim
(defun ac-eclim-candidates ()
(with-no-warnings
(loop for c in (eclim/java-complete)
collect (nth 1 c))))
(ac-define-source eclim
'((candidates . ac-eclim-candidates)
(prefix . c-dot)
(requires . 0)
(symbol . "f")))
;; css
;; Copied from company-css.el
(defconst ac-css-property-alist
;; see http://www.w3.org/TR/CSS21/propidx.html
'(("azimuth" angle "left-side" "far-left" "left" "center-left" "center"
"center-right" "right" "far-right" "right-side" "behind" "leftwards"
"rightwards")
("background" background-color background-image background-repeat
background-attachment background-position)
("background-attachment" "scroll" "fixed")
("background-color" color "transparent")
("background-image" uri "none")
("background-position" percentage length "left" "center" "right" percentage
length "top" "center" "bottom" "left" "center" "right" "top" "center"
"bottom")
("background-repeat" "repeat" "repeat-x" "repeat-y" "no-repeat")
("border" border-width border-style border-color)
("border-bottom" border)
("border-bottom-color" border-color)
("border-bottom-style" border-style)
("border-bottom-width" border-width)
("border-collapse" "collapse" "separate")
("border-color" color "transparent")
("border-left" border)
("border-left-color" border-color)
("border-left-style" border-style)
("border-left-width" border-width)
("border-right" border)
("border-right-color" border-color)
("border-right-style" border-style)
("border-right-width" border-width)
("border-spacing" length length)
("border-style" border-style)
("border-top" border)
("border-top-color" border-color)
("border-top-style" border-style)
("border-top-width" border-width)
("border-width" border-width)
("bottom" length percentage "auto")
("caption-side" "top" "bottom")
("clear" "none" "left" "right" "both")
("clip" shape "auto")
("color" color)
("content" "normal" "none" string uri counter "attr()" "open-quote"
"close-quote" "no-open-quote" "no-close-quote")
("counter-increment" identifier integer "none")
("counter-reset" identifier integer "none")
("cue" cue-before cue-after)
("cue-after" uri "none")
("cue-before" uri "none")
("cursor" uri "*" "auto" "crosshair" "default" "pointer" "move" "e-resize"
"ne-resize" "nw-resize" "n-resize" "se-resize" "sw-resize" "s-resize"
"w-resize" "text" "wait" "help" "progress")
("direction" "ltr" "rtl")
("display" "inline" "block" "list-item" "run-in" "inline-block" "table"
"inline-table" "table-row-group" "table-header-group" "table-footer-group"
"table-row" "table-column-group" "table-column" "table-cell"
"table-caption" "none")
("elevation" angle "below" "level" "above" "higher" "lower")
("empty-cells" "show" "hide")
("float" "left" "right" "none")
("font" font-style font-variant font-weight font-size "/" line-height
font-family "caption" "icon" "menu" "message-box" "small-caption"
"status-bar")
("font-family" family-name generic-family)
("font-size" absolute-size relative-size length percentage)
("font-style" "normal" "italic" "oblique")
("font-variant" "normal" "small-caps")
("font-weight" "normal" "bold" "bolder" "lighter" "100" "200" "300" "400"
"500" "600" "700" "800" "900")
("height" length percentage "auto")
("left" length percentage "auto")
("letter-spacing" "normal" length)
("line-height" "normal" number length percentage)
("list-style" list-style-type list-style-position list-style-image)
("list-style-image" uri "none")
("list-style-position" "inside" "outside")
("list-style-type" "disc" "circle" "square" "decimal" "decimal-leading-zero"
"lower-roman" "upper-roman" "lower-greek" "lower-latin" "upper-latin"
"armenian" "georgian" "lower-alpha" "upper-alpha" "none")
("margin" margin-width)
("margin-bottom" margin-width)
("margin-left" margin-width)
("margin-right" margin-width)
("margin-top" margin-width)
("max-height" length percentage "none")
("max-width" length percentage "none")
("min-height" length percentage)
("min-width" length percentage)
("orphans" integer)
("outline" outline-color outline-style outline-width)
("outline-color" color "invert")
("outline-style" border-style)
("outline-width" border-width)
("overflow" "visible" "hidden" "scroll" "auto")
("padding" padding-width)
("padding-bottom" padding-width)
("padding-left" padding-width)
("padding-right" padding-width)
("padding-top" padding-width)
("page-break-after" "auto" "always" "avoid" "left" "right")
("page-break-before" "auto" "always" "avoid" "left" "right")
("page-break-inside" "avoid" "auto")
("pause" time percentage)
("pause-after" time percentage)
("pause-before" time percentage)
("pitch" frequency "x-low" "low" "medium" "high" "x-high")
("pitch-range" number)
("play-during" uri "mix" "repeat" "auto" "none")
("position" "static" "relative" "absolute" "fixed")
("quotes" string string "none")
("richness" number)
("right" length percentage "auto")
("speak" "normal" "none" "spell-out")
("speak-header" "once" "always")
("speak-numeral" "digits" "continuous")
("speak-punctuation" "code" "none")
("speech-rate" number "x-slow" "slow" "medium" "fast" "x-fast" "faster"
"slower")
("stress" number)
("table-layout" "auto" "fixed")
("text-align" "left" "right" "center" "justify")
("text-decoration" "none" "underline" "overline" "line-through" "blink")
("text-indent" length percentage)
("text-transform" "capitalize" "uppercase" "lowercase" "none")
("top" length percentage "auto")
("unicode-bidi" "normal" "embed" "bidi-override")
("vertical-align" "baseline" "sub" "super" "top" "text-top" "middle"
"bottom" "text-bottom" percentage length)
("visibility" "visible" "hidden" "collapse")
("voice-family" specific-voice generic-voice "*" specific-voice
generic-voice)
("volume" number percentage "silent" "x-soft" "soft" "medium" "loud"
"x-loud")
("white-space" "normal" "pre" "nowrap" "pre-wrap" "pre-line")
("widows" integer)
("width" length percentage "auto")
("word-spacing" "normal" length)
("z-index" "auto" integer))
"A list of CSS properties and their possible values.")
(defconst ac-css-value-classes
'((absolute-size "xx-small" "x-small" "small" "medium" "large" "x-large"
"xx-large")
(border-style "none" "hidden" "dotted" "dashed" "solid" "double" "groove"
"ridge" "inset" "outset")
(color "aqua" "black" "blue" "fuchsia" "gray" "green" "lime" "maroon" "navy"
"olive" "orange" "purple" "red" "silver" "teal" "white" "yellow"
"rgb")
(counter "counter")
(family-name "Courier" "Helvetica" "Times")
(generic-family "serif" "sans-serif" "cursive" "fantasy" "monospace")
(generic-voice "male" "female" "child")
(margin-width "auto") ;; length percentage
(relative-size "larger" "smaller")
(shape "rect")
(uri "url"))
"A list of CSS property value classes and their contents.")
(defconst ac-css-pseudo-classes
'("active" "after" "before" "first" "first-child" "first-letter" "first-line"
"focus" "hover" "lang" "left" "link" "right" "visited")
"Identifiers for CSS pseudo-elements and pseudo-classes.")
(defvar ac-css-property nil
"Current editing property.")
(defun ac-css-prefix ()
(when (save-excursion (re-search-backward "\\_<\\(.+?\\)\\_>\\s *:.*\\=" nil t))
(setq ac-css-property (match-string 1))
(or (ac-prefix-symbol) (point))))
(defun ac-css-property-candidates ()
(or (loop with list = (assoc-default ac-css-property ac-css-property-alist)
with value
while (setq value (pop list))
if (symbolp value)
do (setq list
(append list
(or (assoc-default value ac-css-value-classes)
(assoc-default (symbol-name value) ac-css-property-alist))))
else collect value)
ac-css-pseudo-classes))
(defvar ac-source-css-property
'((candidates . ac-css-property-candidates)
(prefix . ac-css-prefix)
(requires . 0)))
;;;; Not maintained sources
;; ropemacs
(defvar ac-ropemacs-loaded nil)
(defun ac-ropemacs-require ()
(with-no-warnings
(unless ac-ropemacs-loaded
(pymacs-load "ropemacs" "rope-")
(if (boundp 'ropemacs-enable-autoimport)
(setq ropemacs-enable-autoimport t))
(setq ac-ropemacs-loaded t))))
(defun ac-ropemacs-setup ()
(ac-ropemacs-require)
;(setq ac-sources (append (list 'ac-source-ropemacs) ac-sources))
(setq ac-omni-completion-sources '(("\\." ac-source-ropemacs))))
(defun ac-ropemacs-initialize ()
(autoload 'pymacs-apply "pymacs")
(autoload 'pymacs-call "pymacs")
(autoload 'pymacs-eval "pymacs" nil t)
(autoload 'pymacs-exec "pymacs" nil t)
(autoload 'pymacs-load "pymacs" nil t)
(add-hook 'python-mode-hook 'ac-ropemacs-setup)
t)
(defvar ac-ropemacs-completions-cache nil)
(defvar ac-source-ropemacs
'((init
. (lambda ()
(setq ac-ropemacs-completions-cache
(mapcar
(lambda (completion)
(concat ac-prefix completion))
(ignore-errors
(rope-completions))))))
(candidates . ac-ropemacs-completions-cache)))
;; rcodetools
(defvar ac-source-rcodetools
'((init . (lambda ()
(require 'rcodetools)
(condition-case x
(save-excursion
(rct-exec-and-eval rct-complete-command-name "--completion-emacs-icicles"))
(error) (setq rct-method-completion-table nil))))
(candidates . (lambda ()
(all-completions
ac-prefix
(mapcar
(lambda (completion)
(replace-regexp-in-string "\t.*$" "" (car completion)))
rct-method-completion-table))))))
;;;; Default settings
(defun ac-common-setup ()
(add-to-list 'ac-sources 'ac-source-filename))
(defun ac-emacs-lisp-mode-setup ()
(setq ac-sources (append '(ac-source-features ac-source-functions ac-source-yasnippet ac-source-variables ac-source-symbols) ac-sources)))
(defun ac-cc-mode-setup ()
(setq ac-sources (append '(ac-source-yasnippet ac-source-gtags) ac-sources)))
(defun ac-ruby-mode-setup ()
(make-local-variable 'ac-ignores)
(add-to-list 'ac-ignores "end"))
(defun ac-css-mode-setup ()
(setq ac-sources (append '(ac-source-css-property) ac-sources)))
(defun ac-config-default ()
(setq-default ac-sources '(ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers))
(add-hook 'emacs-lisp-mode-hook 'ac-emacs-lisp-mode-setup)
(add-hook 'c-mode-common-hook 'ac-cc-mode-setup)
(add-hook 'ruby-mode-hook 'ac-ruby-mode-setup)
(add-hook 'css-mode-hook 'ac-css-mode-setup)
(add-hook 'auto-complete-mode-hook 'ac-common-setup)
(global-auto-complete-mode t))
(provide 'auto-complete-config)
;;; auto-complete-config.el ends here

1897
emacs.d/auto-complete.el Normal file

File diff suppressed because it is too large Load diff

1036
emacs.d/autopair.el Normal file

File diff suppressed because it is too large Load diff

156
emacs.d/batch-mode.el Normal file
View file

@ -0,0 +1,156 @@
;;; batch-mode.el --- major mode for editing ESRI batch scrips
;;; Copyright (C) 2002, Agnar Renolen <agnar.renolen@emap.no>
;;; Modified (c) 2009, Matthew Fidler <matthew.fidler at gmail.com>
;;; Fixed indents (and labels)
;; batch-mode.el 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; if not, write to the Free Software
;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
;; This is version 1.0 of 21 August 2002.
;;; Comentary:
;; The batch-mode provides syntax hilighting and auto-indentation for
;; DOS batch files (.bat). and auto-idendation.
;; Agnar Renolen, <agnar.renolen@emap.no>
;;; Code:
(defgroup batch nil
"Major mode for editing batch code"
:prefix "batch-"
:group 'languages)
; (defvar batch-mode-hook nil
; "Hooks called when batch mode fires up."
; :type 'hook
; :group 'batch)
(defvar batch-mode-map nil
"Keymap used with batch code")
(defcustom batch-indent-level 4
"Amount by which batch subexpressions are indented."
:type 'integer
:group 'batch)
(defvar batch-font-lock-keywords
(eval-when-compile
(list
; since we can't specify batch comments through the syntax table,
; we have to specify it here, and override whatever is highlighted
'( "^[ \t]*rem\\>.*" (0 font-lock-comment-face t))
; since the argument to the echo command is a string, we format it
; as a string
'( "\\<echo\\>[ \t]*\\(.*\\)" (1 font-lock-string-face t))
; the argument of the goto statement is a label
'( "\\<goto\\>[ \t]*\\([a-zA-Z0-9_]+\\)" (1
font-lock-constant-face))
; the keywords of batch (which are not built-in commands)
(concat "\\<\\(cmdextversion\\|"
"d\\(efined\\|isableextensions\\|o\\)\\|"
"e\\(lse\\|n\\(ableextensions\\|dlocal\\)"
"\\|qu\\|rrorlevel\\|xist\\)\\|for\\|"
"goto\\|i[fn]\\|n\\(eq\\|ot\\)\\|setlocal\\)\\>")
; built-in DOS commands
(cons (concat "\\<\\(a\\(ssoc\\|t\\(\\|trib\\)\\)\\|break\\|"
"c\\(a\\(cls\\|ll\\)\\|d\\|h\\(cp\\|dir\\|k\\("
"dsk\\|ntfs\\)\\)\\|ls\\|md\\|o\\(lor\\|mp\\(\\|act\\)"
"\\|nvert\\|py\\)\\)\\|d\\(ate\\|el\\|i\\("
"r\\|skco\\(mp\\|py\\)\\)\\|oskey\\)\\|"
"e\\(cho\\|rase\\|xit\\)\\|"
"f\\(c\\|ind\\(\\|str\\)\\|for\\(\\|mot\\)\\|type\\)\\|"
"graftabl\\|help\\|label\\|"
"m\\(d\\|mkdir\\|o[dvr]e\\)\\|p\\(a\\(th\\|use\\)"
"\\|opd\\|r\\(int\\|opmt\\)\\|ushd\\)\\|"
"r\\(d\\|e\\(cover\\|n\\(\\|ame\\)\\|place\\)\\|mdir\\)\\|"
"s\\(et\\|hift\\|ort\\|tart\\|ubst\\)\\|"
"t\\(i\\(me\\|tle\\)\\|ree\\|ype\\)\\|"
"v\\(er\\(\\|ify\\)\\|ol\\)\\|xcopy\\)\\>")
'font-lock-builtin-face)
; variables are embeded in percent chars
'( "%[a-zA-Z0-9_]+%?" . font-lock-variable-name-face)
; labels are formatted as constants
'( ":[a-zA-Z0-9_]+" . font-lock-constant-face)
; command line switches are hilighted as type-face
'( "[-/][a-zA-Z0-9_]+" . font-lock-type-face)
; variables set should also be hilighted with variable-name-face
'( "\\<set\\>[ \t]*\\([a-zA-Z0-9_]+\\)" (1 font-lock-variable-name-face))
)))
;;;###autoload
(defun batch-mode ()
"Major mode for editing batch scripts."
(interactive)
(kill-all-local-variables)
(setq major-mode 'batch-mode)
(setq mode-name "Avenue")
(set (make-local-variable 'indent-line-function) 'batch-indent-line)
(set (make-local-variable 'comment-start) "rem")
(set (make-local-variable 'comment-start-skip) "rem[ \t]*")
(set (make-local-variable 'font-lock-defaults)
'(batch-font-lock-keywords nil t nil))
(run-hooks 'batch-mode-hook))
(defun batch-indent-line ()
"Indent current line as batch script"
(let ((indent (batch-calculate-indent))
beg shift-amt
(old-pos (- (point-max) (point))))
(beginning-of-line)
(setq beg (point))
(skip-chars-forward " \t")
(if (looking-at ")")
(setq indent (max (- indent batch-indent-level))))
(message "prev indent: %d" indent)
(setq shift-amt (- indent (current-column)))
(if (not (zerop shift-amt))
(progn
(delete-region beg (point))
; ArcView replaces tabs with single spaces, so we only insert
; spaces to make indentation correct in ArcView.
(insert-char ? indent)
(if (> (- (point-max) old-pos) (point))
(goto-char (- (point-max) old-pos)))))
shift-amt))
(defun batch-calculate-indent ()
"Return appropriate indentation for the current line as batch code."
(save-excursion
(beginning-of-line)
(current-indentation)
(if (bobp)
0
(if (re-search-backward "^[ \t]*[^ \t\n\r]" nil t)
(if (looking-at "[ \t]*\\()[ \t]*else\\|for\\|if\\)\\>[^(\n]*([^)\n]*")
(+ (current-indentation) batch-indent-level)
(if (looking-at "[ \t]*[^(]*)[ \t]*")
(- (current-indentation) batch-indent-level)
(current-indentation)))
0))))
(add-to-list 'auto-mode-alist '("\\.bat\\'" . batch-mode))
(provide 'batch-mode)
;;; batch-mode.el ends here

View file

@ -0,0 +1,101 @@
;; color-theme-gruber-dark.el
;; Revision 1
;;
;; Copyright (C) 2009-2010 Jason R. Blevins
;;
;; Permission is hereby granted, free of charge, to any person
;; obtaining a copy of this software and associated documentation
;; files (the "Software"), to deal in the Software without
;; restriction, including without limitation the rights to use,
;; copy, modify, merge, publish, distribute, sublicense, and/or sell
;; copies of the Software, and to permit persons to whom the
;; Software is furnished to do so, subject to the following
;; conditions:
;;
;; The above copyright notice and this permission notice shall be
;; included in all copies or substantial portions of the Software.
;;
;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
;; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
;; OTHER DEALINGS IN THE SOFTWARE.
(require 'color-theme)
(defun color-theme-gruber-darker ()
"Gruber Darker color theme for Emacs by Jason Blevins.
A darker variant of the Gruber Dark theme for BBEdit
by John Gruber."
(interactive)
(color-theme-install
'(color-theme-gruber-darker
((foreground-color . "#e4e4ef")
(background-color . "#181818")
(background-mode . dark)
(cursor-color . "#ffdd33")
(mouse-color . "#ffdd33"))
;; Standard font lock faces
(default ((t (nil))))
(font-lock-comment-face ((t (:foreground "#cc8c3c"))))
(font-lock-comment-delimiter-face ((t (:foreground "#cc8c3c"))))
(font-lock-doc-face ((t (:foreground "#73c936"))))
(font-lock-doc-string-face ((t (:foreground "#73c936"))))
(font-lock-string-face ((t (:foreground "#73c936"))))
(font-lock-keyword-face ((t (:foreground "#ffdd33"))))
(font-lock-builtin-face ((t (:foreground "#ffdd33"))))
(font-lock-function-name-face ((t (:foreground "#96a6c8"))))
(font-lock-variable-name-face ((t (:foreground "#f4f4ff"))))
(font-lock-preprocessor-face ((t (:foreground "#95a99f"))))
(font-lock-constant-face ((t (:foreground "#95a99f"))))
(font-lock-type-face ((t (:foreground "#95a99f"))))
(font-lock-warning-face ((t (:foreground "#f43841"))))
(font-lock-reference-face ((t (:foreground "#95a99f"))))
(trailing-whitespace ((t (:foreground "#000" :background "#f43841"))))
(link ((t (:foreground "#96A6C8" :underline t))))
;; Search
(isearch ((t (:foreground "#000" :background "#f5f5f5"))))
(isearch-lazy-highlight-face ((t (:foreground "#f4f4ff" :background "#5f627f"))))
(isearch-fail ((t (:foreground "#000" :background "#f43841"))))
;; User interface
(fringe ((t (:background "#111" :foreground "#444"))))
(border ((t (:background "#111" :foreground "#444"))))
(mode-line ((t (:background "#453d41" :foreground "#fff"))))
(mode-line-buffer-id ((t (:background "#453d41" :foreground "#fff"))))
(mode-line-inactive ((t (:background "#453d41" :foreground "#999"))))
(minibuffer-prompt ((t (:foreground "#96A6C8"))))
(region ((t (:background "#484848"))))
(secondary-selection ((t (:background "#484951" :foreground "#F4F4FF"))))
(tooltip ((t (:background "#52494e" :foreground "#fff"))))
;; Parenthesis matching
(show-paren-match-face ((t (:background "#52494e" :foreground "#f4f4ff"))))
(show-paren-mismatch-face ((t (:foreground "#f4f4ff" :background "#c73c3f"))))
;; Line highlighting
(highlight ((t (:background "#282828" :foreground nil))))
(highlight-current-line-face ((t (:background "#282828" :foreground nil))))
;; Calendar
(holiday-face ((t (:foreground "#f43841"))))
;; Info
(info-xref ((t (:foreground "#96a6c8"))))
(info-visited ((t (:foreground "#9e95c7"))))
;; AUCTeX
(font-latex-sectioning-5-face ((t (:foreground "#96a6c8" :bold t))))
(font-latex-bold-face ((t (:foreground "#95a99f" :bold t))))
(font-latex-italic-face ((t (:foreground "#95a99f" :italic t))))
(font-latex-math-face ((t (:foreground "#73c936"))))
(font-latex-string-face ((t (:foreground "#73c936"))))
(font-latex-warning-face ((t (:foreground "#f43841"))))
(font-latex-slide-title-face ((t (:foreground "#96a6c8"))))
)))
(provide 'color-theme-gruber-darker)

View file

@ -0,0 +1,18 @@
(require 'color-theme)
;; vibrant-ink color theme
(defun color-theme-vibrant-ink ()
(interactive)
(color-theme-install
'(color-theme-ryrobes
((background-color . "#000000")
(background-mode . dark)
(border-color . "#000000")
(cursor-color . "#FFFFFF")
(foreground-color . "#FFFFFF")
(mouse-color . "#FFFFFF"))
(font-lock-comment-face ((t (:foreground "#9933CC" :italic t))))
(font-lock-keyword-face ((t (:foreground "#FF6600"))))
(font-lock-type-face ((t (:foreground "#FFCC00"))))
(font-lock-string-face ((t (:foreground "#66FF00")))))))
(provide 'color-theme-vibrant-ink)

View file

@ -0,0 +1,37 @@
(require 'color-theme)
;; weirdness color-theme
(defun color-theme-weirdness ()
(interactive)
(color-theme-install
'(color-theme-weirdness
((background-color . "#000000")
(background-mode . dark)
(border-color . "#000000")
(cursor-color . "#FFFFFF")
(foreground-color . "#FFFFFF")
(mouse-color . "#000000"))
(org-level-1 ((t (:foreground "#5BFD5B" :weight normal))))
(org-level-2 ((t (:foreground "#379A37" :weight normal))))
(org-level-3 ((t (:foreground "#757575" :weight normal))))
(org-level-4 ((t (:foreground "#778899" :weight normal))))
(org-level-5 ((t (:foreground "#9898FF" :weight normal))))
(org-level-6 ((t (:foreground "#0000B0" :weight normal))))
(org-level-7 ((t (:foreground "#740091" :weight normal))))
(org-level-8 ((t (:foreground "#B275C1" :weight normal))))
(fringe ((t (:background "#000000"))))
(mode-line ((t (:foreground "#B3B3B3" :background "#43527A" :background "#000000" :box nil))))
(region ((t (:background "#3D3D3D"))))
(minibuffer-prompt ((t (:foreground "#72F3FF" :bold t))))
(flymake-warnline ((t (:background "#000060"))))
(flymake-errline ((t (:background "#600000"))))
(font-lock-builtin-face ((t (:foreground "#C436C4"))))
(font-lock-comment-face ((t (:foreground "#00AC00" :background "#004000" :bold t :box (:line-width 1 :color "#006000" :style nil)))))
(font-lock-comment-delimiter-face ((t (:inherit 'font-lock-comment-face))))
(font-lock-function-name-face ((t (:foreground "#0FFF28"))))
(font-lock-keyword-face ((t (:foreground "#4E61BB" :bold t))))
(font-lock-string-face ((t (:foreground "#E00900"))))
(font-lock-type-face ((t (:foreground "#8522DD"))))
(font-lock-variable-name-face ((t (:foreground "#18EFF2"))))
(font-lock-warning-face ((t (:foreground "#FF0000" :bold t)))))))
(provide 'color-theme-weirdness)

1668
emacs.d/color-theme.el Normal file

File diff suppressed because it is too large Load diff

1977
emacs.d/csharp-mode.el Normal file

File diff suppressed because it is too large Load diff

45
emacs.d/functions.el Normal file
View file

@ -0,0 +1,45 @@
(defun what-face (pos)
"Find out which face the current position uses"
(interactive "d")
(let ((face (or (get-char-property (point) 'read-face-name)
(get-char-property (point) 'face))))
(if face
(message "Face: %s" face)
(message "No face at %d" pos))))
(defun my-comp-finish-function (buf str)
"Don't show compilation window if everything went ok"
(if (string-match "exited abnormally" str)
;; there were errors
(message "compilation errors, press C-x ` to visit")
;; no errors, make the compilation window go away in 0.5 seconds
(run-at-time 0.5 nil 'delete-windows-on bu)
(message "NO COMPILATION ERRORS!")))
(defun bh/hide-other ()
(interactive)
(save-excursion
(org-back-to-heading)
(org-shifttab)
(org-reveal)
(org-cycle)))
(defun bh/go-to-scratch ()
(interactive)
(switch-to-buffer "*scratch*")
(delete-other-windows))
(defun bh/untabify ()
(interactive)
(untabify (point-min) (point-max)))
(defun bh/killframe ()
(interactive)
(unless (buffer-modified-p)
(kill-buffer (current-buffer)))
(delete-frame))
(defun show-whitespace ()
(whitespace-mode t))
(provide 'functions)

707
emacs.d/javascript.el Normal file
View file

@ -0,0 +1,707 @@
;;; javascript.el --- Major mode for editing JavaScript source text
;; Copyright (C) 2006 Karl Landström
;; Author: Karl Landström <kland@comhem.se>
;; Maintainer: Karl Landström <kland@comhem.se>
;; Version: 2.0 Beta 8
;; Date: 2006-12-26
;; Keywords: languages, oop
;; 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., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Commentary:
;;
;; The main features of this JavaScript mode are syntactic
;; highlighting (enabled with `font-lock-mode' or
;; `global-font-lock-mode'), automatic indentation and filling of
;; comments.
;;
;; This package has (only) been tested with GNU Emacs 21.4 (the latest
;; stable release).
;;
;; Installation:
;;
;; Put this file in a directory where Emacs can find it (`C-h v
;; load-path' for more info). Then add the following lines to your
;; Emacs initialization file:
;;
;; (add-to-list 'auto-mode-alist '("\\.js\\'" . javascript-mode))
;; (autoload 'javascript-mode "javascript" nil t)
;;
;; General Remarks:
;;
;; This mode assumes that block comments are not nested inside block
;; comments and that strings do not contain line breaks.
;;
;; Exported names start with "javascript-" whereas private names start
;; with "js-".
;;
;; Changes:
;;
;; See javascript.el.changelog.
;;; Code:
(require 'cc-mode)
(require 'font-lock)
(require 'newcomment)
(defgroup javascript nil
"Customization variables for `javascript-mode'."
:tag "JavaScript"
:group 'languages)
(defcustom javascript-indent-level 4
"Number of spaces for each indentation step."
:type 'integer
:group 'javascript)
(defcustom javascript-auto-indent-flag t
"Automatic indentation with punctuation characters. If non-nil, the
current line is indented when certain punctuations are inserted."
:type 'boolean
:group 'javascript)
;; --- Keymap ---
(defvar javascript-mode-map nil
"Keymap used in JavaScript mode.")
(unless javascript-mode-map
(setq javascript-mode-map (make-sparse-keymap)))
(when javascript-auto-indent-flag
(mapc (lambda (key)
(define-key javascript-mode-map key 'javascript-insert-and-indent))
'("{" "}" "(" ")" ":" ";" ",")))
(defun javascript-insert-and-indent (key)
"Run command bound to key and indent current line. Runs the command
bound to KEY in the global keymap and indents the current line."
(interactive (list (this-command-keys)))
(call-interactively (lookup-key (current-global-map) key))
(indent-according-to-mode))
;; --- Syntax Table And Parsing ---
(defvar javascript-mode-syntax-table
(let ((table (make-syntax-table)))
(c-populate-syntax-table table)
;; The syntax class of underscore should really be `symbol' ("_")
;; but that makes matching of tokens much more complex as e.g.
;; "\\<xyz\\>" matches part of e.g. "_xyz" and "xyz_abc". Defines
;; it as word constituent for now.
(modify-syntax-entry ?_ "w" table)
table)
"Syntax table used in JavaScript mode.")
(defun js-re-search-forward-inner (regexp &optional bound count)
"Auxiliary function for `js-re-search-forward'."
(let ((parse)
(saved-point (point-min)))
(while (> count 0)
(re-search-forward regexp bound)
(setq parse (parse-partial-sexp saved-point (point)))
(cond ((nth 3 parse)
(re-search-forward
(concat "\\([^\\]\\|^\\)" (string (nth 3 parse)))
(save-excursion (end-of-line) (point)) t))
((nth 7 parse)
(forward-line))
((or (nth 4 parse)
(and (eq (char-before) ?\/) (eq (char-after) ?\*)))
(re-search-forward "\\*/"))
(t
(setq count (1- count))))
(setq saved-point (point))))
(point))
(defun js-re-search-forward (regexp &optional bound noerror count)
"Search forward but ignore strings and comments. Invokes
`re-search-forward' but treats the buffer as if strings and
comments have been removed."
(let ((saved-point (point))
(search-expr
(cond ((null count)
'(js-re-search-forward-inner regexp bound 1))
((< count 0)
'(js-re-search-backward-inner regexp bound (- count)))
((> count 0)
'(js-re-search-forward-inner regexp bound count)))))
(condition-case err
(eval search-expr)
(search-failed
(goto-char saved-point)
(unless noerror
(error (error-message-string err)))))))
(defun js-re-search-backward-inner (regexp &optional bound count)
"Auxiliary function for `js-re-search-backward'."
(let ((parse)
(saved-point (point-min)))
(while (> count 0)
(re-search-backward regexp bound)
(when (and (> (point) (point-min))
(save-excursion (backward-char) (looking-at "/[/*]")))
(forward-char))
(setq parse (parse-partial-sexp saved-point (point)))
(cond ((nth 3 parse)
(re-search-backward
(concat "\\([^\\]\\|^\\)" (string (nth 3 parse)))
(save-excursion (beginning-of-line) (point)) t))
((nth 7 parse)
(goto-char (nth 8 parse)))
((or (nth 4 parse)
(and (eq (char-before) ?/) (eq (char-after) ?*)))
(re-search-backward "/\\*"))
(t
(setq count (1- count))))))
(point))
(defun js-re-search-backward (regexp &optional bound noerror count)
"Search backward but ignore strings and comments. Invokes
`re-search-backward' but treats the buffer as if strings and
comments have been removed."
(let ((saved-point (point))
(search-expr
(cond ((null count)
'(js-re-search-backward-inner regexp bound 1))
((< count 0)
'(js-re-search-forward-inner regexp bound (- count)))
((> count 0)
'(js-re-search-backward-inner regexp bound count)))))
(condition-case err
(eval search-expr)
(search-failed
(goto-char saved-point)
(unless noerror
(error (error-message-string err)))))))
(defun js-continued-var-decl-list-p ()
"Return non-nil if point is inside a continued variable declaration
list."
(interactive)
(let ((start (save-excursion (js-re-search-backward "\\<var\\>" nil t))))
(and start
(save-excursion (re-search-backward "\n" start t))
(not (save-excursion
(js-re-search-backward
";\\|[^, \t][ \t]*\\(/[/*]\\|$\\)" start t))))))
;; --- Font Lock ---
(defun js-inside-param-list-p ()
"Return non-nil if point is inside a function parameter list."
(condition-case err
(save-excursion
(up-list -1)
(and (looking-at "(")
(progn (backward-word 1)
(or (looking-at "function")
(progn (backward-word 1) (looking-at "function"))))))
(error nil)))
(defconst js-function-heading-1-re
"^[ \t]*function[ \t]+\\(\\w+\\)"
"Regular expression matching the start of a function header.")
(defconst js-function-heading-2-re
"^[ \t]*\\(\\w+\\)[ \t]*:[ \t]*function\\>"
"Regular expression matching the start of a function entry in
an associative array.")
(defconst js-keyword-re
(regexp-opt '("abstract" "break" "case" "catch" "class" "const"
"continue" "debugger" "default" "delete" "do" "else"
"enum" "export" "extends" "final" "finally" "for"
"function" "goto" "if" "implements" "import" "in"
"instanceof" "interface" "native" "new" "package"
"private" "protected" "public" "return" "static"
"super" "switch" "synchronized" "this" "throw"
"throws" "transient" "try" "typeof" "var" "void"
"volatile" "while" "with"
"let") 'words)
"Regular expression matching any JavaScript keyword.")
(defconst js-basic-type-re
(regexp-opt '("boolean" "byte" "char" "double" "float" "int" "long"
"short" "void") 'words)
"Regular expression matching any predefined type in JavaScript.")
(defconst js-constant-re
(regexp-opt '("false" "null" "true") 'words)
"Regular expression matching any future reserved words in JavaScript.")
(defconst js-font-lock-keywords-1
(list
"\\<import\\>"
(list js-function-heading-1-re 1 font-lock-function-name-face)
(list js-function-heading-2-re 1 font-lock-function-name-face)
(list "[=(][ \t]*\\(/.*?[^\\]/\\w*\\)" 1 font-lock-string-face))
"Level one font lock.")
(defconst js-font-lock-keywords-2
(append js-font-lock-keywords-1
(list (list js-keyword-re 1 font-lock-keyword-face)
(cons js-basic-type-re font-lock-type-face)
(cons js-constant-re font-lock-constant-face)))
"Level two font lock.")
;; Limitations with variable declarations: There seems to be no
;; sensible way to highlight variables occuring after an initialized
;; variable in a variable list. For instance, in
;;
;; var x, y = f(a, b), z
;;
;; z will not be highlighted.
(defconst js-font-lock-keywords-3
(append
js-font-lock-keywords-2
(list
;; variable declarations
(list
(concat "\\<\\(const\\|var\\)\\>\\|" js-basic-type-re)
(list "\\(\\w+\\)[ \t]*\\([=;].*\\|,\\|/[/*]\\|$\\)"
nil
nil
'(1 font-lock-variable-name-face)))
;; continued variable declaration list
(list
(concat "^[ \t]*\\w+[ \t]*\\([,;=]\\|/[/*]\\|$\\)")
(list "\\(\\w+\\)[ \t]*\\([=;].*\\|,\\|/[/*]\\|$\\)"
'(if (save-excursion (backward-char) (js-continued-var-decl-list-p))
(backward-word 1)
(end-of-line))
'(end-of-line)
'(1 font-lock-variable-name-face)))
;; formal parameters
(list
(concat "\\<function\\>\\([ \t]+\\w+\\)?[ \t]*([ \t]*\\w")
(list "\\(\\w+\\)\\([ \t]*).*\\)?"
'(backward-char)
'(end-of-line)
'(1 font-lock-variable-name-face)))
;; continued formal parameter list
(list
(concat "^[ \t]*\\w+[ \t]*[,)]")
(list "\\w+"
'(if (save-excursion (backward-char) (js-inside-param-list-p))
(backward-word 1)
(end-of-line))
'(end-of-line)
'(0 font-lock-variable-name-face)))))
"Level three font lock.")
(defconst js-font-lock-keywords
'(js-font-lock-keywords-3 js-font-lock-keywords-1 js-font-lock-keywords-2
js-font-lock-keywords-3)
"See `font-lock-keywords'.")
;; --- Indentation ---
(defconst js-possibly-braceless-keyword-re
(regexp-opt
'("catch" "do" "else" "finally" "for" "if" "try" "while" "with" "let")
'words)
"Regular expression matching keywords that are optionally
followed by an opening brace.")
(defconst js-indent-operator-re
(concat "[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|"
(regexp-opt '("in" "instanceof") 'words))
"Regular expression matching operators that affect indentation
of continued expressions.")
(defun js-looking-at-operator-p ()
"Return non-nil if text after point is an operator (that is not
a comma)."
(save-match-data
(and (looking-at js-indent-operator-re)
(or (not (looking-at ":"))
(save-excursion
(and (js-re-search-backward "[?:{]\\|\\<case\\>" nil t)
(looking-at "?")))))))
(defun js-continued-expression-p ()
"Returns non-nil if the current line continues an expression."
(save-excursion
(back-to-indentation)
(or (js-looking-at-operator-p)
(and (js-re-search-backward "\n" nil t)
(progn
(skip-chars-backward " \t")
(backward-char)
(and (> (point) (point-min))
(save-excursion (backward-char) (not (looking-at "[/*]/")))
(js-looking-at-operator-p)
(and (progn (backward-char)
(not (looking-at "++\\|--\\|/[/*]"))))))))))
(defun js-end-of-do-while-loop-p ()
"Returns non-nil if word after point is `while' of a do-while
statement, else returns nil. A braceless do-while statement
spanning several lines requires that the start of the loop is
indented to the same column as the current line."
(interactive)
(save-excursion
(save-match-data
(when (looking-at "\\s-*\\<while\\>")
(if (save-excursion
(skip-chars-backward "[ \t\n]*}")
(looking-at "[ \t\n]*}"))
(save-excursion
(backward-list) (backward-word 1) (looking-at "\\<do\\>"))
(js-re-search-backward "\\<do\\>" (point-at-bol) t)
(or (looking-at "\\<do\\>")
(let ((saved-indent (current-indentation)))
(while (and (js-re-search-backward "^[ \t]*\\<" nil t)
(/= (current-indentation) saved-indent)))
(and (looking-at "[ \t]*\\<do\\>")
(not (js-re-search-forward
"\\<while\\>" (point-at-eol) t))
(= (current-indentation) saved-indent)))))))))
(defun js-ctrl-statement-indentation ()
"Returns the proper indentation of the current line if it
starts the body of a control statement without braces, else
returns nil."
(save-excursion
(back-to-indentation)
(when (save-excursion
(and (not (looking-at "[{]"))
(progn
(js-re-search-backward "[[:graph:]]" nil t)
(forward-char)
(when (= (char-before) ?\)) (backward-list))
(skip-syntax-backward " ")
(skip-syntax-backward "w")
(looking-at js-possibly-braceless-keyword-re))
(not (js-end-of-do-while-loop-p))))
(save-excursion
(goto-char (match-beginning 0))
(+ (current-indentation) javascript-indent-level)))))
(defun js-proper-indentation (parse-status)
"Return the proper indentation for the current line."
(save-excursion
(back-to-indentation)
(let ((ctrl-stmt-indent (js-ctrl-statement-indentation))
(same-indent-p (looking-at "[]})]\\|\\<case\\>\\|\\<default\\>"))
(continued-expr-p (js-continued-expression-p)))
(cond (ctrl-stmt-indent)
((js-continued-var-decl-list-p)
(js-re-search-backward "\\<var\\>" nil t)
(+ (current-indentation) javascript-indent-level))
((nth 1 parse-status)
(goto-char (nth 1 parse-status))
(if (looking-at "[({[][ \t]*\\(/[/*]\\|$\\)")
(progn
(skip-syntax-backward " ")
(when (= (char-before) ?\)) (backward-list))
(back-to-indentation)
(cond (same-indent-p
(current-column))
(continued-expr-p
(+ (current-column) (* 2 javascript-indent-level)))
(t
(+ (current-column) javascript-indent-level))))
(unless same-indent-p
(forward-char)
(skip-chars-forward " \t"))
(current-column)))
(continued-expr-p javascript-indent-level)
(t 0)))))
(defun javascript-indent-line ()
"Indent the current line as JavaScript source text."
(interactive)
(let ((parse-status
(save-excursion (parse-partial-sexp (point-min) (point-at-bol))))
(offset (- (current-column) (current-indentation))))
(when (not (nth 8 parse-status))
(indent-line-to (js-proper-indentation parse-status))
(when (> offset 0) (forward-char offset)))))
;; --- Filling ---
;; FIXME: It should be possible to use the more sofisticated function
;; `c-fill-paragraph' in `cc-cmds.el' instead. However, just setting
;; `fill-paragraph-function' to `c-fill-paragraph' does not work;
;; inside `c-fill-paragraph', `fill-paragraph-function' evaluates to
;; nil!?
(defun js-backward-paragraph ()
"Move backward to start of paragraph. Postcondition: Point is at
beginning of buffer or the previous line contains only whitespace."
(forward-line -1)
(while (not (or (bobp) (looking-at "^[ \t]*$")))
(forward-line -1))
(when (not (bobp)) (forward-line 1)))
(defun js-forward-paragraph ()
"Move forward to end of paragraph. Postcondition: Point is at
end of buffer or the next line contains only whitespace."
(forward-line 1)
(while (not (or (eobp) (looking-at "^[ \t]*$")))
(forward-line 1))
(when (not (eobp)) (backward-char 1)))
(defun js-fill-block-comment-paragraph (parse-status justify)
"Fill current paragraph as a block comment. PARSE-STATUS is the
result of `parse-partial-regexp' from beginning of buffer to
point. JUSTIFY has the same meaning as in `fill-paragraph'."
(let ((offset (save-excursion
(goto-char (nth 8 parse-status)) (current-indentation))))
(save-excursion
(save-restriction
(narrow-to-region (save-excursion
(goto-char (nth 8 parse-status)) (point-at-bol))
(save-excursion
(goto-char (nth 8 parse-status))
(re-search-forward "*/")))
(narrow-to-region (save-excursion
(js-backward-paragraph)
(when (looking-at "^[ \t]*$") (forward-line 1))
(point))
(save-excursion
(js-forward-paragraph)
(when (looking-at "^[ \t]*$") (backward-char))
(point)))
(goto-char (point-min))
(while (not (eobp))
(delete-horizontal-space)
(forward-line 1))
(let ((fill-column (- fill-column offset))
(fill-paragraph-function nil))
(fill-paragraph justify))
;; In Emacs 21.4 as opposed to CVS Emacs 22,
;; `fill-paragraph' seems toadd a newline at the end of the
;; paragraph. Remove it!
(goto-char (point-max))
(when (looking-at "^$") (backward-delete-char 1))
(goto-char (point-min))
(while (not (eobp))
(indent-to offset)
(forward-line 1))))))
(defun js-sline-comment-par-start ()
"Return point at the beginning of the line where the current
single-line comment paragraph starts."
(save-excursion
(beginning-of-line)
(while (and (not (bobp))
(looking-at "^[ \t]*//[ \t]*[[:graph:]]"))
(forward-line -1))
(unless (bobp) (forward-line 1))
(point)))
(defun js-sline-comment-par-end ()
"Return point at end of current single-line comment paragraph."
(save-excursion
(beginning-of-line)
(while (and (not (eobp))
(looking-at "^[ \t]*//[ \t]*[[:graph:]]"))
(forward-line 1))
(unless (bobp) (backward-char))
(point)))
(defun js-sline-comment-offset (line)
"Return the column at the start of the current single-line
comment paragraph."
(save-excursion
(goto-line line)
(re-search-forward "//" (point-at-eol))
(goto-char (match-beginning 0))
(current-column)))
(defun js-sline-comment-text-offset (line)
"Return the column at the start of the text of the current
single-line comment paragraph."
(save-excursion
(goto-line line)
(re-search-forward "//[ \t]*" (point-at-eol))
(current-column)))
(defun js-at-empty-sline-comment-p ()
"Return non-nil if inside an empty single-line comment."
(and (save-excursion
(beginning-of-line)
(not (looking-at "^.*//.*[[:graph:]]")))
(save-excursion
(re-search-backward "//" (point-at-bol) t))))
(defun js-fill-sline-comments (parse-status justify)
"Fill current paragraph as a sequence of single-line comments.
PARSE-STATUS is the result of `parse-partial-regexp' from
beginning of buffer to point. JUSTIFY has the same meaning as in
`fill-paragraph'."
(when (not (js-at-empty-sline-comment-p))
(let* ((start (js-sline-comment-par-start))
(start-line (1+ (count-lines (point-min) start)))
(end (js-sline-comment-par-end))
(offset (js-sline-comment-offset start-line))
(text-offset (js-sline-comment-text-offset start-line)))
(save-excursion
(save-restriction
(narrow-to-region start end)
(goto-char (point-min))
(while (re-search-forward "^[ \t]*//[ \t]*" nil t)
(replace-match "")
(forward-line 1))
(let ((fill-paragraph-function nil)
(fill-column (- fill-column text-offset)))
(fill-paragraph justify))
;; In Emacs 21.4 as opposed to CVS Emacs 22,
;; `fill-paragraph' seems toadd a newline at the end of the
;; paragraph. Remove it!
(goto-char (point-max))
(when (looking-at "^$") (backward-delete-char 1))
(goto-char (point-min))
(while (not (eobp))
(indent-to offset)
(insert "//")
(indent-to text-offset)
(forward-line 1)))))))
(defun js-trailing-comment-p (parse-status)
"Return non-nil if inside a trailing comment. PARSE-STATUS is
the result of `parse-partial-regexp' from beginning of buffer to
point."
(save-excursion
(when (nth 4 parse-status)
(goto-char (nth 8 parse-status))
(skip-chars-backward " \t")
(not (bolp)))))
(defun js-block-comment-p (parse-status)
"Return non-nil if inside a block comment. PARSE-STATUS is the
result of `parse-partial-regexp' from beginning of buffer to
point."
(save-excursion
(save-match-data
(when (nth 4 parse-status)
(goto-char (nth 8 parse-status))
(looking-at "/\\*")))))
(defun javascript-fill-paragraph (&optional justify)
"If inside a comment, fill the current comment paragraph.
Trailing comments are ignored."
(interactive)
(let ((parse-status (parse-partial-sexp (point-min) (point))))
(when (and (nth 4 parse-status)
(not (js-trailing-comment-p parse-status)))
(if (js-block-comment-p parse-status)
(js-fill-block-comment-paragraph parse-status justify)
(js-fill-sline-comments parse-status justify))))
t)
;; --- Imenu ---
(defconst js-imenu-generic-expression
(list
(list
nil
"function\\s-+\\(\\w+\\)\\s-*("
1))
"Regular expression matching top level procedures. Used by imenu.")
;; --- Main Function ---
;;;###autoload
(defun javascript-mode ()
"Major mode for editing JavaScript source text.
Key bindings:
\\{javascript-mode-map}"
(interactive)
(kill-all-local-variables)
(use-local-map javascript-mode-map)
(set-syntax-table javascript-mode-syntax-table)
(set (make-local-variable 'indent-line-function) 'javascript-indent-line)
(set (make-local-variable 'font-lock-defaults) (list js-font-lock-keywords))
(set (make-local-variable 'parse-sexp-ignore-comments) t)
;; Comments
(setq comment-start "// ")
(setq comment-end "")
(set (make-local-variable 'fill-paragraph-function)
'javascript-fill-paragraph)
;; Make c-mark-function work
(setq c-nonsymbol-token-regexp "!=\\|%=\\|&[&=]\\|\\*[/=]\\|\\+[+=]\\|-[=-]\\|/[*/=]\\|<\\(?:<=\\|[<=]\\)\\|==\\|>\\(?:>\\(?:>=\\|[=>]\\)\\|[=>]\\)\\|\\^=\\||[=|]\\|[]!%&(-,./:-?[{-~^-]"
c-stmt-delim-chars "^;{}?:"
c-syntactic-ws-end "[ \n \f/]"
c-syntactic-eol "\\(\\s \\|/\\*\\([^*\n ]\\|\\*[^/\n ]\\)*\\*/\\)*\\(\\(/\\*\\([^*\n ]\\|\\*[^/\n ]\\)*\\|\\\\\\)?$\\|//\\)")
;; Imenu
(setq imenu-case-fold-search nil)
(set (make-local-variable 'imenu-generic-expression)
js-imenu-generic-expression)
(setq major-mode 'javascript-mode)
(setq mode-name "JavaScript")
(run-hooks 'javascript-mode-hook))
(provide 'javascript-mode)
;;; javascript.el ends here

40
emacs.d/manage-org.el Normal file
View file

@ -0,0 +1,40 @@
(defun clone-org-files ()
(interactive)
(if (= (shell-command
"git clone git@82.170.172.156:private/org.git ~/prj/org"
"*Messages*" "*Messages*") 0)
(message "success!")
(message "failed!")))
(defun get-org-files ()
(interactive)
(let ((prev-dir (getenv "PWD")))
(if (= (shell-command
(format "cd ~/prj/org/; git pull origin master; cd %s" prev-dir)
"*Messages*" "*Messages*") 0)
(message "success!")
(message "failed!"))))
(defun save-org-files ()
(interactive)
(let ((prev-dir (getenv "PWD")))
(if (= (shell-command
(format
"cd ~/prj/org/; git add .; git commit -m \"Change for %s\"; cd %s"
(format-time-string "%Y-%m-%d at %H:%M:%S")
prev-dir)
"*Messages*" "*Messages*") 0)
(message "success!")
(message "failed!"))))
(defun push-org-files ()
(interactive)
(let ((prev-dir (getenv "PWD")))
(if (= (shell-command
(format
"cd ~/prj/org/; git push origin master; cd %s" prev-dir)
"*Messages*" "*Messages*") 0)
(message "success!")
(message "failed!"))))
(provide 'manage-org)

630
emacs.d/minimap.el Normal file
View file

@ -0,0 +1,630 @@
;;; minimap.el --- Minimap sidebar for Emacs
;; Copyright (C) 2009, 2010 David Engster
;; Author: David Engster <dengste@eml.cc>
;; Keywords:
;; Version: 0.7
;; This file is NOT part of GNU Emacs.
;; 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. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; This file is an implementation of a minimap sidebar, i.e., a
;; smaller display of the current buffer on the left side. It
;; highlights the currently shown region and updates its position
;; automatically. You can navigate in the minibar by dragging the
;; active region with the mouse, which will scroll the corresponding
;; edit buffer.
;; Usage:
;; * Put minimap.el in your load path.
;; * (require 'minimap)
;; * Use 'M-x minimap-create' in a buffer you're currently editing.
;; * Use 'M-x minimap-kill' to kill the minimap.
;; * Use 'M-x customize-group RET minimap RET' to adapt minimap to your needs.
;; Download:
;; You can always get the latest version from the git repository:
;; git://randomsample.de/minimap.git
;; or http://randomsample.de/minimap.git
;;; KNOWN BUGS:
;; * Currently cannot deal with images.
;; * Display/movement can be a bit erratic at times.
;;; TODO:
;; * Fix known bugs.
;; * Make sidebar permanently visible. This requires something like a
;; 'window group' feature in Emacs, which is currently being worked on.
;; * Moving the active region with the keyboard / mouse-wheel ?
;;; Customizable variables:
(defgroup minimap nil
"A minimap sidebar for Emacs."
:group 'convenience)
(defface minimap-font-face
'((default :family "DejaVu Sans Mono" :height 30))
"Face used for text in minimap buffer, notably the font family and height.
This height should be really small. You probably want to use a
TrueType font for this. After changing this, you should
recreate the minimap to avoid problems with recentering."
:group 'minimap)
(defface minimap-active-region-background
'((((background dark)) (:background "#4517305D0000"))
(t (:background "#C847D8FEFFFF")))
"Face for the active region in the minimap.
By default, this is only a different background color."
:group 'minimap)
(defface minimap-semantic-function-face
'((((background dark))
(:box (:line-width 1 :color "white")
:inherit (font-lock-function-name-face minimap-font-face)
:height 2.5 :background "gray10"))
(t (:box (:line-width 1 :color "black")
:inherit (font-lock-function-name-face minimap-font-face)
:height 2.5 :background "gray90")))
"Face used for functions in the semantic overlay.")
(defface minimap-semantic-variable-face
'((((background dark))
(:box (:line-width 1 :color "white")
:inherit (font-lock-variable-name-face minimap-font-face)
:height 2.5 :background "gray10"))
(t (:box (:line-width 1 :color "black")
:inherit (font-lock-function-name-face minimap-font-face)
:height 2.5 :background "gray90")))
"Face used for variables in the semantic overlay.")
(defface minimap-semantic-type-face
'((((background dark))
(:box (:line-width 1 :color "white")
:inherit (font-lock-type-face minimap-font-face)
:height 2.5 :background "gray10"))
(t (:box (:line-width 1 :color "black")
:inherit (font-lock-function-name-face minimap-font-face)
:height 2.5 :background "gray90")))
"Face used for types in the semantic overlay.")
(defcustom minimap-width-fraction 0.2
"Fraction of width which should be used for minimap sidebar."
:type 'number
:group 'minimap)
(defcustom minimap-window-location 'left
"Location of the minimap window.
Can be either the symbol `left' or `right'."
:type '(choice (const :tag "Left" left)
(const :tag "Right" right))
:group 'minimap)
(defcustom minimap-buffer-name-prefix "*MINIMAP* "
"Prefix for buffer names of minimap sidebar."
:type 'string
:group 'minimap)
(defcustom minimap-update-delay 0.2
"Delay in seconds after which sidebar gets updated.
Setting this to 0 will let the minimap react immediately, but
this will slow down scrolling."
:type 'number
:set (lambda (sym value)
(set sym value)
(when (and (boundp 'minimap-timer-object)
minimap-timer-object)
(cancel-timer minimap-timer-object)
(setq minimap-timer-object
(run-with-idle-timer
minimap-update-delay t 'minimap-update))))
:group 'minimap)
(defcustom minimap-always-recenter nil
"Whether minimap sidebar should be recentered after every point movement."
:type 'boolean
:group 'minimap)
(defcustom minimap-recenter-type 'relative
"Specifies the type of recentering the minimap should use.
The minimap can use different types of recentering, i.e., how the
minimap should behave when you scroll in the main window or when
you drag the active region with the mouse. The following
explanations will probably not help much, so simply try them and
choose the one which suits you best.
`relative' -- The position of the active region in the minimap
corresponds with the relative position of this region in the
buffer. This the default.
`middle' -- The active region will stay fixed in the middle of
the minimap.
`free' -- The position will be more or less free. When dragging
the active region, the minimap will scroll when you reach the
bottom or top."
:type '(choice (const :tag "Relative" relative)
(const :tag "Middle" middle)
(const :tag "Free" free))
:group 'minimap)
(defcustom minimap-hide-scroll-bar t
"Whether the minimap should hide the vertical scrollbar."
:type 'boolean
:group 'minimap)
(defcustom minimap-hide-fringes t
"Whether the minimap should hide the fringes."
:type 'boolean
:group 'minimap)
(defcustom minimap-dedicated-window nil
"Whether the minimap should create a dedicated window."
:type 'boolean
:group 'minimap)
(defcustom minimap-display-semantic-overlays t
"Display overlays from CEDET's semantic analyzer.
If you use CEDET and the buffer's major-mode is supported, the
minimap can display overlays generated by the semantic analyzer.
By default, it will apply the faces `minimap-semantic-<X>-face',
with <X> being \"function\", \"variable\" and \"type\". Also, it
will display the name of the tag in the middle of the overlay in
the corresponding font-lock face.
See also `minimap-enlarge-certain-faces', which can be used as
fallback."
:type 'boolean
:group 'minimap)
(defcustom minimap-enlarge-certain-faces 'as-fallback
"Whether certain faces should be enlarged in the minimap.
All faces listed in `minimap-normal-height-faces' will be
displayed using the default font height, allowing you to still
read text using those faces. By default, this should enlarge all
function names in the minimap, given you have font locking
enabled. This variable can have the following values:
'as-fallback (the default) -- The feature will only be activated
if information from CEDET's semantic analyzer isn't available
(see: `minimap-display-semantic-overlays').
'always -- Always active.
nil -- Inactive."
:type '(choice (const :tag "Fallback if CEDET unavailable." 'as-fallback)
(const :tag "Always active." 'always)
(const :tag "Inactive." nil))
:group 'minimap)
(defcustom minimap-normal-height-faces '(font-lock-function-name-face)
"List of faces which should be displayed with normal height.
When `minimap-enlarge-certain-faces' is non-nil, all faces in
this list will be displayed using the default font height. By
default, this list contains `font-lock-function-name-face', so
you can still read function names in the minimap."
:type '(repeat face)
:group 'minimap)
(defcustom minimap-sync-overlay-properties '(face invisible)
"Specifies which overlay properties should be synced.
Unlike text properties, overlays are not applied automatically to
the minimap and must be explicitly synced. This variable
specifies which overlay properties should be synced by
`minimap-sync-overlays'. Most importantly, this variable should
include 'invisible', so that hidden text does not appear in the
minimap buffer."
:type '(repeat symbol)
:group 'minimap)
;;; Internal variables
(defvar minimap-start nil)
(defvar minimap-end nil)
(defvar minimap-active-overlay nil)
(defvar minimap-bufname nil)
(defvar minimap-timer-object nil)
(defvar minimap-active-minimaps 0)
(defvar minimap-base-overlay nil)
(defvar minimap-numlines nil)
(defvar minimap-pointmin-overlay nil)
(make-variable-buffer-local 'minimap-start)
(make-variable-buffer-local 'minimap-end)
(make-variable-buffer-local 'minimap-active-overlay)
(make-variable-buffer-local 'minimap-bufname)
(make-variable-buffer-local 'minimap-base-overlay)
(make-variable-buffer-local 'minimap-numlines)
(make-variable-buffer-local 'minimap-pointmin-overlay)
;;; Minimap creation / killing
;;;###autoload
(defun minimap-create ()
"Create a minimap sidebar for the current window."
(interactive)
;; If minimap is visible, do nothing.
(unless (and minimap-bufname
(get-buffer minimap-bufname)
(get-buffer-window (get-buffer minimap-bufname)))
(let ((bufname (concat minimap-buffer-name-prefix
(buffer-name (current-buffer))))
(new-win (if (eq minimap-window-location 'left)
(split-window-horizontally
(round (* (window-width)
minimap-width-fraction)))
(split-window-horizontally
(round (* (window-width)
(- 1 minimap-width-fraction))))
(other-window 1))))
;; If minimap exists but isn't visible, reuse it.
(if (and minimap-bufname
(get-buffer minimap-bufname))
(switch-to-buffer minimap-bufname t)
;; Otherwise create new minimap
(minimap-new-minimap bufname)
;; If this is the first minimap, create the idle timer.
(when (zerop minimap-active-minimaps)
(setq minimap-timer-object
(run-with-idle-timer minimap-update-delay t 'minimap-update)))
(setq minimap-active-minimaps
(1+ minimap-active-minimaps))))
(other-window 1)
(minimap-sync-overlays)))
(defun minimap-new-minimap (bufname)
"Create new minimap BUFNAME for current buffer and window."
(let ((indbuf (make-indirect-buffer (current-buffer) bufname t))
(edges (window-pixel-edges)))
(setq minimap-bufname bufname)
(set-buffer indbuf)
(when minimap-hide-scroll-bar
(setq vertical-scroll-bar nil))
(switch-to-buffer indbuf)
(setq minimap-base-overlay (make-overlay (point-min) (point-max) nil t t))
(overlay-put minimap-base-overlay 'face 'minimap-font-face)
(overlay-put minimap-base-overlay 'priority 1)
(setq minimap-pointmin-overlay (make-overlay (point-min) (1+ (point-min))))
(setq minimap-start (window-start)
minimap-end (window-end)
minimap-active-overlay (make-overlay minimap-start minimap-end)
line-spacing 0)
(overlay-put minimap-active-overlay 'face
'minimap-active-region-background)
(overlay-put minimap-active-overlay 'priority 5)
(minimap-mode 1)
(when (and (boundp 'linum-mode)
linum-mode)
(linum-mode 0))
(when minimap-hide-fringes
(set-window-fringes nil 0 0))
(when minimap-dedicated-window
(set-window-dedicated-p nil t))
(setq buffer-read-only t)
;; Calculate the actual number of lines displayable with the minimap face.
(setq minimap-numlines
(floor
(/
(- (nth 3 edges) (nth 1 edges))
(car (progn (redisplay) (window-line-height))))))))
;;;###autoload
(defun minimap-kill ()
"Kill minimap for current buffer.
Cancel the idle timer if no more minimaps are active."
(interactive)
(if (null minimap-bufname)
(message "No minimap associated with %s." (buffer-name (current-buffer)))
(let ((curname (buffer-name (current-buffer)))
(buf (get-buffer minimap-bufname))
(win (get-buffer-window minimap-bufname)))
(setq minimap-bufname nil)
(if (null buf)
(message "No minimap associated with %s." curname)
(when win
(delete-window win))
(kill-buffer buf)
(when (zerop
(setq minimap-active-minimaps
(1- minimap-active-minimaps)))
(cancel-timer minimap-timer-object)
(setq minimap-timer-object nil))
(message "Minimap for %s killed." curname)))))
;;; Minimap update
(defun minimap-update (&optional force)
"Update minimap sidebar if necessary.
This is meant to be called from the idle-timer or the post command hook.
When FORCE, enforce update of the active region."
(when minimap-bufname
(let ((win (get-buffer-window minimap-bufname))
start end pt ov)
(when win
(setq start (window-start)
end (window-end)
pt (point)
ov)
(with-selected-window win
(unless (and (not force)
(= minimap-start start)
(= minimap-end end))
(move-overlay minimap-active-overlay start end)
(setq minimap-start start
minimap-end end)
(minimap-recenter (line-number-at-pos (/ (+ end start) 2))
(/ (- (line-number-at-pos end)
(line-number-at-pos start))
2)))
(goto-char pt)
(when minimap-always-recenter
(recenter (round (/ (window-height) 2)))))))))
;;; Overlay movement
(defun minimap-move-overlay-mouse (start-event)
"Move overlay by tracking mouse movement."
(interactive "e")
(mouse-set-point start-event)
(when (get-buffer-window (buffer-base-buffer (current-buffer)))
(let* ((echo-keystrokes 0)
(end-posn (event-end start-event))
(start-point (posn-point end-posn))
(make-cursor-line-fully-visible nil)
(cursor-type nil)
(pcselmode pc-selection-mode)
pt ev)
(when pcselmode
(pc-selection-mode -1))
(move-overlay minimap-active-overlay start-point minimap-end)
(track-mouse
(minimap-set-overlay start-point)
(while (and
(consp (setq ev (read-event)))
(eq (car ev) 'mouse-movement))
(setq pt (posn-point (event-start ev)))
(when (numberp pt)
(minimap-set-overlay pt))))
(select-window (get-buffer-window (buffer-base-buffer)))
(minimap-update)
(when pcselmode
(pc-selection-mode 1)))))
(defun minimap-set-overlay (pt)
"Set overlay position, with PT being the middle."
(goto-char pt)
(let* ((ovstartline (line-number-at-pos minimap-start))
(ovendline (line-number-at-pos minimap-end))
(ovheight (round (/ (- ovendline ovstartline) 2)))
(line (line-number-at-pos))
(winstart (window-start))
(winend (window-end))
newstart newend)
(setq pt (point-at-bol))
(setq newstart (minimap-line-to-pos (- line ovheight)))
;; Perform recentering
(minimap-recenter line ovheight)
;; Set new position in main buffer and redisplay
(with-selected-window (get-buffer-window (buffer-base-buffer))
(goto-char pt)
(set-window-start nil newstart)
(redisplay t)
(setq newend (window-end)))
(when (eq minimap-recenter-type 'free)
(while (> newend winend)
(scroll-up 5)
(redisplay t)
(setq winend (window-end))))
(move-overlay minimap-active-overlay newstart newend)))
(defun minimap-line-to-pos (line)
"Return point position of line number LINE."
(save-excursion
(goto-char 1)
(if (eq selective-display t)
(re-search-forward "[\n\C-m]" nil 'end (1- line))
(forward-line (1- line)))
(point)))
(defun minimap-recenter (middle height)
"Recenter the minimap according to `minimap-recenter-type'.
MIDDLE is the line number in the middle of the active region.
HEIGHT is the number of lines from MIDDLE to begin/end of the
active region."
(cond
;; Relative recentering
((eq minimap-recenter-type 'relative)
(let* ((maxlines (line-number-at-pos (point-max)))
percentage relpos newline start numlines)
(setq numlines (count-lines (window-start) (window-end)))
(setq percentage (/ (float middle) (float maxlines)))
(setq newline (ceiling (* percentage numlines)))
(setq start (minimap-line-to-pos
(- middle height
(floor (* percentage
(- numlines height height))))))
(or (> start (point-min))
(setq start (point-min)))
;; If (point-max) already visible, don't go further
(if (and (> start (window-start))
(with-selected-window (get-buffer-window (buffer-base-buffer))
(= (point-max) (window-end))))
(save-excursion
(goto-char (point-max))
(recenter -1))
(unless (and (> start (window-start))
(= (point-max) (window-end)))
(set-window-start nil start)))))
;; Middle recentering
((eq minimap-recenter-type 'middle)
(let ((start (- middle height
(floor (* 0.5
(- minimap-numlines height height))))))
(if (< start 1)
(progn
;; Hack: Emacs cannot scroll down any further, so we fake
;; it using an overlay. Otherwise, the active region
;; would move to the top.
(overlay-put minimap-pointmin-overlay
'display (concat
(make-string (abs start) 10)
(buffer-substring (point-min) (1+ (point-min)))))
(overlay-put minimap-pointmin-overlay
'face `(:background ,(face-background 'default)))
(overlay-put minimap-pointmin-overlay
'priority 10)
(setq start 1))
(overlay-put minimap-pointmin-overlay 'display "")
(overlay-put minimap-pointmin-overlay 'face nil))
(set-window-start nil (minimap-line-to-pos start))))
;; Free recentering
((eq minimap-recenter-type 'free)
(let ((newstart (minimap-line-to-pos (- middle height)))
(winstart (window-start)))
(while (< newstart winstart)
(scroll-down 5)
(redisplay t)
(setq winstart (window-start)))))))
;;; Minimap minor mode
(defvar minimap-mode-map (make-sparse-keymap)
"Keymap used by `minimap-mode'.")
(define-key minimap-mode-map [down-mouse-1] 'minimap-move-overlay-mouse)
(define-key minimap-mode-map [down-mouse-2] 'minimap-move-overlay-mouse)
(define-key minimap-mode-map [down-mouse-3] 'minimap-move-overlay-mouse)
(define-minor-mode minimap-mode
"Minor mode for minimap sidebar."
nil "minimap" minimap-mode-map)
;;; Sync minimap with modes which create/delete overlays.
(defun minimap-sync-overlays ()
"Synchronize overlays between base and minimap buffer.
Apply semantic overlays or face enlargement if necessary."
(interactive)
(when minimap-bufname
(let ((baseov (overlays-in (point-min) (point-max)))
(semantic (and (boundp 'semantic-version)
(semantic-active-p)))
ov props p)
(with-current-buffer minimap-bufname
(remove-overlays)
(while baseov
(when (setq props (minimap-get-sync-properties (car baseov)))
(setq ov (make-overlay (overlay-start (car baseov))
(overlay-end (car baseov))))
(while (setq p (car props))
(overlay-put ov (car p) (cadr p))
(setq props (cdr props))))
(setq baseov (cdr baseov)))
(move-overlay minimap-pointmin-overlay (point-min) (1+ (point-min)))
;; Re-apply font overlay
(move-overlay minimap-base-overlay (point-min) (point-max)))
;; Face enlargement
(when (and font-lock-mode
(or (eq minimap-enlarge-certain-faces 'always)
(and (eq minimap-enlarge-certain-faces 'as-fallback)
(or (not minimap-display-semantic-overlays)
(not semantic)))))
(when (eq font-lock-support-mode 'jit-lock-mode)
(jit-lock-fontify-now))
(with-current-buffer minimap-bufname
(minimap-enlarge-faces)))
;; Semantic overlays
(when (and semantic
minimap-display-semantic-overlays)
(minimap-apply-semantic-overlays)))
(minimap-update t)))
(defun minimap-get-sync-properties (ov)
"Get properties from overlay OV which should be synced.
You can specify those properties with
`minimap-sync-overlay-properties'."
(delq nil
(mapcar
(lambda (p)
(let ((val (overlay-get ov p)))
(if val
(list p val)
nil)))
minimap-sync-overlay-properties)))
(defun minimap-enlarge-faces ()
"Apply default font to all faces in `minimap-normal-height-faces'.
This has to be called in the minimap buffer."
(let ((pos (next-single-property-change (point-min) 'face))
next ov face)
(while pos
(setq face (get-text-property pos 'face))
(when (delq nil (mapcar (lambda (x) (equal x face))
minimap-normal-height-faces))
(setq ov
(make-overlay pos
(setq pos (next-single-property-change pos 'face))))
(overlay-put ov 'face `(:family ,(face-font 'default)))
(overlay-put ov 'priority 5))
(setq pos (next-single-property-change pos 'face)))))
(defun minimap-apply-semantic-overlays ()
"Apply semantic overlays to the minimap.
This has to be called from the base buffer."
(let ((tags (semantic-fetch-tags))
tag class ov ovnew)
(while tags
(setq tag (car tags))
(setq class (semantic-tag-class tag))
(setq ov (semantic-tag-overlay tag))
(when (and (overlayp ov)
(or (eq class 'function)
(eq class 'type)
(eq class 'variable)))
(with-current-buffer minimap-bufname
(let ((start (overlay-start ov))
(end (overlay-end ov))
(name (semantic-tag-name tag)))
(overlay-put
(setq ovnew (make-overlay start end))
'face `(:background ,(face-background
(intern (format "minimap-semantic-%s-face"
(symbol-name class))))))
(overlay-put ovnew 'priority 1)
(setq start
(minimap-line-to-pos (/ (+ (line-number-at-pos start)
(line-number-at-pos end)) 2)))
(setq end (progn (goto-char start) (point-at-eol)))
(setq ovnew (make-overlay start end))
(overlay-put ovnew 'face (format "minimap-semantic-%s-face"
(symbol-name class)))
(overlay-put ovnew 'display (concat " " name " "))
(overlay-put ovnew 'priority 6))))
(setq tags (cdr tags)))))
;; outline-(minor-)mode
(add-hook 'outline-view-change-hook 'minimap-sync-overlays)
;; hideshow
(add-hook 'hs-hide-hook 'minimap-sync-overlays)
(add-hook 'hs-show-hook 'minimap-sync-overlays)
(provide 'minimap)
;;; minimap.el ends here

1061
emacs.d/popup.el Normal file

File diff suppressed because it is too large Load diff

207
emacs.d/rainbow-mode.el Normal file
View file

@ -0,0 +1,207 @@
;;; rainbow-mode.el --- prints color strings with colored background
;; Copyright (C) 2010 Julien Danjou
;; Author: Julien Danjou <julien@danjou.info>
;; Keywords: strings, faces
;; This file is NOT part of GNU Emacs.
;; GNU Emacs 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.
;; GNU Emacs 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. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; This minor mode will add background to strings that matches color names.
;; i.e.
;; #0000ff
;; Will be printed in white with a blue background.
;;
;;; Code:
(eval-when-compile
(require 'cl))
(require 'regexp-opt)
(require 'faces)
(defgroup rainbow nil
"Show color strings with a background color."
:tag "Rainbow"
:group 'help)
;; Hexadecimal colors
(defvar rainbow-hexadecimal-colors-font-lock-keywords
'("#[0-9a-fA-F]\\{3\\}[0-9a-fA-F]\\{3\\}?"
(0 (rainbow-colorize-itself)))
"Font-lock keywords to add for hexadecimal colors.")
;; rgb() colors
(defvar rainbow-html-rgb-colors-font-lock-keywords
'(("rgb(\s*\\([0-9]\\{1,3\\}\\(?:\s*%\\)?\\)\s*,\s*\\([0-9]\\{1,3\\}\\(?:\s*%\\)?\\)\s*,\s*\\([0-9]\\{1,3\\}\\(?:\s*%\\)?\\)\s*)"
(0 (rainbow-colorize-rgb)))
("rgba(\s*\\([0-9]\\{1,3\\}\\(?:\s*%\\)?\\)\s*,\s*\\([0-9]\\{1,3\\}\\(?:\s*%\\)?\\)\s*,\s*\\([0-9]\\{1,3\\}\\(?:\s*%\\)?\\)\s*,\s*[0-9]\\{1,3\\}\s*%?\s*)"
(0 (rainbow-colorize-rgb))))
"Font-lock keywords to add for RGB colors.")
;; HTML colors name
(defvar rainbow-html-colors-font-lock-keywords nil
"Font-lock keywords to add for HTML colors.")
(make-variable-buffer-local 'rainbow-html-colors-font-lock-keywords)
(defcustom rainbow-html-colors-alist
'(("black" . "#000000")
("silver" . "#C0C0C0")
("gray" . "#808080")
("white" . "#FFFFFF")
("maroon" . "#800000")
("red" . "#FF0000")
("purple" . "#800080")
("fuchsia" . "#FF00FF")
("green" . "#008000")
("lime" . "#00FF00")
("olive" . "#808000")
("yellow" . "#FFFF00")
("navy" . "#000080")
("blue" . "#0000FF")
("teal" . "#008080")
("aqua" . "#00FFFF"))
"Alist of HTML colors.
Each entry should have the form (COLOR-NAME . HEXADECIMAL-COLOR)."
:group 'rainbow)
(defcustom rainbow-html-colors-major-mode-list
'(html-mode css-mode php-mode nxml-mode xml-mode)
"List of major mode where HTML colors are enabled when
`rainbow-html-colors' is set to auto."
:group 'rainbow)
(defcustom rainbow-html-colors 'auto
"When to enable HTML colors.
If set to t, the HTML colors will be enabled. If set to nil, the
HTML colors will not be enabled. If set to auto, the HTML colors
will be enabled if a major mode has been detected from the
`rainbow-html-colors-major-mode-list'."
:group 'rainbow)
;; X colors
(defvar rainbow-x-colors-font-lock-keywords
`(,(regexp-opt (x-defined-colors) 'words)
(0 (rainbow-colorize-itself)))
"Font-lock keywords to add for X colors.")
(defcustom rainbow-x-colors-major-mode-list
'(emacs-lisp-mode lisp-interaction-mode c-mode c++-mode java-mode)
"List of major mode where X colors are enabled when
`rainbow-x-colors' is set to auto."
:group 'rainbow)
(defcustom rainbow-x-colors 'auto
"When to enable X colors.
If set to t, the X colors will be enabled. If set to nil, the
X colors will not be enabled. If set to auto, the X colors
will be enabled if a major mode has been detected from the
`rainbow-x-colors-major-mode-list'."
:group 'rainbow)
;; Functions
(defun rainbow-colorize-match (color)
"Return a matched string propertized with a face whose
background is COLOR. The foreground is computed using
`rainbow-color-luminance', and is either white or black."
(put-text-property
(match-beginning 0) (match-end 0)
'face `((:foreground ,(if (> 128.0 (rainbow-x-color-luminance color))
"white" "black"))
(:background ,color))))
(defun rainbow-colorize-itself ()
"Colorize a match with itself."
(rainbow-colorize-match (match-string-no-properties 0)))
(defun rainbow-colorize-by-assoc (assoc-list)
"Colorize a match with its association from ASSOC-LIST."
(rainbow-colorize-match (cdr (assoc (match-string-no-properties 0) assoc-list))))
(defun rainbow-rgb-relative-to-absolute (number)
"Convert a relative NUMBER to absolute. If NUMBER is absolute, return NUMBER.
This will convert \"80 %\" to 204, \"100 %\" to 255 but \"123\" to \"123\""
(let ((string-length (- (length number) 1)))
;; Is this a number with %?
(if (eq (elt number string-length) ?%)
(/ (* (string-to-number (substring number 0 string-length)) 255) 100)
(string-to-number number))))
(defun rainbow-colorize-rgb ()
"Colorize a match with itself."
(let ((r (rainbow-rgb-relative-to-absolute (match-string-no-properties 1)))
(g (rainbow-rgb-relative-to-absolute (match-string-no-properties 2)))
(b (rainbow-rgb-relative-to-absolute (match-string-no-properties 3))))
(rainbow-colorize-match (format "#%02X%02X%02X" r g b))))
(defun rainbow-color-luminance (red green blue)
"Calculate the luminance of color composed of RED, BLUE and GREEN."
(floor (+ (* .2126 red) (* .7152 green) (* .0722 blue)) 256))
(defun rainbow-x-color-luminance (color)
"Calculate the luminance of a color string (e.g. \"#ffaa00\", \"blue\")."
(let* ((values (x-color-values color))
(r (car values))
(g (cadr values))
(b (caddr values)))
(rainbow-color-luminance r g b)))
(defun rainbow-turn-on ()
"Turn on raibow-mode."
(font-lock-add-keywords nil
(list rainbow-hexadecimal-colors-font-lock-keywords))
;; Activate X colors?
(when (or (eq rainbow-x-colors t)
(and (eq rainbow-x-colors 'auto)
(memq major-mode rainbow-x-colors-major-mode-list)))
(font-lock-add-keywords nil
(list rainbow-x-colors-font-lock-keywords)))
;; Activate HTML colors?
(when (or (eq rainbow-html-colors t)
(and (eq rainbow-html-colors 'auto)
(memq major-mode rainbow-html-colors-major-mode-list)))
(setq rainbow-html-colors-font-lock-keywords
`(,(regexp-opt (mapcar 'car rainbow-html-colors-alist) 'words)
(0 (rainbow-colorize-by-assoc rainbow-html-colors-alist))))
(font-lock-add-keywords nil
`(,rainbow-html-colors-font-lock-keywords
,@rainbow-html-rgb-colors-font-lock-keywords))))
(defun rainbow-turn-off ()
"Turn off rainbow-mode."
(font-lock-remove-keywords
nil
(list
rainbow-hexadecimal-colors-font-lock-keywords
rainbow-html-colors-font-lock-keywords
rainbow-x-colors-font-lock-keywords
rainbow-html-rgb-colors-font-lock-keywords)))
;;;###autoload
(define-minor-mode rainbow-mode
"Colorize strings that represent colors.
This will fontify with colors the string like \"#aabbcc\" or \"blue\""
:lighter " Rbow"
(progn
(if rainbow-mode
(rainbow-turn-on)
(rainbow-turn-off))
;; Turn on font lock
(font-lock-mode 1)))
(provide 'rainbow-mode)

5151
emacs.d/sqlplus.el Normal file

File diff suppressed because it is too large Load diff

1932
emacs.d/tabbar.el Normal file

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,22 @@
(eval-when-compile
(require 'color-theme))
(defun color-theme-example ()
"Example theme. Carbon copy of color-theme-gnome contributed by Jonadab."
(interactive)
(color-theme-install
'(color-theme-example
((foreground-color . "wheat")
(background-color . "darkslategrey")
(background-mode . dark))
(default ((t (nil))))
(region ((t (:foreground "cyan" :background "dark cyan"))))
(underline ((t (:foreground "yellow" :underline t))))
(modeline ((t (:foreground "dark cyan" :background "wheat"))))
(modeline-buffer-id ((t (:foreground "dark cyan" :background "wheat"))))
(modeline-mousable ((t (:foreground "dark cyan" :background "wheat"))))
(modeline-mousable-minor-mode ((t (:foreground "dark cyan" :background "wheat"))))
(italic ((t (:foreground "dark red" :italic t))))
(bold-italic ((t (:foreground "dark red" :bold t :italic t))))
(font-lock-comment-face ((t (:foreground "Firebrick"))))
(bold ((t (:bold)))))))

File diff suppressed because it is too large Load diff

395
emacs.d/vala-mode.el Normal file
View file

@ -0,0 +1,395 @@
;;; vala-mode.el --- Vala mode derived mode
;; Author: 2005 Dylan R. E. Moonfire
;; 2008 Étienne BERSAC
;; Maintainer: Étienne BERSAC <bersace03@laposte.net>
;; Created: 2008 May the 4th
;; Modified: May 2008
;; Version: 0.1
;; Keywords: vala languages oop
;; 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., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Commentary:
;;
;; See http://live.gnome.org/Vala for details about Vala language.
;;
;; This is a separate mode to implement the Vala constructs and
;; font-locking. It is mostly the csharp-mode from
;; http://mfgames.com/linux/csharp-mode with vala specific keywords
;; and filename suffixes.
;;
;; Note: The interface used in this file requires CC Mode 5.30 or
;; later.
;;; .emacs (don't put in (require 'vala-mode))
;; (autoload 'vala-mode "vala-mode" "Major mode for editing Vala code." t)
;; (setq auto-mode-alist
;; (append '(("\\.vala$" . vala-mode)) auto-mode-alist))
;;; Versions:
;;
;; 0.1 : Initial version based on csharp-mode
;;
;; This is a copy of the function in cc-mode which is used to handle
;; the eval-when-compile which is needed during other times.
(defun c-filter-ops (ops opgroup-filter op-filter &optional xlate)
;; See cc-langs.el, a direct copy.
(unless (listp (car-safe ops))
(setq ops (list ops)))
(cond ((eq opgroup-filter t)
(setq opgroup-filter (lambda (opgroup) t)))
((not (functionp opgroup-filter))
(setq opgroup-filter `(lambda (opgroup)
(memq opgroup ',opgroup-filter)))))
(cond ((eq op-filter t)
(setq op-filter (lambda (op) t)))
((stringp op-filter)
(setq op-filter `(lambda (op)
(string-match ,op-filter op)))))
(unless xlate
(setq xlate 'identity))
(c-with-syntax-table (c-lang-const c-mode-syntax-table)
(delete-duplicates
(mapcan (lambda (opgroup)
(when (if (symbolp (car opgroup))
(when (funcall opgroup-filter (car opgroup))
(setq opgroup (cdr opgroup))
t)
t)
(mapcan (lambda (op)
(when (funcall op-filter op)
(let ((res (funcall xlate op)))
(if (listp res) res (list res)))))
opgroup)))
ops)
:test 'equal)))
;; This inserts the bulk of the code.
(require 'cc-mode)
;; These are only required at compile time to get the sources for the
;; language constants. (The cc-fonts require and the font-lock
;; related constants could additionally be put inside an
;; (eval-after-load "font-lock" ...) but then some trickery is
;; necessary to get them compiled.)
(eval-when-compile
(let ((load-path
(if (and (boundp 'byte-compile-dest-file)
(stringp byte-compile-dest-file))
(cons (file-name-directory byte-compile-dest-file) load-path)
load-path)))
(load "cc-mode" nil t)
(load "cc-fonts" nil t)
(load "cc-langs" nil t)))
(eval-and-compile
;; Make our mode known to the language constant system. Use Java
;; mode as the fallback for the constants we don't change here.
;; This needs to be done also at compile time since the language
;; constants are evaluated then.
(c-add-language 'vala-mode 'java-mode))
;; Java uses a series of regexes to change the font-lock for class
;; references. The problem comes in because Java uses Pascal (leading
;; space in names, SomeClass) for class and package names, but
;; Camel-casing (initial lowercase, upper case in words,
;; i.e. someVariable) for variables.
;;(error (byte-compile-dest-file))
;;(error (c-get-current-file))
(c-lang-defconst c-opt-after-id-concat-key
vala (if (c-lang-const c-opt-identifier-concat-key)
(c-lang-const c-symbol-start)))
(c-lang-defconst c-basic-matchers-before
vala `(
;;;; Font-lock the attributes by searching for the
;;;; appropriate regex and marking it as TODO.
;;,`(,(concat "\\(" vala-attribute-regex "\\)")
;; 0 font-lock-function-name-face)
;; Put a warning face on the opener of unclosed strings that
;; can't span lines. Later font
;; lock packages have a `font-lock-syntactic-face-function' for
;; this, but it doesn't give the control we want since any
;; fontification done inside the function will be
;; unconditionally overridden.
,(c-make-font-lock-search-function
;; Match a char before the string starter to make
;; `c-skip-comments-and-strings' work correctly.
(concat ".\\(" c-string-limit-regexp "\\)")
'((c-font-lock-invalid-string)))
;; Fontify keyword constants.
,@(when (c-lang-const c-constant-kwds)
(let ((re (c-make-keywords-re nil
(c-lang-const c-constant-kwds))))
`((eval . (list ,(concat "\\<\\(" re "\\)\\>")
1 c-constant-face-name)))))
;; Fontify all keywords except the primitive types.
,`(,(concat "\\<" (c-lang-const c-regular-keywords-regexp))
1 font-lock-keyword-face)
;; Fontify leading identifiers in fully
;; qualified names like "Foo.Bar".
,@(when (c-lang-const c-opt-identifier-concat-key)
`((,(byte-compile
`(lambda (limit)
(while (re-search-forward
,(concat "\\(\\<" ; 1
"\\(" (c-lang-const c-symbol-key)
"\\)" ; 2
"[ \t\n\r\f\v]*"
(c-lang-const
c-opt-identifier-concat-key)
"[ \t\n\r\f\v]*"
"\\)"
"\\("
(c-lang-const
c-opt-after-id-concat-key)
"\\)")
limit t)
(unless (progn
(goto-char (match-beginning 0))
(c-skip-comments-and-strings limit))
(or (get-text-property (match-beginning 2) 'face)
(c-put-font-lock-face (match-beginning 2)
(match-end 2)
c-reference-face-name))
(goto-char (match-end 1)))))))))
))
;; Vala does not allow a leading qualifier operator. It also doesn't
;; allow the ".*" construct of Java. So, we redo this regex without
;; the "\\|\\*" regex.
(c-lang-defconst c-identifier-key
vala (concat "\\(" (c-lang-const c-symbol-key) "\\)" ; 1
(concat "\\("
"[ \t\n\r\f\v]*"
(c-lang-const c-opt-identifier-concat-key)
"[ \t\n\r\f\v]*"
(concat "\\("
"\\(" (c-lang-const c-symbol-key) "\\)"
"\\)")
"\\)*")))
;; Vala has a few rules that are slightly different than Java for
;; operators. This also removed the Java's "super" and replaces it
;; with the Vala's "base".
(c-lang-defconst c-operators
vala `((prefix "base")))
;; Vala directives ?
;; (c-lang-defconst c-opt-cpp-prefix
;; csharp "^\\s *#.*")
;; Vala uses the following assignment operators
(c-lang-defconst c-assignment-operators
vala '("=" "*=" "/=" "%=" "+=" "-=" ">>=" "<<="
"&=" "^=" "|=" "++" "--"))
;; This defines the primative types for Vala
(c-lang-defconst c-primitive-type-kwds
vala '("void" "char" "int" "float" "double" "string"))
;; The keywords that define that the following is a type, such as a
;; class definition.
(c-lang-defconst c-type-prefix-kwds
vala '("class" "interface" "struct" "enum" "signal"))
;; Type modifier keywords. They appear anywhere in types, but modifiy
;; instead create one.
(c-lang-defconst c-type-modifier-kwds
vala '("const"))
;; Structures that are similiar to classes.
(c-lang-defconst c-class-decl-kwds
vala '("class" "interface"))
;; The various modifiers used for class and method descriptions.
(c-lang-defconst c-modifier-kwds
vala '("public" "partial" "private" "const" "abstract"
"protected" "ref" "in" "out" "static" "virtual"
"override" "params" "internal" "weak" "owned"
"unowned"))
;; We don't use the protection level stuff because it breaks the
;; method indenting. Not sure why, though.
(c-lang-defconst c-protection-kwds
vala nil)
;; Define the keywords that can have something following after them.
(c-lang-defconst c-type-list-kwds
vala '("struct" "class" "interface" "is" "as"
"delegate" "event" "set" "get" "add" "remove"
"callback" "signal" "var" "default"))
;; This allows the classes after the : in the class declartion to be
;; fontified.
(c-lang-defconst c-typeless-decl-kwds
vala '(":"))
;; Sets up the enum to handle the list properly
(c-lang-defconst c-brace-list-decl-kwds
vala '("enum" "errordomain"))
;; We need to remove Java's package keyword
(c-lang-defconst c-ref-list-kwds
vala '("using" "namespace" "construct"))
;; Follow-on blocks that don't require a brace
(c-lang-defconst c-block-stmt-2-kwds
vala '("for" "if" "switch" "while" "catch" "foreach" "lock"))
;; Statements that break out of braces
(c-lang-defconst c-simple-stmt-kwds
vala '("return" "continue" "break" "throw"))
;; Statements that allow a label
;; TODO?
(c-lang-defconst c-before-label-kwds
vala nil)
;; Constant keywords
(c-lang-defconst c-constant-kwds
vala '("true" "false" "null"))
;; Keywords that start "primary expressions."
(c-lang-defconst c-primary-expr-kwds
vala '("this" "base"))
;; We need to treat namespace as an outer block to class indenting
;; works properly.
(c-lang-defconst c-other-block-decl-kwds
vala '("namespace"))
;; We need to include the "in" for the foreach
(c-lang-defconst c-other-kwds
vala '("in" "sizeof" "typeof"))
(require 'cc-awk)
(c-lang-defconst c-at-vsemi-p-fn
vala 'c-awk-at-vsemi-p)
(defcustom vala-font-lock-extra-types nil
"*List of extra types (aside from the type keywords) to recognize in Vala mode.
Each list item should be a regexp matching a single identifier.")
(defconst vala-font-lock-keywords-1 (c-lang-const c-matchers-1 vala)
"Minimal highlighting for Vala mode.")
(defconst vala-font-lock-keywords-2 (c-lang-const c-matchers-2 vala)
"Fast normal highlighting for Vala mode.")
(defconst vala-font-lock-keywords-3 (c-lang-const c-matchers-3 vala)
"Accurate normal highlighting for Vala mode.")
(defvar vala-font-lock-keywords vala-font-lock-keywords-3
"Default expressions to highlight in Vala mode.")
(defvar vala-mode-syntax-table
nil
"Syntax table used in vala-mode buffers.")
(or vala-mode-syntax-table
(setq vala-mode-syntax-table
(funcall (c-lang-const c-make-mode-syntax-table vala))))
(defvar vala-mode-abbrev-table nil
"Abbreviation table used in vala-mode buffers.")
(c-define-abbrev-table 'vala-mode-abbrev-table
;; Keywords that if they occur first on a line
;; might alter the syntactic context, and which
;; therefore should trig reindentation when
;; they are completed.
'(("else" "else" c-electric-continued-statement 0)
("while" "while" c-electric-continued-statement 0)
("catch" "catch" c-electric-continued-statement 0)
("finally" "finally" c-electric-continued-statement 0)))
(defvar vala-mode-map (let ((map (c-make-inherited-keymap)))
;; Add bindings which are only useful for Vala
map)
"Keymap used in vala-mode buffers.")
;;(easy-menu-define vala-menu vala-mode-map "Vala Mode Commands"
;; ;; Can use `vala' as the language for `c-mode-menu'
;; ;; since its definition covers any language. In
;; ;; this case the language is used to adapt to the
;; ;; nonexistence of a cpp pass and thus removing some
;; ;; irrelevant menu alternatives.
;; (cons "Vala" (c-lang-const c-mode-menu vala)))
;;; Autoload mode trigger
(add-to-list 'auto-mode-alist '("\\.vala$" . vala-mode))
(add-to-list 'auto-mode-alist '("\\.vapi$" . vala-mode))
;; Custom variables
(defcustom vala-mode-hook nil
"*Hook called by `vala-mode'."
:type 'hook
:group 'c)
;;; The entry point into the mode
;;;###autoload
(defun vala-mode ()
"Major mode for editing Vala code.
This is a simple example of a separate mode derived from CC Mode
to support a language with syntax similar to
C#/C/C++/ObjC/Java/IDL/Pike.
The hook `c-mode-common-hook' is run with no args at mode
initialization, then `vala-mode-hook'.
Key bindings:
\\{vala-mode-map}"
(interactive)
(kill-all-local-variables)
(c-initialize-cc-mode t)
(set-syntax-table vala-mode-syntax-table)
(setq major-mode 'vala-mode
mode-name "Vala"
local-abbrev-table vala-mode-abbrev-table
abbrev-mode t)
(use-local-map c-mode-map)
;; `c-init-language-vars' is a macro that is expanded at compile
;; time to a large `setq' with all the language variables and their
;; customized values for our language.
(c-init-language-vars vala-mode)
;; `c-common-init' initializes most of the components of a CC Mode
;; buffer, including setup of the mode menu, font-lock, etc.
;; There's also a lower level routine `c-basic-common-init' that
;; only makes the necessary initialization to get the syntactic
;; analysis and similar things working.
(c-common-init 'vala-mode)
;;(easy-menu-add vala-menu)
(c-set-style "linux")
(setq indent-tabs-mode t)
(setq c-basic-offset 4)
(setq tab-width 4)
(c-toggle-auto-newline -1)
(c-toggle-hungry-state -1)
(run-hooks 'c-mode-common-hook)
(run-hooks 'vala-mode-hook)
(c-update-modeline))
(provide 'vala-mode)
;;; vala-mode.el ends here

1179
emacs.d/zenburn.el Normal file

File diff suppressed because it is too large Load diff

View file

@ -4,4 +4,4 @@ REM An install script for windows
echo "Copying .emacs to %APPDATA%\\" echo "Copying .emacs to %APPDATA%\\"
copy /Y .emacs %APPDATA%\ copy /Y .emacs %APPDATA%\
echo "Copying .emacs.d to %APPDATA%\\" echo "Copying .emacs.d to %APPDATA%\\"
copy /Y .emacs.d %APPDATA%\ copy /Y .emacs.d %APPDATA%\.emacs.d\

View file

@ -1,20 +1,23 @@
#!/bin/bash
INSTALL_BASEFILE=`readlink -f $0` INSTALL_BASEFILE=`readlink -f $0`
INSTALL_BASEDIR=`dirname $INSTALL_BASEFILE` INSTALL_BASEDIR=`dirname $INSTALL_BASEFILE`
CMD="ln -sfn" CMD="ln -sfn"
function linkmy
{
echo "Linking $INSTALL_BASEDIR/$1 to $HOME/$2"
$CMD $INSTALL_BASEDIR/$1 $HOME/$2
}
# XDEFAULTS # XDEFAULTS
echo "Linking $INSTALL_BASEDIR/.Xdefaults to $HOME/.Xdefaults" linkmy Xdefaults .Xdefaults
$CMD $INSTALL_BASEDIR/Xdefaults $HOME/.Xdefaults
# XMODMAP # XMODMAP
echo "Linking $INSTALL_BASEDIR/.Xmodmap to $HOME/.Xmodmap" linkmy Xmodmap .Xmodmap
$CMD $INSTALL_BASEDIR/Xmodmap $HOME/.Xmodmap
# NCMPCPP # NCMPCPP
echo "Linking $INSTALL_BASEDIR/ncmpcpp to $HOME/.ncmpcpp" linkmy ncmpcpp .ncmpcpp
$CMD $INSTALL_BASEDIR/ncmpcpp $HOME/.ncmpcpp
# AWESOME # AWESOME
echo "Linking $INSTALL_BASEDIR/config/awesome to $HOME/.config/awesome" linkmy config/awesome .config/awesome
$CMD $INSTALL_BASEDIR/config/awesome $HOME/.config/awesome # EMACS
linkmy emacs .emacs
linkmy emacs.d .emacs.d