Emacs Init for HP Laptop

gistfile1.el

;;; generic Emacs utility
;;; ------------------------------------------------------------------

(defun add-subdirs-to-load-path (dir)
  (let ((default-directory (concat dir "/")))
    (normal-top-level-add-subdirs-to-load-path)))

;;; basic load-path setup
;;; ------------------------------------------------------------------

(add-to-list 'load-path (convert-standard-filename (expand-file-name "~/.emacs.d")))
(add-subdirs-to-load-path (convert-standard-filename (expand-file-name "~/.emacs.d")))

(require 'tramp)
(require 'dedicated)
(require 'winner)
(require 'windmove)
(require 'color-theme)
(require 'etags-select)
(require 'compile)
(require 'cc-mode)
(require 'unrealscript-mode)
(require 'sunrise-commander)
(require 'ibuffer)
(require 'savehist)
(require 'imenu)
(require 'w32shell)
(require 'browse-kill-ring)
(require 'smart-scan)
(require 'mirror-mode)
(require 'hideshow)



;; yet another snippet
(require 'yasnippet)
(setq yas/root-directory (convert-standard-filename "~/.emacs.d/yasnippet-0.6.1c/snippets"))
(yas/initialize)
(yas/load-directory yas/root-directory)


;; auto-complete
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories 
	     (convert-standard-filename "~/.emacs.d/auto-complete-1.3.1/dict"))
(ac-config-default)
(require 'auto-complete-etags)

;;; useful builtins
(winner-mode 1)
(savehist-mode 1)


;; decorations
(color-theme-initialize)
(color-theme-arjen)
(setq frame-title-format "Emacs: %b (%m)")
(setq visible-bell 't)

(setq next-line-add-newlines t)

;; always re-read change files
;;(global-auto-revert-mode)

;; associate some modes with some extra filetypes
(add-to-list 'auto-mode-alist '("\\.h$" . c++-mode)) ;; to clobber inform-maybe-mode
(add-to-list 'auto-mode-alist '("\\.inl$" . c++-mode))
(add-to-list 'auto-mode-alist '("\\.xrc$" . xml-mode))
(add-to-list 'auto-mode-alist '("SConscript" . python-mode))
(add-to-list 'auto-mode-alist '("SConstruct" . python-mode))
(add-to-list 'auto-mode-alist '("\\.d$" . c-mode)) ;; for working with ECLs
(add-to-list 'auto-mode-alist '("\\.asd$" . lisp-mode))
(add-to-list 'auto-mode-alist '("\\.as$" . actionscript-mode))
(add-to-list 'auto-mode-alist '("\\.uc$" . unrealscript-mode))
(add-to-list 'auto-mode-alist '("\\.srvm\\'" . sr-virtual-mode))

;; =====================================================================
;; Redefine the window key on w32
(setq w32-lwindow-modifier 'super)
(setq w32-pass-lwindow-to-system nil)
(setq w32-rwindow-modifier 'super)
(setq w32-pass-rwindow-to-system nil)
(setq w32-pass-alt-to-system nil)
(setq w32-alt-is-meta 'meta)

(windmove-default-keybindings 'super)
(browse-kill-ring-default-keybindings)

(global-set-key [f12] 'ibuffer)
(global-set-key [(shift f12)] 'dired)
(global-set-key [(control f12)] 'sunrise)
(global-set-key [(meta f12)] 'bookmark-bmenu-list)

(global-set-key [(meta f7)] 'compile)
(global-set-key [f7] 'recompile)

(global-set-key [f9] 'smart-symbol-go-forward)
(global-set-key [(shift f9)] 'smart-symbol-go-backward)
(global-set-key [(meta f9)] 'highlight-symbol-at-point)

(defvar prev-highlight-symbol nil)

(defun highlight-symbol-at-point ()
  (interactive)
  (when prev-highlight-symbol
	(unhighlight-regexp prev-highlight-symbol))
  (setq prev-highlight-symbol    (smart-symbol-at-pt 'beginning))
  (highlight-regexp
   prev-highlight-symbol
   'hi-yellow))

(global-set-key [f5] 'visit-tags-table)
(global-set-key [(shift f5)] 'tags-search)
(global-set-key [(control f5)] 'tags-query-replace)
(global-set-key [(meta f5)] 'tags-loop-continue)
(global-set-key [(control meta f5)] 'tags-reset-tags-tables)

;; overload search on k3 (shift=backward, meta=regexp)
(global-set-key [(f3)] 'search-forward)
(global-set-key [(shift f3)] 'search-backward)
(global-set-key [(meta f3)] 'search-forward-regexp)
(global-set-key [(shift meta f3)] 'search-backward-regexp)

;; overload replacement on k4 (meta == regexp, control = query)
(global-set-key [(f4)] 'replace-string)
(global-set-key [(control f4)] 'query-replace)
(global-set-key [(meta f4)] 'replace-regexp)
(global-set-key [(control meta f4)] 'query-replace-regexp)

(global-set-key [(meta return)] 'yas/expand)
(global-set-key [(control meta f)] 'find-file-at-point)

(global-set-key [(control meta prior)] 'winner-undo)
(global-set-key [(control meta next)] 'winner-redo)

(global-set-key [(control meta e)] 'compilation-minor-mode)

;; register manipulatoin
(global-set-key [(control x) (r) (?\?)] 'view-register)

(set-default buffer-file-coding-system 'utf-8-unix)
(set-default-coding-systems 'utf-8-unix)
(prefer-coding-system 'utf-8-unix)
(set-default default-buffer-file-coding-system 'utf-8-unix)

(ido-mode 1)

(defun kill-to-register (register start end &optional delete-flag)
  (interactive "cKill to register: \nr\nP")
  (set-register register (filter-buffer-substring start end))
  (delete-region start end))

(global-set-key [(control c)(control w)] 'kill-to-register)
(global-set-key [(control c)(meta w)]	 'copy-to-register)
(global-set-key [(control c)(control y)] 'insert-register)

(defun super-skip-syntax-forward ()
  (interactive)
  (let 
	  ((syntax-here (string (char-syntax (char-after)))))
	(if (string= syntax-here "w")
		(skip-syntax-forward "w_")
	  (skip-syntax-forward syntax-here))))

(defun super-skip-syntax-backward ()  
  (interactive)
  (let 
	  ((syntax-here (string (char-syntax (char-before)))))
	(if (string= syntax-here "w")
		(skip-syntax-backward "w_")
	  (skip-syntax-backward syntax-here))))

;; kill/delete by syntax 
(defun kill-syntax (&optional arg)
  "Kill ARG sets of syntax characters after point."
  (interactive "p")
  (let ((arg (or arg 1))
		(inc (if (and arg (< arg 0)) 1 -1))
		(opoint (point)))
	(while (or;(not (= arg 0)) ;; This condition is implied.
			(and (> arg 0) (not (eobp)))
			(and (< arg 0) (not (bobp))))
	  (if (> arg 0)
		  (super-skip-syntax-forward)
		(super-skip-syntax-backward))
	  (setq arg (+ arg inc)))
	(if (and (> arg 0) (eobp))
		(message "End of buffer"))
	(if (and (< arg 0) (bobp))
		(message "Beginning of buffer"))
	(kill-region opoint (point))))

(defun kill-syntax-backward (&optional arg)
  "Kill ARG sets of syntax characters preceding point."
  (interactive "p")
  (kill-syntax (- 0 (or arg 1))))

(global-set-key [(control delete)] 'kill-syntax)
(global-set-key [(control right)] 'super-skip-syntax-forward)
(global-set-key [(control left)]  'super-skip-syntax-backward)

;; zap shouldn't be greedy -------------------------------------
(defun zap-upto-char (arg char)
  "Kill up to but not including ARG'th occurrence of CHAR.
Case is ignored if `case-fold-search' is non-nil in the current buffer.
Goes backward if ARG is negative; error if CHAR not found."
  (interactive "p\ncZap upto char: ")
  (if (char-table-p translation-table-for-input)
	  (setq char (or (aref translation-table-for-input char) char)))
  (kill-region (point)
			   (progn
				 (search-forward (char-to-string char) nil nil arg)
				 (if (minusp arg)
					 (forward-char 1)
				   (backward-char 1))
										;			 (goto-char (if (> arg 0) (1- (point)) (1+ (point))))
				 (point))))

(global-set-key [(meta z)] 'zap-upto-char)

;; -- utilities ------------------------------------------------------------

(setenv "PATH" (concat (convert-standard-filename "/wsr/gnuwin32/bin") path-separator (getenv "PATH")))
(setenv "INFOPATH" (concat (convert-standard-filename "/wsr/emacs-23.3/info") path-separator (getenv "INFOPATH")))

(defun search-site-url-portion (keyword &optional site inurl lucky) 
  (concat
   (format "search?q=%s" (url-hexify-string keyword))
   (if site (format "+site:%s" (url-hexify-string site)))
   (if inurl (format "+inurl:%s" (url-hexify-string inurl)))
   (if lucky "&btnI")))

(defun search-site-url (keyword &optional site inurl lucky)
  "Do a Google search for KEYWORD. Restrict to SITE and INURL, if specified.
Jump to best match (I Feel Lucky) if LUCKY set."
  (concat "http://www.google.com/"
		  (search-site-url-portion keyword site inlrl lucky)))


(defun search-site-url (keyword &optional site inurl lucky)
 "Do a Google search for KEYWORD. Restrict to SITE and INURL, if specified.
Jump to best match (I Feel Lucky) if LUCKY set.
"
;;  (message (list keyword site inurl lucky))
 (concat "http://www.google.com/"
         (format "search?q=%s" (url-hexify-string keyword))
         (if site (format "+site:%s" (url-hexify-string site)))
         (if inurl (format "+inurl:%s" (url-hexify-string inurl)))
         (if lucky "&btnI")))

;(defvar help-selector-methods 
;;  '( (?e "Emacs"
;;		  "www.gnu.org" "/emacs/")))

(defun help-selector ()
 (interactive)
 (message "Select [%s]: "
          (apply #'string (mapcar #'car help-selector-methods)))
 (let* ((ch (save-window-excursion
              (select-window (minibuffer-window))
              (read-char)))		
        (params (find ch help-selector-methods :key #'car)))
   (browse-url (apply #'search-site-url (thing-at-point 'symbol) (list (third params) (fourth params) (fifth params))))))

(defvar c++-mode-help-selector-methods 
  '(( ?a "Assimp"
		 "assimp.sourceforge.net" "/lib_html/" nil)
	( ?f "Fbx"
		 "http://download.autodesk.com" "/us/fbx/SDKdocs/" nil)
	( ?o "Ogre"
		 "www.ogre3d.org"  "/docs/api/html/" nil)
	( ?c "CppReference"
		 "http://www.cppreference.com" "/wiki/" nil)
	( ?w "WxWidgets"
		 "docs.wxwidgets.org" "/trunk/" nil)))

(defvar python-mode-help-selector-methods 
  '((?p
	 "Python"
	 "docs.python.org" "/ref/" t )))

(defvar clojure-mode-help-selector-methods 
  '((?c 
	 "Clojure"
	 "http://clojure.org" "/Reference/" nil) 
	(?j
	 "Java"
	 "http://java.sun.com" "/j2se/1.5.0/docs/api/" nil)))


(defvar html-mode-help-selector-methods
  '(( ?h
	  "www.htmlquick.com" "/reference/" t)
	( ?c
	  "www.w3schools.com" "/css/" t)
	( ?j 
	  "www.w3schools.com" nil t)))
  

(global-set-key [(meta f1)] 'help-selector)


(defun use-scons ()
  (interactive)
  (setenv "PATH" (concat (convert-standard-filename "/Python26") path-separator (convert-standard-filename "/Python26/Scripts") path-separator (getenv "PATH"))))

(defun use-mingw ()
  (interactive)
  (setenv "PATH" (concat (convert-standard-filename "/wsr/MinGW/bin") path-separator (getenv "PATH")))
  (setenv "INFOPATH" (concat (convert-standard-filename "/wsr/mingw/info") path-separator (getenv "INFOPATH"))))

(defun use-flex ()
  (interactive)
  (setenv "PATH" (concat (convert-standard-filename "/wsr/flex/bin") path-separator (getenv "PATH"))))

(defun use-gnuwin32 ()
  (interactive)
  (setenv "GNUWIN32" "C:\\wsr\\gnuwin32")
  (setenv "PATH" (concat "C:\\wsr\\gnuwin32\\bin" path-separator (getenv "PATH")))
  (setenv "APS2_CONFIG" "C:\\wsr\\gnuwin32\\etc")
  (setenv "INFOPATH" (concat "C:\\wsr\\gnuwin32\\info" path-separator (getenv "INFOPATH")))
  (setenv "WGETRC" "C:\\wsr\\gnuwin32\\etc\\wgetrc"))

;; emacs needs these  
(use-gnuwin32)

(defun use-swig ()
  (setenv "PATH" (concat "C:\\wsr\\swigwin-2.0.0" path-separator (getenv "PATH"))))

;; -- formatting a buffer should be quickn easy -------------------------------------
(defun indent-buffer()
  "Indent the whole buffer from point-min to point-max using
   the command indent-region"
  (interactive)	 
  (setq tab-width 4)
  (setq indent-tabs-mode t)
  (tabify 0 (point-max))
  (indent-region 0 (point-max) nil))

(defun python-repair ()
  (interactive)
  (setq tab-width 8)
  (setq python-indent 8)
  (setq indent-tabs-mode t)
  (tabify 0 (point-max))
  (indent-region 0 (point-max) nil)
  (setq tab-width 4)
  (setq python-indent 4)
  (whitespace-cleanup))

(global-set-key [f8] 'indent-buffer)

(defun astyle-buffer ()
  (interactive)
  (shell-command-on-region (point-min) (point-max)
						   "astyle --style=java --unpad-paren --keep-one-line-blocks --delete-empty-lines --indent=force-tab=4 --indent-switches --indent-cases --indent-namespaces" ;; add options here...
						   (current-buffer) t 
						   (get-buffer-create "*Astyle Errors*") t))

(global-set-key [(meta f8)] 'astyle-buffer)

;; -- tagging should use ectags and be available from withih emacs --------------------
(defun tag-directory ()
  (interactive)
  (shell-command
   (concat
	"ectags --recurse --verbose -e -o TAGS	--options=\"" (expand-file-name "~/ectags.cnf") "\"	 ."))
  (visit-tags-table "TAGS"))

(defun tag-c++ ()
  (interactive)
  (shell-command
   (concat
	"dir /b /s *.cpp *.h *.cxx *.hpp *.hh  | ectags --verbose -e -o TAGS	 --language-force=c++  --c++-kinds=cfnstunedm --extra=+q --options=\"" (expand-file-name "~/ectags.cnf") "\" -L -"))
  (visit-tags-table "TAGS"))

(defun tag-c ()
  (interactive)
  (shell-command
   (concat
	"dir /b /s *.c *.h | ectags --verbose -e -o TAGS  --language-force=c  --c-kinds=cfnstunedm --options=\"" (expand-file-name "~/ectags.cnf") "\" -L -"))
  (visit-tags-table "TAGS"))

(defun tag-headers ()
  (interactive)
  (shell-command
   (concat
	"dir /b /s *.h *.hxx *.hpp *.hh | ectags --verbose -e -o TAGS  --c-kinds=+pxd --c++-kinds=+pxd --extra=+q --options=\"" (expand-file-name "~/ectags.cnf") "\" -L -"))
  (visit-tags-table "TAGS"))


(global-set-key "\M-." 'etags-select-find-tag)
(global-set-key "\M-," 'pop-tag-mark)

(define-key ac-completing-map (kbd "TAB") nil)
(define-key ac-completing-map (kbd "\M-n") 'ac-next)
(define-key ac-completing-map (kbd "\M-p") 'ac-previous)
(setq ac-auto-start 4)
(global-set-key "\M-/" 'auto-complete)

;; -- C++ ---------------------------------------------

(require 'google-c-style)
(autoload 'expand-member-functions "member-functions" "Expand C++ member function declarations" t)

(load-file (convert-standard-filename "~/.emacs.d/sourcepair.el"))

(defconst playbox-c-style
  ;; Always indent c/c++ sources, never insert tabs
  '((c-tab-always-indent		. t)
	;; Offset for line only comments
	(c-basic-offset . 4)
	(c-comment-only-line-offset . 0)
	;; Controls the insertion of newlines before and after braces.
	(c-hanging-braces-alist		. ((substatement-open after)
								   (brace-list-open)))
	;; Controls the insertion of newlines before and after certain colons.
	(c-hanging-colons-alist		. ((member-init-intro before)
								   (inher-intro)
								   (case-label after)
								   (label after)
								   (access-label after)))
	;; List of various C/C++/ObjC constructs to "clean up".
	(c-cleanup-list				. (scope-operator
								   empty-defun-braces
								   defun-close-semi))
	;; Association list of syntactic element symbols and indentation offsets.
	(c-offsets-alist			. ((arglist-close . c-lineup-arglist)
								   (access-label      . +)
								   (namespace-open    . 0)
								   (innamespace       . 0)
								   (substatement-open . 0)
								   (case-label		  . +)
								   (block-open		  . 0)
								   (inline-open		  . 0)
								   (access-label	  . -)
								   (class-open        . +)
								   (class-close       . -)
								   (label			   . 0)
								   (knr-argdecl-intro . -)))
	(c-echo-syntactic-information-p . t))
  "Playbox C/C++ Programming Style")

(c-add-style "playbox" playbox-c-style)

;; assume filename is same as classname
(defun get-class-name ()
  (file-name-nondirectory (file-name-sans-extension buffer-file-name)))

;; insert it interactively
(defun insert-class-name  ()
  (interactive)
  (insert (get-class-name)))


(defun c-file-enter ()
  "Expands all member functions in the corresponding .h file"
  (interactive)
  (let ((c-file (buffer-name))
		(h-file (concat (substring (buffer-name (current-buffer)) 0 -3 ) "h")))
	(if (equal (substring (buffer-name (current-buffer)) -4 ) ".cpp")
		(if (file-exists-p h-file)
			(expand-member-functions h-file c-file)))))

(defun h-file-create ()
  "Create a new h file.	 Insert a infdef/define/endif block"
  (interactive)
  (if (or (equal (substring (buffer-name (current-buffer)) -2 ) ".h")
		  (equal (substring (buffer-name (current-buffer)) -4 ) ".hpp"))
	  (if (equal "" (buffer-string))
		  (insert "#ifndef "(upcase (substring (buffer-name (current-buffer)) 0 -2)) "_H\n#define "
				  (upcase (substring (buffer-name (current-buffer)) 0 -2)) "_H\n\n#endif"))))


(defun forward-c-token ()
  (c-forward-token-2 1))

(defun backward-c-token ()
  (c-forward-token-2 1))


(defun c-wx-lineup-topmost-intro-cont (langelem)
  (save-excursion
	(beginning-of-line)
	(if (re-search-forward "EVT_" (line-end-position) t)
		'c-basic-offset
	  (c-lineup-topmost-intro-cont langelem))))

(add-to-list 'c++-font-lock-extra-types
			 "\bwx[A-Z][a-z][a-zA-Z]*?\b" "\bSo[A-Z][a-z][a-zA-Z]*?\b")

(require 'semantic/find)
(require 'doc-mode)

(defun doc-tag ()
  (interactive)
  (semantic-mode 1)
  (doc-mode 1) 
  (doc-mode-fix-tag-doc)
  (doc-mode -1)
  (semantic-mode -1))

(add-hook 'c-mode-common-hook
		  (lambda ()
			(auto-revert-mode 1)
			(setq case-fold-search nil)
			(mirror-mode 1)
			(local-set-key [(meta right)] 'forward-c-token)
			(local-set-key [(meta left)] 'backward-c-token)
			;; this pisses me off to no end, unbind it
			(global-unset-key "\C-\\")
			(c-set-style "playbox")
			;; Do not check for old-style (K&R) function declarations;
			;; this speeds up indenting a lot.
			(setq c-recognize-knr-p nil)
			(setq c-basic-offset 4)
			(setq compile-command "scons -u  ")
			(setq dabbrev-case-fold-search nil)
			(setq dabbrev-case-replace nil)
			(setq dabbrev-case-distinction nil)
			(local-set-key [(control c) t] 'sourcepair-load)
			(local-set-key [(meta f11)] 'doc-tag)
			(local-set-key "\r" 'newline-and-indent)			
			(h-file-create)
			(hs-minor-mode 1)
			(c-set-offset 'topmost-intro-cont 'c-wx-lineup-topmost-intro-cont)
			(local-set-key [(meta ?#)] 'insert-class-name)
			(auto-complete-mode 1)
			(setq ac-sources '(ac-source-words-in-buffer ac-source-etags  ac-source-words-in-same-mode-buffers))
			(set (make-local-variable  'help-selector-methods) c++-mode-help-selector-methods)))



;; -- GLSL ---
(require 'glsl-mode)
(autoload 'glsl-mode "glsl-mode" nil t)
(add-to-list 'auto-mode-alist '("\\.vert\\'" . glsl-mode))
(add-to-list 'auto-mode-alist '("\\.frag\\'" . glsl-mode))

;; -- PYTHON -------------------------------------

  

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;										   

(require 'python)
(setq tab-width 4)							   
(setq python-indent 4)
(setenv "PATH" (concat (convert-standard-filename "/Python26") path-separator	 (getenv "PATH")))
(add-hook 'python-mode-hook 
		  (lambda ()
			;; this hook is local, can't add it globally
			(add-hook 'write-contents-functions 'delete-trailing-whitespace)
			(setq ac-sources '(ac-source-words-in-same-mode-buffers ac-source-yasnippet))
			;;			  (ac-ropemacs-setup)
			(auto-complete-mode 1)
			(setq indent-tabs-mode t)
			(setq tab-width 4)							   
			(setq python-indent 4)
			(set (make-local-variable 'help-selector-methods) python-mode-help-selector-methods)))


;; -- HTML -------------------------------------

(add-hook 'html-mode-hook
		  (lambda ()
			(set (make-local-variable  'help-selector-methods) html-mode-help-selector-methods)))

;; -- BACKUPS --------------------------------------------------------
;; Put autosave files (ie #foo#) in one place, *not*
;; scattered all over the file system!
(defvar autosave-dir (expand-file-name "~/emacs.bak"))

(make-directory autosave-dir t)

(defun auto-save-file-name-p (filename)
  (string-match "^#.*#$" (file-name-nondirectory filename)))

(defun make-auto-save-file-name ()
  (concat autosave-dir
		  (if buffer-file-name
			  (concat "#" (file-name-nondirectory buffer-file-name) "#")
			(expand-file-name
			 (concat "#%" (buffer-name) "#")))))

;; Put backup files (ie foo~) in one place too. (The backup-directory-alist
;; list contains regexp=>directory mappings; filenames matching a regexp are
;; backed up in the corresponding directory. Emacs will mkdir it if necessary.)
(defvar backup-dir (expand-file-name "~/emacs.bak"))
(setq backup-directory-alist (list (cons "." backup-dir)))

(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.
 '(ac-candidate-limit 7)
 '(ac-delay 0.3)
 '(ac-dwim nil)
 '(ac-use-fuzzy nil)
 '(browse-url-browser-function (quote browse-url-default-windows-browser))
 '(browse-url-generic-program "C:\\Program Files\\Opera\\opera.exe")
 '(clojure-src-root "c:/wsr/lisp/clojure-1.2.0")
 '(compilation-window-height 16)
 '(desktop-modes-not-to-save nil)
 '(display-time-mode nil)
 '(ecb-layout-window-sizes (quote (("top1" (ecb-directories-buffer-name 0.3140096618357488 . 0.21428571428571427) (ecb-sources-buffer-name 0.21739130434782608 . 0.21428571428571427) (ecb-methods-buffer-name 0.4975845410628019 . 0.21428571428571427)))))
 '(ecb-options-version "2.40")
 '(ecb-source-path (quote (("C:\\Documents and Settings\\john.connors\\My Documents\\Visual Studio 2008\\Projects\\cyan_source\\" "cyan_source") ("C:\\Documents and Settings\\john.connors\\My Documents\\Visual Studio 2008\\Projects\\cyan_source\\" "cyan_research"))))
 '(ido-enable-tramp-completion nil)
 '(inferior-lisp-program "\\wsr\\lisp\\ccl\\wx86cl.exe -l C:/wsr/lisp/ccl/cclrc.lisp")
 '(python-indent 4)
 '(python-python-command "c:\\\\python26\\\\python.exe")
 '(rcirc-default-nick "ZabaQ")
 '(save-place t nil (saveplace))
 '(scroll-conservatively 200)
 '(semantic-c-dependency-system-include-path (quote ("/wsr/mingw/include")))
 '(semantic-default-submodes nil)
 '(semanticdb-persistent-path (quote (never)))
 '(show-paren-mode t)
 '(size-indication-mode t)
 '(sourcepair-header-path (quote ("." ".." "../include" "./include")))
 '(sourcepair-source-path (quote ("." ".." "./src" "../src")))
 '(special-display-regexps (quote ("\"[ ]?[*][^*]+[*]\"")))
 '(split-height-threshold nil)
 '(split-width-threshold nil)
 '(swank-clojure-classpath (quote ("\\wsr\\lisp\\clojure-1.1.0\\clojure.jar" "\\wsr\\lisp\\clojure-contrib-1.1.0\\clojure-contrib.jar" "\\wsr\\emacs\\site-lisp\\swank-clojure\\swank-clojure-1.2.1.jar")))
 '(swank-clojure-extra-vm-args (list "-server" "-Xms128M" "-Xmx512M" "-Dfile.encoding=UTF-8"))
 '(swank-clojure-jar-home "c:\\wsr\\emacs\\site-lisp\\swank-clojure\\")
 '(swank-clojure-java-path (convert-standard-filename "/Program Files/Java/jdk1.6.0_17/bin/java.exe"))
 '(tab-width 4)
 '(tool-bar-mode nil)
 '(tramp-mode nil)
 '(uniquify-buffer-name-style (quote forward) nil (uniquify))
 '(vc-handled-backends nil)
 '(w32shell-emacsw32-gnuwin32-bindir "C:\\wsr\\gnuwin32\\bin")
 '(w32shell-msys-bin "C:\\wsr\\msys\\bin\\"))
(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.
 '(default ((t (:inherit nil :stipple nil :background "black" :foreground "White" :inverse-video nil :box nil :strike-through nil :overline nil :underline nil :slant normal :weight normal :height 83 :width normal :foundry "outline" :family "Consolas")))))


(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(put 'narrow-to-region 'disabled nil)