From: Da Zhang <zhangda82@gmail.com>
To: 10192@debbugs.gnu.org
Subject: bug#10192: Emacs 24.0.92 windows build, fatal error with M-< or M->
Date: Fri, 02 Dec 2011 00:20:21 -0500 [thread overview]
Message-ID: <4ED86015.4010705@gmail.com> (raw)
[-- Attachment #1.1: Type: text/plain, Size: 868 bytes --]
Dear Yidong,
I am a dedicated Emacs user who is excited for the new Emacs 24. I have tried the 3 pretests of Emacs 24, and I saw improvements of its stability from each pretest. For example, with my current extensive .emacs configuration file, the first 2 pretests were not able to start normally. However, all the three pretests have the following problems:
1. after the .emacs file is loaded into the pretest Emacs, when I press M-< or M->, the program abort with a fatal error: "A fatal error has occurred! Would you like to attach a debugger? Select Yes to debug, No to abort Emacs..."
2. certain part of eieio is not available, and the emacs prompts with "Symbol's function definition is void: eieio--defgeneric-init-form"
I am not sure if other windows users have experienced the same problem. I attached my .emacs file. Thanks for your attention.
Da Zhang
[-- Attachment #1.2: Type: text/html, Size: 1383 bytes --]
[-- Attachment #2: .emacs --]
[-- Type: text/plain, Size: 111665 bytes --]
;; Filename: .emacs
;; Description:
;; Author: Da Zhang
;; Created: Tue Sep 30 01:18:02 2008
;; Da Zhang
;; Update #: 2576
;;
;;; Commentary:
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;; -*- Mode: Emacs-Lisp -*- ;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Code:
;;{{{ General settings {begin}--------------------
(defalias 'ttl 'toggle-truncate-lines)
(defalias 'sbm 'scroll-bar-mode)
(defalias 'menu 'menu-bar-mode)
(defalias 'tbm 'tool-bar-mode)
(defalias 'repl 'query-replace-regexp)
(defalias 'mkh 'make-header)
(defalias 'flb 'flyspell-buffer)
(defalias 'flm 'flyspell-mode)
(defalias 'flr 'flyspell-region)
(defalias 'prb 'ps-print-buffer)
(defalias 'prr 'ps-print-region)
(defalias 'printb 'htmlize-view-buffer)
(defalias 'printr 'htmlize-view-region)
(defalias 'sht 'shell-toggle)
(defalias 'trp 'transparency_plus)
(defalias 'trm 'transparency_minus)
(defalias 'trn 'transparencey_normal)
(defalias 'stw 'show-ws-toggle-show-trailing-whitespace)
(defalias 'font 'menu-set-font)
(defalias 'obp 'open-buffer-path)
(defalias 'zoomin 'text-scale-increase)
(defalias 'zoomout 'text-scale-decrease)
(defalias 'res 'research)
(defalias 'rep 'report)
(defalias 'fold 'folding-mode)
(defalias 'wc 'word-count)
;; Change cursor color according to mode
(defvar set-cursor-color-color "")
(defvar set-cursor-color-buffer "")
(defun set-cursor-color-according-to-mode ()
"change cursor color according to some minor modes."
;; set-cursor-color is somewhat costly, so we only call it when needed:
(let ((color
(if buffer-read-only "white"
(if overwrite-mode "red"
"red3"))))
(unless (and
(string= color set-cursor-color-color)
(string= (buffer-name) set-cursor-color-buffer))
(set-cursor-color (setq set-cursor-color-color color))
(setq set-cursor-color-buffer (buffer-name)))))
(add-hook 'post-command-hook 'set-cursor-color-according-to-mode)
;; set the cursor as a bar instead the rectangular block
(setq-default cursor-type 'box)
;; for cygwin's Emacs
(add-to-list 'load-path "c:/Emacs/site-lisp/")
;; disable the scroll bar on the right by default
(scroll-bar-mode t)
;; highlight the current line, as in Matlab
(global-hl-line-mode t)
;; disable the WoMan-log buffer
(setq-default woman-show-log nil)
(setq-default woman-ignore t)
;; when you mark a region, you can delete it or replace it as in other Windows programs:
;; simply hit delete or type whatever you want or yank
(delete-selection-mode t)
;; make the slow activity to echo my unfinished commands faster
(setq-default echo-keystrokes 0.1)
;; let there be a marker on every empty line on the left fringe: not needed, so nil
(setq-default default-indicate-empty-lines nil)
;; for Emacs 23 only. use the system's trash can when deleting files and foldrs
(setq-default delete-by-moving-to-trash t)
;; by default, do not display continuation lines, instead, give each line of the text just one screen line
(setq-default truncate-lines nil)
;; show the matching parentheses immediately
(setq-default show-paren-delay 0)
;; display the name of the current function at the mode-line
(which-function-mode t)
;; (setq visible-bell t) ; turn off the bell when we have error
(setq ring-bell-function 'ignore) ; no bells
(setq inhibit-startup-message t) ; turn off the startup message
(setq column-number-mode t) ; display the column number
(setq mouse-yank-at-point t) ; prevent the mouse yanking at click. So move the caret first,
; then use middle key of mouse to yank there
(setq kill-ring-max 200) ; to have a very long kill ring so that I can recover more.
(setq default-fill-column 120) ; set the fill-column as XXX columns for easy reading, 80 is default
(setq-default indent-tabs-mode nil) ; don't use TAB to indent.
(setq default-tab-width 4) ; set the default TAB width to 4 characters.
(setq sentence-end-double-space nil) ; don't insert 2 spaces after sentence end.
(setq enable-recursive-minibuffers t) ; t means to enable me to use minibuffer recursively. but I don't like it
(defun stop-using-minibuffer ()
"kill the minibuffer"
(when (>= (recursion-depth) 1)
(abort-recursive-edit)))
(add-hook 'mouse-leave-buffer-hook 'stop-using-minibuffer)
;; (setq scroll-step 1)
;; (setq mouse-wheel-scroll-amount '(1 ((shift) . 1) ((control))))
;; for smooth scrolling and disabling the automatical recentering of emacs when moving the cursor
(setq-default scroll-margin 0
scroll-conservatively 0
scroll-up-aggressively 0.01
scroll-down-aggressively 0.01)
(setq scroll-preserve-screen-position t)
(setq default-major-mode 'text-mode) ; set the default mode
(show-paren-mode t) ; match parentheses
(setq show-paren-style 'parenthesis) ; when matching parentheses show the matching paren if it is visible
; otherwise show the entire expression
(mouse-avoidance-mode 'jump) ; when caret is close to mouse pointer, move
; the mouse pointer away automatically
; how the title of the buffer is displayed
; (setq frame-title-format "%b")
(auto-image-file-mode 1) ; enable emacs to open and display pictures directly
(fset 'yes-or-no-p 'y-or-n-p) ; use y/n rather than yes/no as choices
(display-time) ; display time
(global-font-lock-mode t) ; syntax highlighting
(setq font-lock-maximum-decoration t)
(setq font-lock-verbose t)
(setq font-lock-maximum-size '((t . 1048576) (vm-mode . 5250000)))
(transient-mark-mode t) ; use high contrast to show region
(tool-bar-mode t) ; don't want that big tool bar
(setq user-full-name "Da Zhang") ; personal information
(add-hook 'text-mode-hook 'turn-on-auto-fill) ; wrap long lines in text mode
(setq compile-command "make")
;; when the caret is at the end of line and you want to move it up, it stays at each line's end: t
;; when the caret is at the end of line and you want to move it up, it stays at each line's end: nil
(setq track-eol nil)
;; set up emacs so that it generates backup files
(setq make-backup-files t)
(setq-default make-backup-files t)
;; Backups in ~/.backups/emacs/ folder
(defun make-backup-file-name (FILE)
(let ((dirname (concat "~/.backups/emacs/"
(format-time-string "%y/%m/%d/"))))
(if (not (file-exists-p dirname))
(make-directory dirname t))
(concat dirname (file-name-nondirectory FILE))))
;; kill a line and the RET together by C-k
(setq-default kill-whole-line t)
;; show-wspace, load this library to enable several nice features: show-ws-toggle-show-hard-spaces,
;; show-ws-toggle-show-tabs
(require 'show-wspace)
;; "focus follows mouse": the window your mouse pointer is over receives focus (input) so you don't need to click on it
;; to give it focus.
(setq mouse-autoselect-window nil)
;; set the default encoding system
(prefer-coding-system 'utf-8)
;; htmlize: output color highlighted file into html file
(require 'htmlize)
(add-to-list 'auto-mode-alist '("\\.htm$" . html-mode))
(add-to-list 'auto-mode-alist '("\\.html$" . html-mode))
(add-to-list 'auto-mode-alist '("\\.tmpl$" . html-mode))
(add-to-list 'auto-mode-alist '("\\.xml$" . xml-mode))
;; my version of revert-buffer
(defun da-revert-buffer (&optional arg)
"save the current position to tmp, then call revert-buffer, then goto-char(position)"
(interactive "P")
(defvar tmp)
(setq tmp (point))
(if arg
(revert-buffer t t)
(revert-buffer t)
)
(goto-char tmp)
(kill-local-variable 'tmp))
;; several quick accesses
(defun work ()
"Switch to my work dir."
(interactive)
(find-file "C:/Documents and Settings/da/My Documents/work")
)
(defun research ()
"Switch to my research dir."
(interactive)
(find-file "C:/research")
)
(defun report ()
"Switch to my research dir."
(interactive)
(find-file "C:/Documents and Settings/da/My Documents/report")
)
(defun lit ()
"Switch to the literature folder."
(interactive)
(find-file "C:/Documents and Settings/da/My Documents/literature")
)
(defun doc ()
"Switch to the literature folder."
(interactive)
(find-file "C:/Documents and Settings/da/My Documents")
)
(defun matlab-dir ()
"Switch to the literature folder."
(interactive)
(find-file "C:/MATLAB2008a/work/Da_matural_subroutines")
)
;; modify kill line and kill region so that if M-w or C-w without an active region, just copy the line
(defadvice kill-ring-save (before slick-copy activate compile) "When called
interactively with no active region, copy a single line instead."
(interactive (if mark-active (list (region-beginning) (region-end)) (message
"Copied line") (list (line-beginning-position) (line-beginning-position
2)))))
(defadvice kill-region (before slick-cut activate compile)
"When called interactively with no active region, kill a single line instead."
(interactive
(if mark-active (list (region-beginning) (region-end))
(list (line-beginning-position)
(line-beginning-position 2)))))
;; Load the appropriate interaction-mode for given source file extensions
(setq auto-mode-alist
(append '(("\\.pl$" . perl-mode)
("\\.perl$" . perl-mode)
("\\.txt$" . text-mode)
("\\.html$" . html-mode)
("\\.java$" . java-mode)
("\\.nqc$" . c++-mode)
("\\.C$". c++-mode)
("\\.H$". c++-mode)
("\\.h$". c++-mode)
("\\.dra$". c++-mode)
("\\.par$". c++-mode)
("\\.env$". shell-script-mode)
("\\.eml$" . mail-mode)
("\\.org$$\\'" . org-mode)
("\\.m$$\\'" . matlab-mode)
("\\.tlc$" . tlc-mode)
("\\.ijm$" . java-mode)
)
auto-mode-alist))
;; global-auto-revert-mode
(global-auto-revert-mode t)
;; use fringe to indicate empty lines on the left
(setq-default indicate-empty-lines t
indicate-buffer-boundaries 'left)
(setq redisplay-dont-pause nil) ;; Non-nil means update isn't paused when input is detected.
(setq-default scroll-step 1) ;; change the behavior of scroll
;; start usging the version control mechanism
;; (setq version-control t)
;; (setq kept-old-version 2) ; you can backup 2 old versions, i.e, last version, the one before last version
;; (setq kept-new-versions 1); back up the new version once
;; (setq delete-old-versions t);; get rid of the old versions other than the last 2 versions
;; (setq backup-directory-alist '(("." . "~/backups"))) ; set up the path for backups
;; (setq backup-by-copying t) ; using direct copy to back up
;; default start up path:
;; (setq default-directory "C:/Documents and Settings/da/My Documents/") ; My documents
;; just to turn on these settings
;; (put 'set-goal-column 'disabled nil)
;; (put 'upcase-region 'disabled nil)
;; (put 'downcase-region 'disabled nil)
;; (put 'LaTeX-hide-environment 'disabled nil)
;; REMOVE TRAILING WHITESPACES BEFORE SAVING (NOW LOCAL)
;; (add-hook 'before-save-hook 'delete-trailing-whitespace)
;; ;; Non-nil means to automatically adjust `window-vscroll' to view tall lines.
;; (setq-default auto-window-vscroll nil)
;; ;; midnight mode
;; (require 'midnight)
;; (setq clean-buffer-list-delay-general 2)
;;}}} General settings {end}--------------------
;;{{{ ELPA {begin}--------------------
;;; This was installed by package-install.el.
;;; This provides support for the package system and
;;; interfacing with ELPA, the package archive.
;;; Move this code earlier if you want to reference
;;; packages in your .emacs.
(when
(load
(expand-file-name "~/.emacs.d/elpa/package.el"))
(package-initialize))
(setq package-archives '(("ELPA" . "http://tromey.com/elpa/")
("gnu" . "http://elpa.gnu.org/packages/")
("marmalade" . "http://marmalade-repo.org/packages/")))
;;}}} ELPA {end}--------------------
;;{{{ Transparency {begin}--------------------
(defun opacity-modify (&optional dec)
"modify the transparency of the emacs frame; if DEC is t,
decrease the transparency, otherwise increase it in 20%-steps"
(let* ((alpha-or-nil (frame-parameter nil 'alpha)) ; nil before setting
(oldalpha (if alpha-or-nil alpha-or-nil 100))
(newalpha (if dec (- oldalpha 10) (+ oldalpha 10))))
(when (and (>= newalpha frame-alpha-lower-limit) (<= newalpha 100))
(modify-frame-parameters nil (list (cons 'alpha newalpha))))))
(defun transparency_plus ()
"increase the transparency"
(interactive)
(opacity-modify t))
(defun transparency_minus ()
"decrease the transparency"
(interactive)
(opacity-modify))
(defun transparencey_normal ()
"make the transparency to normal"
(interactive)
(modify-frame-parameters nil `((alpha . 100))))
;;}}} Transparency {end}--------------------
;;{{{ Diary and calendar {begin}--------------------
;; set the latitude and longitude of Norman, OK so that Emacs can calculate the
;; time of sunrise and sunset for me
(setq calendar-latitude +42.37)
(setq calendar-longitude -71.03)
(setq calendar-location-name "Boston, MA")
;; set up how calendar displays
(setq calendar-remove-frame-by-deleting t)
(setq calendar-week-start-day 1) ; a week starts at Monday
(setq mark-diary-entries-in-calendar t) ; mark the dates where I have diaries
;; (setq mark-holidays-in-calendar nil) ; don't show hoildays on the calendar
;; (setq view-calendar-holidays-initially nil) ; don't show holidays when the calendar starts
;; set up diary
(setq diary-file "~/diary");; the default diary path
(setq diary-mail-addr "daveluciffer@gmail.com")
(add-hook 'diary-hook 'appt-make-list)
;;}}} Diary and calendar {end}--------------------
;;{{{ Auctex Settings {begin}--------------------
;; Reftex activation
(autoload 'reftex-mode "reftex" "RefTeX Minor Mode" t)
(autoload 'turn-on-reftex "reftex" "RefTeX Minor Mode" nil)
(autoload 'reftex-citation "reftex-cite" "Make citation" nil)
(autoload 'reftex-index-phrase-mode "reftex-index" "Phrase mode" t)
(add-hook 'LaTeX-mode-hook 'turn-on-reftex) ; with AUCTeX LaTeX mode
(add-hook 'latex-mode-hook 'turn-on-reftex) ; with Emacs latex mode
(setq reftex-plug-into-AUCTeX t)
;; ;; enable document parcing
(setq TeX-auto-save t)
(setq TeX-parse-self t)
;; To get a full featured LaTeX-section command, insert: http://www.gnu.org/software/auctex/manual/auctex.html
(setq LaTeX-section-hook
'(LaTeX-section-heading
LaTeX-section-title
LaTeX-section-section
LaTeX-section-label))
;; auto fill
(add-hook 'LaTeX-mode-hook 'turn-on-auto-fill)
;; flyspell
(add-hook 'LaTeX-mode-hook 'flyspell-mode)
(add-hook 'latex-mode-hook 'flyspell-mode)
(add-hook 'TeX-mode-hook 'flyspell-mode)
;; latex toolbar
;; (add-hook 'LaTeX-mode-hook 'LaTeX-install-toolbar)
;; enable the Tex-fold-mode for all Auctex modes, which can hide (fold) and show (unfold) macros and environments
;; described in section 6.2 http://www.gnu.org/software/auctex/manual/auctex.html
(add-hook 'TeX-mode-hook (lambda ()
(TeX-fold-mode 1)
(define-key TeX-mode-map
"\C-m" 'reindent-then-newline-and-indent)))
;; enabled source-specials (for dvi inverse search) permanently
(add-hook 'TeX-mode-hook 'TeX-source-specials-mode 1)
;; variables for BibTeX auto search
(setq reftex-bibpath-environment-variables '("/cygdrive/c/H/Bib/"))
;; Add standard Sweave file extensions to the list of files recognized
;; by AUCTeX.
(setq TeX-file-extensions
'("Rnw" "rnw" "Snw" "snw" "tex" "sty" "cls" "ltx" "texi" "texinfo" "dtx"))
;; to enable auto-fill-mode in all text mode, similar to above:
;; (add-hook 'text-mode-hook 'turn-on-auto-fill)
;; if you often use /include and multifile structure, enable emacs to ask for
;; a master file every time you open a new file
;; (setq-default TeX-master nil)
;;}}} Auctex Settings {end}--------------------
;;{{{ printing {begin}--------------------
;;; Easier printing
(require 'w32-winprint)
(require 'htmlize-view)
(htmlize-view-add-to-files-menu)
;; since the correct program gsprint.exe is used, now emacs can print by
;; PostScript print XXX
(setq ps-lpr-command "C:/Program Files/Ghostgum/gsview/gsprint.exe")
;; This line causes ghostscript to query which printer to
;; use - which you may not need if, for example, you only
;; have one printer.
(setq ps-lpr-switches '("-query"))
(setq ps-printer-name t)
;; to enable the new printing package of Emacs 22
;; more options and customizations are needed to fully use this printing.el, but
;; I will leave it for later invesgivation
(require 'printing)
;; First of all, take a glance of printing documentation only to have an idea
;; of what `printing' is capable.
;; Then try to set the variables: `pr-ps-name', `pr-ps-printer-alist',
;; `pr-txt-name', `pr-txt-printer-alist' and `pr-path-alist'. These variables
;; are the main variables for printing processing.
;; Now, please, see these variables documentation more in deep. You can do
;; this by typing C-h v pr-ps-name RET (for example) if you already loaded
;; printing package, or by browsing printing.el source file.
;;}}} printing {end}--------------------
;;{{{ Muse {begin}--------------------
;; (add-to-list 'load-path "c:/Emacs/site-lisp/muse/")
;; (add-to-list 'load-path "c:/Emacs/site-lisp/muse/")
(require 'muse-mode) ; load authoring mode
(require 'muse-html) ; load publishing styles I use
(require 'muse-latex)
(require 'muse-texinfo)
(require 'muse-docbook)
(require 'muse-project) ; publish files in projects
(require 'muse-colors)
(require 'muse-wiki)
(setq muse-html-meta-content-type (concat "text/html; charset=utf-8"))
(define-key muse-mode-map [f5] 'muse-project-publish-this-file)
(add-to-list 'auto-mode-alist '("\\.muse$" . muse-mode))
(defun my-muse-mode-hook ()
(setq auto-fill-mode t)
(flyspell-mode 1)
(footnote-mode 1)
)
(add-hook 'muse-mode-hook 'my-muse-mode-hook)
;; load the customization file for muse mode and project definitions
;; location: site-lisp/muse-da-projects.el
(load "muse-da-projects")
;; muse to slides
(require 'muse-html-slidy)
;;}}} Muse {end}--------------------
;;{{{ CS-RCS mode {begin}--------------------
;; this is the integration of the ComponentSoftware CS-RCS front end of RCS in
;; windows and the emacs. CF:
;; http://www.componentsoftware.com/csrcs/Integration/emacs.htm
(load "vc-hooks")
(setq vc-path "C:/program files/ComponentSoftware/cs-rcs/system")
;; don't use the vc-toggle-read-only, use the toggle-read-only
(global-set-key (kbd "C-x C-q") 'toggle-read-only)
;;}}} CS-RCS mode {end}--------------------
;;{{{ Org-mode {begin}--------------------
(add-to-list 'load-path "c:/Emacs/site-lisp/org/")
;; (add-to-list 'load-path "C:/Emacs/site-lisp/org/")
(require 'org-install)
;; The following lines are always needed. Choose your own keys.
(add-to-list 'auto-mode-alist '("\\.org\\'" . org-mode))
;; (global-set-key (kbd "C-c l") 'org-store-link)
;; (global-set-key (kbd "C-c a") 'org-agenda)
;; (global-set-key (kbd "C-c b") 'org-iswitchb)
(setq org-hide-leading-stars t)
(setq org-log-done t)
;; set sorting strategy for org TODO items
(setq org-agenda-sorting-strategy
'((agenda priority-down time-up)
(todo priority-down category-keep)
(tags priority-down category-keep)))
;; CDLaTeX hook
(add-hook 'org-mode-hook 'turn-on-org-cdlatex)
;; allows changing todo states with S-left and S-right skipping all of the normal processing when entering or leaving a
;; todo state
(setq org-treat-S-cursor-todo-selection-as-state-change nil)
(setq org-agenda-skip-timestamp-if-done t)
;; TODO, MAYBE, STARTED, WAITING, DONE
(setq org-todo-keywords '((type "MAYBE(m)" "TODO(t)" "STARTED(s)" "WAITING(w)" "|" "DONE(d)")))
;; (setq org-todo-keyword-faces
;; '(("WAITING" . (:foreground "gray" :weight bold))))
;; (setq org-todo-keyword-faces
;; '(("MAYBE" . (:foreground "gray" :weight bold))))
;; (setq org-todo-keyword-faces
;; '(("TODO" . (:foreground "red" :weight bold))))
;; (setq org-directory "~/org")
(setq org-directory "c:/H/GTD/")
(setq org-reverse-note-order nil)
(global-set-key [f12] 'remember)
(global-set-key [C-f12] 'gtd)
(defun gtd ()
"Switch to my GTD project file."
(interactive)
(find-file "c:/H/GTD/this_week.org")
)
;; org-google-weather support
(require 'google-weather)
(require 'org-google-weather)
;; disable the translation from _ and ^ to subscript and superscript
(setq-default org-export-with-sub-superscripts nil)
;; sacha chua's org-toodledo mode for toodledo integration (http://www.toodledo.com/)
;; (require 'org-toodledo)
;; (setq org-toodledo-userid "td4bf2dc9a78677")
;; (setq org-toodledo-password "da014916")
;;}}} Org-mode {end}--------------------
;;{{{ Remember mode {begin}--------------------
(require 'remember)
(org-remember-insinuate)
(setq org-remember-templates
'(("TODO" ?t "* %?%&" "~/org/TODO.org" bottom)
("NOTES" ?n "* %?\n** %T\n" "~/org/notes.org" bottom)
("MINUTES" ?m "* %?\n** %T\n" "~/org/minutes.org" bottom)))
(setq remember-annotation-functions '(org-remember-annotation))
(setq remember-handler-functions '(org-remember-handler))
(add-hook 'remember-mode-hook 'org-remember-apply-template)
;; CF: http://metajack.im/2008/12/30/gtd-capture-with-emacs-orgmode/
;;}}} Remember mode {end}--------------------
;;{{{ outline minor mode {begin}--------------------
(global-unset-key (kbd "C-o"))
(global-set-key (kbd "M-o") 'open-line)
;; Set the minor mode prefix to C-o
(setq outline-minor-mode-prefix "\C-o")
(add-hook 'muse-mode-hook 'outline-minor-mode)
(add-hook 'html-mode-hook 'outline-minor-mode)
(add-hook 'LaTeX-mode-hook 'outline-minor-mode)
;;}}} outline minor mode {end}--------------------
;;{{{ cygwin-shell {begin}--------------------
;; disable these two -- they slow down the start up so much, and I don't know the use of them
;;; Add Cygwin Info pages
(setq Info-default-directory-list (append Info-default-directory-list (list "c:/cygwin/usr/info/")))
(setq ediff-shell shell-file-name) ; Ediff shell
(add-hook 'comint-output-filter-functions
'shell-strip-ctrl-m nil t)
(add-hook 'comint-output-filter-functions
'comint-watch-for-password-prompt nil t)
;; to use the bash shell provided by cygwin
(setq explicit-shell-file-name "C:/cygwin/bin/bash.exe")
;; to use the windows system shell
;; (setq explicit-shell-file-name "cmdproxy.exe")
;; For subprocesses invoked via the shell
;; (e.g., "shell -c command")
(setq shell-file-name explicit-shell-file-name)
;; set environmental variables specific for this Emacs emulation of bash.exe (this shell will not load /etc/profile properly)
;; but this emulation will read ~/.bashrc
;; if use \ to separate path, must use \\ to escape \
;; or use / to separate path
(setenv "SHELL" shell-file-name)
(setenv "PATH" (concat (getenv "PATH") "C:\\cygwin\\bin;C:\\cygwin\\usr\\X11R6\\bin;C:\\cygwin\\usr\\sbin;C:\\cygwin\\usr\\local\\bin;"))
(setenv "PATH" (concat "C:\\cygwin\\bin;C:\\cygwin\\usr\\X11R6\\bin;C:\\cygwin\\usr\\sbin;C:\\cygwin\\usr\\local\\bin;" (getenv "PATH")))
;; (setenv "PS1" "\[\e[31;1m\][\w]\[\e[0m\]")
;;; Shell mode
(setq ansi-color-names-vector ; better contrast colors
["black" "red4" "green4" "yellow4"
"blue3" "magenta4" "cyan4" "white"])
(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
;;}}} cygwin-shell {end}--------------------
;;{{{ default emacs windows size {begin}--------------------
(setq default-frame-alist
'((top . 0) (left . 0)
(width . 164) (height . 52)))
;; (set-frame-height (selected-frame) 54) ; # of lines
;; (set-frame-width (selected-frame) 164); # of columns
;; (set-frame-position (selected-frame) 0 0) ; upper left corner is (0,0)
;; set up the X resource Geometry for MS-Windows
;; registry, HKEY_LOCAL_MACHINE\SOFTWARE\GNU\Emacs
;; Emacs.Geometry:83x59 (3:4) 124x59 (4:3, resolution: 1280x1024)
;; CF:
;; http://www.gnu.org/savannah-checkouts/gnu/emacs/manual/html_node/emacs/Table-of-Resources.html#Table-of-Resources
;; http://xwinman.org/resource.php
;;}}} default emacs windows size {end}--------------------
;;{{{ Emacs Server {begin}--------------------
(server-force-delete)
(server-start)
;;}}} Emacs Server {end}--------------------
;;{{{ line number setting {begin}--------------------
;; for adding line numbers to the beginning of each line
;; better than setnu.el
(require 'linum)
(defun toggle-linum-mode () ; define function
"Toggle the linum-mode"
(interactive)
(if linum-mode
(linum-mode -1)
(linum-mode 1)))
;; use f1 as the key sequency for toggle line number on/off
(global-set-key [f1] 'toggle-linum-mode)
;;}}} line number setting {end}--------------------
;;{{{ buffer modes {begin}--------------------
;; ibuffer
(require 'ibuffer)
(global-set-key (kbd "C-x C-b") 'ibuffer) ; ibuffer.el, to lable, sort, hide, search, replace through buffers
(defun ibuffer-ediff-marked-buffers ()
(interactive)
(let* ((marked-buffers (ibuffer-get-marked-buffers))
(len (length marked-buffers)))
(unless (= 2 len)
(error (format "%s buffer%s been marked (needs to be 2)"
len (if (= len 1) " has" "s have"))))
(ediff-buffers (car marked-buffers) (cadr marked-buffers))))
(define-key ibuffer-mode-map "e" 'ibuffer-ediff-marked-buffers)
;; use /-R in ibuffer mode to enable the filtered view of buffers
(setq ibuffer-saved-filter-groups
(quote (("default"
("dir" (or
(mode . dired-mode)
(mode . shell-mode)))
("org" (or
(name . "^\\*Calendar\\*$")
(name . "^diary$")
(mode . org-mode)
(mode . org-agenda-mode)))
("muse" (or
(mode . muse-mode)
(name . "^\\.muse$")))
("webpage" (or
(mode . html-mode)
(mode . xml-mode)
(mode . css-mode)
(name . "^\\.html$")
(name . "^\\.htm$")
(name . "^\\.xml$")
(name . "^\\.tmpl$")
(name . "^\\.css$")))
("lisp" (or
(mode . emacs-lisp-mode)
(name . "^\\.el$")
(name . "^\\.elc$")))
("latex" (or
(mode . TeX-latex-mode)
(mode . TeX-tex-mode)
(mode . latex-mode)
(mode . bibtex-mode)
(name . "^\\.tex$")
(name . "^\\.bib$")
(name . "^\\.bbl$")
(name . "^\\.aux$")
(name . "^\\.log$")
(name . "^\\.blg$")))
("matlab" (or
(mode . matlab-mode)
(name . "^\\.m$")))
("c++" (or
(mode . c++-mode)
(mode . c-mode)
(mode . makefile-mode)
(name . "makefile")
(name . "^\\.cpp$")
(name . "^\\.c$")
(name . "^\\.h$")
(name . "^\\.hpp$")
(name . "^\\.dra$")
(name . "^\\.par$")))
("doc" (or
(mode . Info-mode)
(mode . apropos-mode)
(mode . woman-mode)
(mode . help-mode)
(mode . Man-mode)))
))))
;; Note: the name of the group is case sensitive, so "default" != "DEFAULT"
(add-hook 'ibuffer-mode-hook
(lambda ()
(ibuffer-switch-to-saved-filter-groups "default")))
(setq ibuffer-saved-filters
(quote (("dir"
((or
(mode . dired-mode)
(mode . shell-mode))))
("org"
((or
(name . "^\\*Calendar\\*$")
(name . "^diary$")
(mode . org-mode)
(mode . org-agenda-mode))))
("muse"
((or
(mode . muse-mode)
(name . "^\\.muse$"))))
("webpage"
((or
(mode . html-mode)
(mode . xml-mode)
(mode . css-mode)
(name . "^\\.html$")
(name . "^\\.htm$")
(name . "^\\.xml$")
(name . "^\\.tmpl$")
(name . "^\\.css$"))))
("lisp"
((or
(mode . emacs-lisp-mode)
(name . "^\\.el$")
(name . "^\\.elc$"))))
("tex"
((or
(mode . TeX-latex-mode)
(mode . TeX-tex-mode)
(mode . latex-mode)
(mode . bibtex-mode)
(name . "^\\.tex$")
(name . "^\\.bib$")
(name . "^\\.bbl$")
(name . "^\\.dra$")
(name . "^\\.par$")
(name . "^\\.aux$")
(name . "^\\.log$")
(name . "^\\.blg$"))))
("matlab"
((or
(mode . matlab-mode)
(name . "^\\*M-Lint\\*$")
(name . "^\\.m$"))))
("c++"
((or
(mode . c++-mode)
(mode . c-mode)
(mode . makefile-mode)
(name . "makefile")
(name . "^\\.cpp$")
(name . "^\\.c$")
(name . "^\\.h$")
(name . "^\\.hpp$")
(name . "^\\.dra$")
(name . "^\\.par$"))))
("Image"
((or
(mode . image-mode)
(name . "^\\.jpg$")
(name . "^\\.png$")
(name . "^\\.tif$")
(name . "^\\.tiff$"))))
("doc"
((or
(mode . Info-mode)
(mode . apropos-mode)
(mode . woman-mode)
(mode . help-mode)
(mode . Man-mode)))))))
;; column width of ibuffer
;; Use human readable Size column instead of original one
(define-ibuffer-column size-h
(:name "Size" :inline t)
(cond
((> (buffer-size) 1000) (format "%7.3fk" (/ (buffer-size) 1000.0)))
((> (buffer-size) 1000000) (format "%7.3fM" (/ (buffer-size) 1000000.0)))
(t (format "%8d" (buffer-size)))))
;; Modify the default ibuffer-formats
(setq ibuffer-formats
'((mark modified read-only " "
(name 40 40 :left)
" "
(size-h 9 -1 :right)
" "
(mode 16 16 :left :elide)
" "
filename-and-process)))
;; swbuff
;; (require 'swbuff)
;; (global-set-key (kbd "<C-prior>") 'swbuff-switch-to-previous-buffer)
;; (global-set-key (kbd "<C-next>") 'swbuff-switch-to-next-buffer)
;; (setq swbuff-exclude-buffer-regexps
;; '("^ .*" "^\\*.*\\*")) ;; from swbuff.el
;; ;;'("^ " "\\*.*\\*")) ;; Wang Yin's original setting
;; (setq swbuff-status-window-layout 'scroll)
;; (setq swbuff-clear-delay 0.1)
;; (setq swbuff-separator "|")
;; (setq swbuff-window-min-text-height 1)
;; tabbar
;; (require 'tabbar-acquamacs)
(require 'tabbar)
(tabbar-mode 1)
(global-set-key (kbd "C-S-p") 'tabbar-backward-group)
(global-set-key (kbd "C-S-n") 'tabbar-forward-group)
(global-set-key (kbd "C-S-b") 'tabbar-backward)
(global-set-key (kbd "C-S-f") 'tabbar-forward) ; tabbar.el, put all the buffers on the tabs.
(global-set-key (kbd "C-<") 'tabbar-backward)
(global-set-key (kbd "C->") 'tabbar-forward) ; tabbar.el, put all the buffers on the tabs.
(setq tabbar-background-color "gray80")
(setq tabbar-cycle-scope (quote tabs))
(setq tabbar-separator (quote (1)))
(setq table-time-before-update 0.1)
(setq tabbar-use-images nil)
;;}}} buffer modes {end}--------------------
;;{{{ browse-kill-ring {begin}--------------------
(require 'browse-kill-ring)
(global-set-key (kbd "C-c k") 'browse-kill-ring)
(browse-kill-ring-default-keybindings) ; browse-kill-ring.el, to use a buffer to
; let you select what you want to yank
;;}}} browse-kill-ring {end}--------------------
;;{{{ ido {begin}--------------------
;; ido.el, easist way to switch among buffers and to search files
;; (require 'ido)
;; (ido-mode t)
;; use the following "(add-hook 'term-setup-hook 'ido-mode)" instead of
(require 'ido)
(ido-mode t)
;; as a work around of a bug in this version of the emacs
;; 23-cvs-081124: recursive load tramp
;; (add-hook 'term-setup-hook 'ido-mode)
;; ignore what buffer, file, directory in ido minibuffer
(setq ido-ignore-buffers
'("\\` " "^\\*ESS\\*" "^\\*Messages\\*" "^\\*Help\\*" "^\\*Buffer"
"^\\*.*Completions\\*$" "^\\*Ediff" "^\\*tramp" "^\\*cvs-"
"_region_" " output\\*$" "^TAGS$" "^\*Ido" "^\\*WoMan-log\\*"))
(setq ido-ignore-directories
'("\\`auto/" "\\.prv/" "\\`CVS/" "\\`\\.\\./" "\\`\\./"))
(setq ido-ignore-files
'("\\.asv/" "\\`auto/" "\\.prv/" "_region_" "\\`CVS/" "\\`#" "\\`.#" "\\`\\.\\./" "\\`\\./"))
;; flex-matching: ido will match files containing the characters which have been
;; entered anywhere so long as they are in the correct sequence.
(setq ido-enable-flex-matching t)
;; whether a new buffer is created if no buffer matches substring. Choices are
;; 'always to create new buffers unconditionally, 'prompt to ask user whether to
;; create buffer, or 'never to never create new buffer.
(setq ido-create-new-buffer 'always)
;; ido auto merge
(setq ido-auto-merge-delay-time 5) ; wait for 5 seconds before doing auto merge.
;; the following are keybindings of ido, but I just didn't enable them because someday I want to bind these
;; keys by myself
(add-hook 'ido-define-mode-map-hook 'ido-my-keys)
(defun ido-my-keys ()
"Set up the keymap for `ido'."
;; common keys
(define-key ido-mode-map "\C-e" 'ido-edit-input)
(define-key ido-mode-map "\t" 'ido-complete) ;; complete partial, using TAB
(define-key ido-mode-map "\C-j" 'ido-select-text)
(define-key ido-mode-map "\C-m" 'ido-exit-minibuffer)
(define-key ido-mode-map "?" 'ido-completion-help) ;; list completions
(define-key ido-mode-map [(control ? )] 'ido-restrict-to-matches)
(define-key ido-mode-map [(control ?@)] 'ido-restrict-to-matches)
;; cycle through matches
(define-key ido-mode-map "\C-r" 'ido-prev-match)
(define-key ido-mode-map "\C-s" 'ido-next-match)
(define-key ido-mode-map [right] 'ido-next-match)
(define-key ido-mode-map [left] 'ido-prev-match)
;; toggles
(define-key ido-mode-map "\C-t" 'ido-toggle-regexp) ;; same as in isearch
(define-key ido-mode-map "\C-p" 'ido-toggle-prefix)
(define-key ido-mode-map "\C-c" 'ido-toggle-case)
(define-key ido-mode-map "\C-a" 'ido-toggle-ignore)
;; keys used in file and dir environment
(when (memq ido-cur-item '(file dir))
(define-key ido-mode-map "\C-b" 'ido-enter-switch-buffer)
(define-key ido-mode-map "\C-d" 'ido-enter-dired)
(define-key ido-mode-map "\C-f" 'ido-fallback-command)
;; cycle among directories
;; use [left] and [right] for matching files
(define-key ido-mode-map [down] 'ido-next-match-dir)
(define-key ido-mode-map [up] 'ido-prev-match-dir)
;; backspace functions
(define-key ido-mode-map [backspace] 'ido-delete-backward-updir)
(define-key ido-mode-map "\d" 'ido-delete-backward-updir);; use of backspace
(define-key ido-mode-map [(meta backspace)] 'ido-delete-backward-word-updir)
(define-key ido-mode-map [(control backspace)] 'backward-kill-word)
;; I can't understand this
(define-key ido-mode-map [(meta ?d)] 'ido-wide-find-dir)
(define-key ido-mode-map [(meta ?f)] 'ido-wide-find-file)
(define-key ido-mode-map [(meta ?k)] 'ido-forget-work-directory)
(define-key ido-mode-map [(meta ?m)] 'ido-make-directory)
(define-key ido-mode-map [(meta down)] 'ido-next-work-directory)
(define-key ido-mode-map [(meta up)] 'ido-prev-work-directory)
(define-key ido-mode-map [(meta left)] 'ido-prev-work-file)
(define-key ido-mode-map [(meta right)] 'ido-next-work-file)
;; search in the directories
;; use C-_ to undo this
(define-key ido-mode-map [(meta ?s)] 'ido-merge-work-directories)
(define-key ido-mode-map [(control ?\/)] 'ido-undo-merge-work-directory)
)
(when (eq ido-cur-item 'file)
(define-key ido-mode-map "\C-k" 'ido-delete-file-at-head)
(define-key ido-mode-map "\C-l" 'ido-toggle-literal)
(define-key ido-mode-map "\C-o" 'ido-copy-current-word)
(define-key ido-mode-map "\C-v" 'ido-toggle-vc)
(define-key ido-mode-map "\C-w" 'ido-copy-current-file-name)
)
(when (eq ido-cur-item 'buffer)
(define-key ido-mode-map "\C-b" 'ido-fallback-command)
(define-key ido-mode-map "\C-f" 'ido-enter-find-file)
(define-key ido-mode-map "\C-k" 'ido-kill-buffer-at-head)
))
;;}}} ido {end}--------------------
;;{{{ auto save of the time of last change {begin}--------------------
;; set up the time stamp so that the time and date of last change can be saved
;; according to the following webpage: http://zhdotemacs.sourceforge.net/emacs/timestamp.html
(add-hook 'write-file-hooks 'time-stamp)
(setq time-stamp-format "%:u %02m/%02d/%04y %02H:%02M:%02S") ; format: username mm/dd/yy hh/mm/ss
;;}}} auto save of the time of last change {end}--------------------
;;{{{ set up rect mark for selected region {begin}--------------------
;; according to rect-mark.el
;; press Shift and drag mouse to highlight a region
;; Support for marking a rectangle of text with highlighting.
(require 'rect-mark)
;; Use this section in your "~/.emacs" when rect-mark isn't included
;; as an integral part of Emacs. Don't forget to remove the first
;; three columns.
;; ;; Support for marking a rectangle of text with highlighting.
(define-key ctl-x-map "r\C-@" 'rm-set-mark)
(define-key ctl-x-map [?r ?\C-\ ] 'rm-set-mark)
;; bind C-x r C-x to rm-exchange-point-and-mark===> working great with C-x C-x:
;; exchange-point-and-mark
(define-key ctl-x-map "r\C-x" 'rm-exchange-point-and-mark)
(define-key ctl-x-map "r\C-w" 'rm-kill-region)
(define-key ctl-x-map "r\M-w" 'rm-kill-ring-save)
(define-key global-map [S-down-mouse-1] 'rm-mouse-drag-region)
(autoload 'rm-set-mark "rect-mark"
"Set mark for rectangle." t)
(autoload 'rm-exchange-point-and-mark "rect-mark"
"Exchange point and mark for rectangle." t)
(autoload 'rm-kill-region "rect-mark"
"Kill a rectangular region and save it in the kill ring." t)
(autoload 'rm-kill-ring-save "rect-mark"
"Copy a rectangular region to the kill ring." t)
(autoload 'rm-mouse-drag-region "rect-mark"
"Drag out a rectangular region with the mouse." t)
;; ;; Use this section in your "~/.emacs" to modify picture mode so that
;; ;; it automatically uses the rect-mark equivalents of many commands.
;; ;; ;; One vision of a better picture mode.
(add-hook 'picture-mode-hook 'rm-example-picture-mode-bindings)
(autoload 'rm-example-picture-mode-bindings "rect-mark"
"Example rect-mark key and mouse bindings for picture mode.")
;;}}} set up rect mark for selected region {end}--------------------
;;{{{ set up auto pair parentheses {begin}--------------------
;;right after you input left bracket or parenthesis, emacs automatically pair
;;the right one for your, including:(), "", [] , {}, etc.
(defun my-general-mode-auto-pair ()
"Auto pair the matching parentheses."
(interactive)
(make-local-variable 'skeleton-pair-alist)
(setq skeleton-pair-alist '(
(?' _ "'")
(?\" _ "\"")
(?\( _ ")")
(?\[ _ "]")
(?{ \n > _ \n ?} >)))
(setq skeleton-pair t)
(local-set-key (kbd "(") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "{") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "'") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "\"") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "[") 'skeleton-pair-insert-maybe))
(add-hook 'java-mode-hook 'my-general-mode-auto-pair)
(add-hook 'perl-mode-hook 'my-general-mode-auto-pair)
(add-hook 'php-mode-hook 'my-general-mode-auto-pair)
(add-hook 'BibTeX-mode 'my-general-mode-auto-pair)
(defun my-c-mode-auto-pair ()
"Auto pair the matching parentheses specialized for C/C++ programming."
(interactive)
(make-local-variable 'skeleton-pair-alist)
(setq skeleton-pair-alist '(
(?' _ "'")
(?\" _ "\"")
(?\( _ ")")
(?\[ _ "]")))
(setq skeleton-pair t)
(local-set-key (kbd "(") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "'") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "\"") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "[") 'skeleton-pair-insert-maybe))
(add-hook 'c-mode-hook 'my-general-mode-auto-pair)
(add-hook 'c++-mode-hook 'my-general-mode-auto-pair)
;; define my version of paratheses pair strategy for matlab mode
(defun my-matlab-mode-auto-pair ()
"Auto pair the matching parentheses specialized for Matlab programming."
(interactive)
(make-local-variable 'skeleton-pair-alist)
(setq skeleton-pair-alist '(
(?' _ "'")
(?\( _ ")")
(?\[ _ "]")
(?\{ _ "}")))
(setq skeleton-pair t)
(local-set-key (kbd "(") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "{") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "'") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "[") 'skeleton-pair-insert-maybe))
(add-hook 'matlab-mode-hook 'my-matlab-mode-auto-pair)
(add-hook 'sh-mode-hook 'my-matlab-mode-auto-pair)
;; define my version of paratheses pair strategy for all AucTeX modes
(defun my-TeX-mode-auto-pair ()
"Auto pair the matching parentheses specialized for TeX/LaTeX."
(interactive)
(make-local-variable 'skeleton-pair-alist)
;; version 1: (),{},[],$$
(setq skeleton-pair-alist '(
(?\( _ ")")
(?\[ _ "]")
(?\{ _ "}")
(?\$ _ "$")))
;; version 2: ( ),{ },[ ],$ $----->not used
;; (setq skeleton-pair-alist '(
;; (?\( ? _ " )")
;; (?\[ ? _ " ]")
;; (?\{ ? _ " }")
;; (?\$ ? _ " $")))
(setq skeleton-pair t)
(local-set-key (kbd "(") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "{") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "`") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "[") 'skeleton-pair-insert-maybe)
(local-set-key (kbd "$") 'skeleton-pair-insert-maybe))
(add-hook 'TeX-mode-hook 'my-TeX-mode-auto-pair)
;; (add-hook 'LaTeX-mode-hook 'my-TeX-mode-auto-pair)
(add-hook 'emacs-lisp-mode-hook 'my-TeX-mode-auto-pair)
(add-hook 'org-mode-hook 'my-TeX-mode-auto-pair)
(add-hook 'bibtex-mode-hook 'my-TeX-mode-auto-pair)
;;}}} set up auto pair parentheses {end}--------------------
;;{{{ color theme {begin}--------------------
;; enable the color-theme package
(require 'color-theme) ; load the color-theme package
;; Call function da-color-theme to change to the dark face, and call C-u da-color-theme for the yellow background face.
(require 'switch-color-theme-matlab-latex)
(global-set-key [f6] 'da-color-theme)
(da-color-theme) ; select my own color theme as default
(require 'zenburn)
;;}}} color theme {end}--------------------
;;{{{ file header {begin}--------------------
;; use M-x make-header to auto write fire header for my source codes
(require 'header2)
;; Do this in your ~/.emacs:according to the header2.el
;; User options (variables) defined here:
;;
;; `header-copyright-notice', `header-history-label', `header-max',
;; `make-header-hook'
;;
;; Other variables defined here:
;;
;; `file-header-update-alist', `header-prefix-string', `return-to'
(setq header-copyright-notice "Da Zhang MGH Radiology\n")
(setq header-modification-author "Da Zhang\n")
(setq make-header-hook '( header-file-name
header-author
header-copyright
header-usage
header-compile
header-system
header-bugs
header-creation-date
header-modification-date
header-update-count
header-description
header-mode-line
header-code
header-eof
))
(make-local-variable 'user-full-name)
(make-local-variable 'user-mail-address)
;; Update file headers when write files.
(add-hook 'write-file-hooks 'update-file-header)
;; Create headers for file buffers in my favorite modes.
(add-hook 'emacs-lisp-mode-hook 'auto-make-header)
(add-hook 'c-mode-common-hook 'auto-make-header)
(add-hook 'c++-mode-hook 'auto-make-header)
(add-hook 'java-mode-hook 'auto-make-header)
(add-hook 'perl-mode-hook 'auto-make-header)
(defun my-matlab-mode-auto-make-header ()
"Auto make header for matlab code."
(interactive)
(make-local-variable 'make-header-hook)
(setq make-header-hook '( header-file-name
header-author
header-copyright
header-usage
header-compile
header-system
header-bugs
header-creation-date
header-modification-date
header-update-count
header-description
header-mode-line
header-matlab-code-begin
header-matlab-code-end
)))
(add-hook 'matlab-mode-hook 'my-matlab-mode-auto-make-header)
(defun my-org-mode-auto-make-header ()
"Auto make header for matlab code."
(interactive)
(make-local-variable 'make-header-hook)
(setq make-header-hook '( header-org-mode
)))
(add-hook 'org-mode-hook 'my-org-mode-auto-make-header)
(defun my-perl-mode-auto-make-header ()
"Auto make header for matlab code."
(interactive)
(make-local-variable 'make-header-hook)
(setq make-header-hook '(header-perl-header-begin
header-file-name
header-author
header-creation-date
header-modification-date
header-update-count
header-description
header-mode-line
header-perl-code-begin
)))
(add-hook 'perl-mode-hook 'my-perl-mode-auto-make-header)
;;}}} file header {end}--------------------
;;{{{ redo {begin}--------------------
(require 'redo)
(global-set-key (kbd "C-?") 'redo)
;;}}} redo {end}--------------------
;;{{{ scroll without cursor moving {begin}--------------------
;; scroll functions
(defun hold-line-scroll-up()
"Scroll the page with the cursor in the same line"
(interactive)
(let ((next-screen-context-lines
(count-lines
(window-start) (window-end)
)
))
(scroll-up)
))
(defun hold-line-scroll-down()
"Scroll the page with the cursor in the same line"
(interactive)
(let ((next-screen-context-lines
(count-lines
(window-start) (window-end)
)
))
(scroll-down)
))
;; while scroll up/down by holding Ctrl and mouse wheel up/down, the cursor doesn't move within the current
;; window, and scroll line by line.
(global-set-key (kbd "<C-wheel-up>") 'hold-line-scroll-up)
(global-set-key (kbd "<C-wheel-down>") 'hold-line-scroll-down)
;;}}} scroll without cursor moving {end}--------------------
;;{{{ shell toggle {begin}--------------------
(autoload 'shell-toggle "da-shell-toggle"
"Toggles between the *shell* buffer and whatever buffer you are editing."
t)
(autoload 'shell-toggle-cd "da-shell-toggle"
"Pops up a shell-buffer and insert a \"cd <file-dir>\" command." t)
(global-set-key (kbd "C-M-'") 'shell-toggle-cd)
(global-set-key (kbd "C-'") 'shell-toggle)
(global-set-key (kbd "C-M-!") 'shell-command)
(defun open-buffer-path ()
"Run explorer on the directory of the current buffer."
(interactive)
(shell-command
(concat "explorer " (replace-regexp-in-string "/" "\\\\"
(if (eq major-mode 'dired-mode)
dired-directory
(file-name-directory (buffer-file-name))) t t))))
;; (defun run-shell-at-buffer-path ()
;; "Run explorer on the directory of the current buffer."
;; (interactive)
;; (shell-command
;; (concat "bash " " -c " (concat "'cd " (replace-regexp-in-string "/" "\\\\"
;; (if (eq major-mode 'dired-mode)
;; dired-directory
;; (file-name-directory (buffer-file-name))) t t) "'" ))
;;}}} shell toggle {end}--------------------
;;{{{ dired mode {begin}--------------------
;; enable dired to visit subfolders in the current buffer by typing "a"
(put 'dired-find-alternate-file 'disabled nil)
;; dired+ mode
(require 'dired+)
(require 'dired-details)
;; use ( or ) to toggle the details shown in dired
(require 'dired-details+)
;; find-dired
(require 'find-dired)
(setq find-ls-option '("-print0 | xargs -0 ls -ld" . "-ld"))
;; Hack dired to launch files mouse clicking
;; and Ret to open the dir into the same buffer
(require 'w32-browser)
;; open the father path using M-<up>
(add-hook 'dired-mode-hook (lambda ()
(interactive)
(define-key dired-mode-map (kbd "<M-up>")
'dired-up-directory)
(define-key dired-mode-map
"c" 'diredp-copy-this-file)
;; (define-key dired-mode-map
;; [M-f8] 'dired-w32-browser) ;; open in window associated application
(define-key dired-mode-map
(kbd "<C-M-return>") 'dired-w32-browser) ;; open in window associated application
(define-key dired-mode-map
"\r" 'dired-find-alternate-file)))
;; we want dired not not make always a new buffer if visiting a directory
;; but using only one dired buffer for all directories.
(defadvice dired-advertised-find-file (around dired-subst-directory activate)
"Replace current buffer if file is a directory."
(interactive)
(let ((orig (current-buffer))
(filename (dired-get-filename)))
ad-do-it
(when (and (file-directory-p filename)
(not (eq (current-buffer) orig)))
(kill-buffer orig))))
(eval-after-load "dired"
;; don't remove `other-window', the caller expects it to be there
'(defun dired-up-directory (&optional other-window)
"Run Dired on parent directory of current directory."
(interactive "P")
(let* ((dir (dired-current-directory))
(orig (current-buffer))
(up (file-name-directory (directory-file-name dir))))
(or (dired-goto-file (directory-file-name dir))
;; Only try dired-goto-subdir if buffer has more than one dir.
(and (cdr dired-subdir-alist)
(dired-goto-subdir up))
(progn
(kill-buffer orig)
(dired up)
(dired-goto-file dir))))))
;; enable dired to recursively copy and delete files and directories
(setq dired-recursive-copies 'top)
(setq dired-recursive-deletes 'top)
;; sorting functionality in dired
;; ss sort according to file size
;; sx sort according to file extention
;; st sort according to access time
;; sn sort according to file name
(add-hook 'dired-mode-hook (lambda ()
(interactive)
(make-local-variable 'dired-sort-map)
(setq dired-sort-map (make-sparse-keymap))
(define-key dired-mode-map "s" dired-sort-map)
(define-key dired-sort-map "s"
'(lambda () "sort by Size"
(interactive) (dired-sort-other (concat dired-listing-switches "S"))))
(define-key dired-sort-map "x"
'(lambda () "sort by eXtension"
(interactive) (dired-sort-other (concat dired-listing-switches "X"))))
(define-key dired-sort-map "t"
'(lambda () "sort by Time"
(interactive) (dired-sort-other (concat dired-listing-switches "t"))))
(define-key dired-sort-map "n"
'(lambda () "sort by Name"
(interactive) (dired-sort-other (concat dired-listing-switches ""))))))
;; put folder at the top of the list
(defun dired-sort-dir-first ()
"Dired sort hook to list directories first."
(save-excursion
(let (buffer-read-only)
(forward-line 2) ;; beyond dir. header
(sort-regexp-fields t "^.*$" "[ ]*." (point) (point-max))))
(and (featurep 'xemacs)
(fboundp 'dired-insert-set-properties)
(dired-insert-set-properties (point-min) (point-max)))
(set-buffer-modified-p nil))
(add-hook 'dired-after-readin-hook 'dired-sort-dir-first)
;; use C-x C-j to open the containing folder of the current file
;; C-x C-j open the directory of current buffer
(global-set-key (kbd "C-x C-j") 'open-dir-current-file)
(defun open-dir-current-file()
(interactive)
(if (buffer-file-name)
(dired default-directory)))
;; omit certain file extensions that I don't want to see
;; use M-o to toggle omitting these files
(setq dired-omit-extensions '("CVS/" "~"
".a" ".aux"
".bin" ".lbin" ".blg"
".class" ".cp" ".cps"
".fasl" ".fas" ".fmt"
".ufsl" ".ln" ".fn" ".fns"
".glo"
".idx"
".ky" ".kys"
".la" ".lof" ".lot"
".o"
".pgs" ".pg"
".sparcf"
".tfm" ".toc" ".tp" ".tps"
".vr" ".vrs"
".x86f"))
;;}}} dired mode {end}--------------------
;;{{{ bm Bookmarks {begin}--------------------
;; Make sure the repository is loaded as early as possible
(setq bm-restore-repository-on-load t)
(require 'bm)
;; M$ Visual Studio key setup.
(global-set-key [(f2)] 'bm-toggle)
(global-set-key [(control f2)] 'bm-previous)
(global-set-key [(shift f2)] 'bm-next)
(global-set-key [(meta f2)] 'bm-show-all)
(global-set-key [(control shift f2)] 'bm-remove-all-current-buffer)
(global-set-key [(f3)] 'bm-next)
(global-set-key [(control f3)] 'bm-previous)
;; Click on fringe to toggle bookmarks, and use mouse wheel to move
;; between them.
(setq bm-marker 'bm-marker-left)
(setq bm-highlight-style 'bm-highlight-line-and-fringe)
;; (global-set-key (kbd "<left-fringe> <mouse-5>") 'bm-next-mouse)
;; (global-set-key (kbd "<left-fringe> <mouse-4>") 'bm-previous-mouse)
;; (global-set-key (kbd "<left-fringe> <mouse-1>") 'bm-toggle-mouse)
;; make bookmarks persistent as default
(setq bm-repository-file "c:/home/zhangda/bm-repository")
(setq-default bm-buffer-persistence t)
;; Update bookmark repository when saving the file.
(add-hook 'after-save-hook 'bm-buffer-save)
;; Restore bookmarks when buffer is reverted.
(add-hook 'after-revert-hook 'bm-buffer-restore)
;; Loading the repository from file when on start up.
(add-hook' after-init-hook 'bm-repository-load)
;; Restoring bookmarks when on file find.
(add-hook 'find-file-hooks 'bm-buffer-restore)
;; Saving bookmark data on killing a buffer
(add-hook 'kill-buffer-hook 'bm-buffer-save)
;; Saving the repository to file when on exit.
;; kill-buffer-hook is not called when Emacs is killed, so we
;; must save all bookmarks first.
(add-hook 'kill-emacs-hook '(lambda nil
(bm-buffer-save-all)
(bm-repository-save)))
;; make sure bookmarks is saved before check-in (and revert-buffer)
(add-hook 'vc-before-checkin-hook 'bm-buffer-save)
;;}}} bm Bookmarks {end}--------------------
;;{{{ word-count {begin}--------------------
;;; Final version: while
(defun word-count (beginning end)
"Print number of words in the region."
(interactive "r")
(message "Counting words in region ... ")
;;; 1. Set up appropriate conditions.
(save-excursion
(let ((count 0))
(goto-char beginning)
;;; 2. Run the while loop.
(while (and (< (point) end)
(re-search-forward "\\w+\\W*" end t))
(setq count (1+ count)))
;;; 3. Send a message to the user.
(cond ((zerop count)
(message
"The region does NOT have any words."))
((= 1 count)
(message
"The region has 1 word."))
(t
(message
"The region has %d words." count))))))
;;}}} word-count {end}--------------------
;;{{{ unicad {begin}--------------------
;; Unicad helps Emacs to guess the correct coding system when opening a file.
;; It's designed to work automatically and quietly without user interaction.
(require 'unicad)
;;}}} unicad {end}--------------------
;;{{{ pager {begin}--------------------
;; make the scroll up and scroll down act as in other softwares
;; pager.el stuff
(require 'pager)
(global-set-key "\C-v" 'pager-page-down)
(global-set-key [next] 'pager-page-down)
(global-set-key "\M-v" 'pager-page-up)
(global-set-key [prior] 'pager-page-up)
(global-set-key '[M-up] 'pager-row-up)
(global-set-key '[M-down] 'pager-row-down)
;;}}} pager {end}--------------------
;;{{{ unfill {begin}--------------------
;;; Stefan Monnier <foo at acm.org>. It is the opposite of
;;; fill-paragraph Takes a multi-line paragraph and makes it into a
;;; single line of text.
(defun unfill-paragraph ()
"Reverse the effect of fill-paragraph: make a paragraph into a single line."
(interactive)
(let ((fill-column 46488))
(fill-paragraph nil)))
(defun unfill-region ()
"Do the opposite of fill-region; stuff all paragraphs in the current region into long lines."
(interactive)
(let ((fill-column 46488))
(fill-region (point) (mark))))
(global-unset-key (kbd "C-M-q"))
(global-set-key (kbd "C-M-q") 'unfill-paragraph)
;;}}} unfill {end}--------------------
;;{{{ move up/down by multiple lines {begin}--------------------
;; Faster point movement
(global-set-key (kbd "C-M-p")
'(lambda () (interactive) (previous-line 15)))
(global-set-key (kbd "C-M-n")
'(lambda () (interactive) (next-line 15)))
;;}}} move up/down by multiple lines {end}--------------------
;;{{{ anything {begin}--------------------
(require 'anything-config)
(setq anything-map
(let ((map (copy-keymap minibuffer-local-map)))
(define-key map (kbd "<down>") 'anything-next-line)
(define-key map (kbd "<up>") 'anything-previous-line)
(define-key map (kbd "C-n") 'anything-next-line)
(define-key map (kbd "C-p") 'anything-previous-line)
(define-key map (kbd "<prior>") 'anything-previous-page)
(define-key map (kbd "<next>") 'anything-next-page)
(define-key map (kbd "<right>") 'anything-next-source)
(define-key map (kbd "<left>") 'anything-previous-source)
(define-key map (kbd "<RET>") 'anything-exit-minibuffer)
(define-key map (kbd "C-1") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-2") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-3") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-4") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-5") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-6") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-7") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-8") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-9") 'anything-select-with-digit-shortcut)
(define-key map (kbd "C-i") 'anything-select-action)
map))
(global-set-key [C-f10]
(lambda() (interactive)
(anything
:prompt "Switch to: "
:candidate-number-limit 10 ;; up to 10 of each
:sources
'( anything-c-source-buffers ;; buffers
anything-c-source-recentf ;; recent files
anything-c-source-bookmarks ;; bookmarks
anything-c-source-files-in-current-dir+)))) ;; current dir
;; anything-c-source-locate))) ;; use 'locate'
;;}}} anything {end}--------------------
;;{{{ flyspell {begin}--------------------
;;; Use Aspell for spell checking
(add-hook 'text-mode-hook 'flyspell-mode)
(setq-default ispell-program-name "C:/Emacs/aspell/bin/aspell.exe")
(setq-default ispell-extra-args '("--sug-mode=ultra"))
;;}}} flyspell {end}--------------------
;;{{{ Tramp mode {begin}--------------------
(setq tramp-default-method "sshx")
;; (setq tramp-default-method "plink")
;; (setq tramp-verbose 10)
;; (setq tramp-debug-buffer t)
;;}}} Tramp mode {end}--------------------
;;{{{ Auto Complete {begin}--------------------
(global-set-key (kbd "<apps>") 'hippie-expand)
(global-set-key (kbd "<C-tab>") 'hippie-expand)
;; hippie-expand
(setq hippie-expand-try-functions-list
'(senator-try-expand-semantic
try-expand-dabbrev
try-expand-dabbrev-visible
try-expand-dabbrev-all-buffers
try-expand-dabbrev-from-kill
try-expand-all-abbrevs
try-expand-list
try-expand-list-all-buffers
try-expand-line
try-expand-line-all-buffers
try-complete-file-name-partially
try-complete-file-name
try-complete-lisp-symbol-partially
try-complete-lisp-symbol
try-expand-whole-kill))
;; key bindings for specific modes
;; Auctex mode
(add-hook 'LaTeX-mode-hook
'(lambda ()
(define-key LaTeX-mode-map (kbd "<C-tab>")
'TeX-complete-symbol)))
;; Matlab mode
(add-hook 'matlab-mode-hook
'(lambda ()
(define-key matlab-mode-map (kbd "<C-tab>")
'matlab-complete-symbol)))
;; Emacs-Lisp mode
(add-hook 'emacs-lisp-mode-hook
'(lambda ()
(define-key emacs-lisp-mode-map (kbd "<C-tab>")
'lisp-complete-symbol)))
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "c:/Emacs/site-lisp/ac-dict")
(ac-config-default)
;;}}} Auto Complete {end}--------------------
;;{{{ Desktop and recentf {begin}--------------------
;; recentf stuff
(require 'recentf)
(recentf-mode t)
(setq recentf-max-menu-items 25)
(global-set-key "\C-x\ \C-r" 'recentf-open-files)
;;Note: for the outline-minor-mode-prefix to be successfully set to C-o,
;;this desktop setting must be placed after the settings of the outline
;;mode, especially the (setq outline-minor-mode-prefix "C-o")
(setq desktop-path (quote ("C:/home/zhangda/emacs-desktop-dir/")))
(setq desktop-dirname "C:/home/zhangda/emacs-desktop-dir")
(setq desktop-load-locked-desktop t)
(setq desktop-save-mode t)
(setq history-length 250)
(desktop-read) ; enable desktop function, which save all the buffers opened
; before exiting
;;}}} Desktop and recentf {end}--------------------
;;{{{ Info customize {begin}--------------------
(define-key Info-mode-map (kbd "M-n") 'forward-paragraph)
;;}}} Info customize {end}--------------------
;;{{{ my customized keybindings {begin}--------------------
;; global set key bindings for function keys
;; (global-set-key [f1] 'toggle-linum-mode)
;; (global-set-key [(f2)] 'bm-toggle)
;; (global-set-key [(control f2)] 'bm-previous)
;; (global-set-key [(shift f2)] 'bm-next)
;; (global-set-key [(meta f2)] 'bm-show-all)
;; (global-set-key [(control shift f2)] 'bm-remove-all-current-buffer)
;; (global-set-key [(f3)] 'bm-next)
;; (global-set-key [(control f3)] 'bm-previous)
(global-set-key [f4] 'repeat-complex-command)
(global-set-key [C-f4] 'call-last-kbd-macro)
(global-set-key [M-f4] 'ido-kill-buffer)
;; (define-key muse-mode-map [f5] 'muse-project-publish-this-file)
;; (global-set-key [f6] 'da-color-theme)
(global-set-key [C-f6] 'compile)
(global-set-key [f7] 'next-error)
(global-set-key [C-f7] 'previous-error)
(global-set-key [f8] 'da-revert-buffer)
(global-set-key [f9] 'dired)
(global-set-key [C-f9] 'speedbar-get-focus)
(global-set-key [M-f9] 'open-buffer-path)
(global-set-key [f10] 'anything)
;; (global-set-key [C-f10]
;; (lambda() (interactive)
;; (anything
;; :prompt "Switch to: "
;; :candidate-number-limit 10 ;; up to 10 of each
;; :sources
;; '( anything-c-source-buffers ;; buffers
;; anything-c-source-recentf ;; recent files
;; anything-c-source-bookmarks ;; bookmarks
;; anything-c-source-files-in-current-dir+)))) ;; current dir
;; ;; anything-c-source-locate))) ;; use 'locate'
(global-set-key [f11] 'query-replace-regexp)
;; (global-set-key [f12] 'remember)
;; (global-set-key [C-f12] 'gtd)
;; (global-set-key [M-f12] 'weblogger-start-entry)
;; comment/uncomment out region
(global-set-key (kbd "C-c ;") 'comment-region)
(global-set-key (kbd "C-c :") 'uncomment-region)
;; for my convinence, set M-n and M-p as follows
(global-set-key (kbd "M-n") 'forward-paragraph)
(global-set-key (kbd "M-p") 'backward-paragraph)
;; keybinding for backward C-k
(global-set-key ( kbd "C-S-k")
'(lambda () (interactive) (kill-line 0)))
(global-unset-key (kbd "C-z"))
(global-set-key (kbd "C-z") 'undo)
(global-set-key (kbd "C-S-z") 'redo)
;; enable the undo-tree mode: C-x u will open the undo-tree buffer for visualization
(require 'undo-tree)
(global-undo-tree-mode)
;; go to the matching parenthesis or square bracket
(defun da-match-paren (arg)
"Go to the matching paren if on a paren."
(interactive "p")
(cond ((and mark-active (looking-at "\\s\(")) (forward-list 1))
((and mark-active (looking-back "\\s\)")) (backward-list 1))
((looking-at "\\s\(") (forward-list 1) (backward-char 1))
((looking-at "\\s\)") (forward-char 1) (backward-list 1))
))
(global-set-key (kbd "M-[") 'da-match-paren)
(defun combine-lines (&optional arg)
(interactive "P")
(let ((rexp "\\(?:\\s-\\|\n\\)"))
(progn
(while (looking-back rexp)
(delete-backward-char 1))
(while (looking-at rexp)
(delete-char 1))
(unless arg
(insert " ")))))
(global-set-key (kbd "M-]") 'combine-lines)
;; set up for temporary mark in files
(global-set-key (kbd "M-.") 'ska-point-to-register)
(global-set-key (kbd "M-,") 'ska-jump-to-register)
;; (global-set-key [(control \.)] 'ska-point-to-register)
;; (global-set-key [(control \,)] 'ska-jump-to-register)
(defun ska-point-to-register()
"Store cursor position _fast_ in a register.
Use ska-jump-to-register to jump back to the stored
position."
(interactive)
(message "Point to register")
(setq zmacs-region-stays t)
(point-to-register 8))
(defun ska-jump-to-register()
"Switches between current cursor position and position
that was stored with ska-point-to-register."
(interactive)
(message "Jump to register")
(setq zmacs-region-stays t)
(let ((tmp (point-marker)))
(jump-to-register 8)
(set-register 8 tmp)))
;; go-to-char
(global-set-key (kbd "C-c C-a") 'wy-go-to-char)
(defun wy-go-to-char (n char)
"Move forward to Nth occurence of CHAR.
Typing `wy-go-to-char-key' again will move forwad to the next Nth
occurence of CHAR."
(interactive "p\ncGo to char: ")
(search-forward (string char) nil nil n)
(while (char-equal (read-char) char)
(search-forward (string char) nil nil n))
(setq unread-command-events (list last-input-event)))
;; ;; hide region
;; (require 'hide-region)
;; (global-set-key (kbd "C-c r") 'hide-region-hide)
;; (global-set-key (kbd "C-c R") 'hide-region-unhide)
;; hide lines
(autoload 'hide-lines "hide-lines" "Hide lines based on a regexp" t)
(global-set-key (kbd "C-c M-l") 'hide-lines)
(global-set-key (kbd "C-c M-L") 'show-all-invisible)
;; word search
(global-set-key (kbd "M-s") 'word-search-forward)
(global-unset-key (kbd "M-r"))
(global-set-key (kbd "M-r") 'word-search-backward)
;; go to other window
(global-set-key [backtab] 'other-window)
;; global set key bindings for goto line
(global-set-key (kbd "M-g") 'goto-line)
;; global set key bindings for M-Spcace for set mark
(global-set-key (kbd "M-<SPC>") 'set-mark-command)
;; zoom in and out for emacs (text size adjust)
(global-set-key (kbd "<C-kp-add>") 'text-scale-increase)
(global-set-key (kbd "<C-kp-subtract>") 'text-scale-decrease)
(global-set-key (kbd "C-x C-f") 'ido-find-file)
(define-key org-mode-map (kbd "C-c [") 'reftex-citation)
;; (setq w32-enable-caps-lock nil)
;; (global-set-key [capslock] 'execute-extended-command)
;;}}} my customized keybindings {end}--------------------
;;{{{ web blogger {begin}--------------------
;; (load-file "weblogger.el")
;; (require 'weblogger)
;; (add-hook 'weblogger-entry-mode-hook
;; (lambda ()
;; (auto-fill-mode nil)))
;; (global-set-key [M-f12] 'weblogger-start-entry)
;; (autoload 'markdown-mode "markdown-mode.el"
;; "Major mode for editing Markdown files" t)
;; (setq auto-mode-alist
;; (cons '("\\.text" . markdown-mode) auto-mode-alist))
;; org2blog mode
(require 'org2blog-autoloads)
(setq org2blog/wp-blog-alist
'(("wordpress"
:url "http://zhangda.wordpress.com/xmlrpc.php"
:username "zhangda"
:tags-as-categories nil)))
(global-set-key [C-M-f12] 'org2blog/wp-new-entry)
;;}}} web blogger {end}--------------------
;;{{{ Visual Basic {begin}--------------------
;; autoload visual-basic-mode
(autoload 'visual-basic-mode "visual-basic-mode" "Visual Basic mode." t)
(add-to-list 'auto-mode-alist '("\\.vbs\\'" . visual-basic-mode)) ;VBscript
(add-to-list 'auto-mode-alist '("\\.vb\\'" . visual-basic-mode)) ;visual basic .NET file
(add-to-list 'auto-mode-alist '("\\.bas\\'" . visual-basic-mode)) ;visual basic form
(add-to-list 'auto-mode-alist '("\\.frm\\'" . visual-basic-mode)) ;basic language source
;; (add-to-list 'auto-mode-alist '("\\.cls\\'" . visual-basic-mode)) ;C++ class definition file
(setq-default visual-basic-mode-indent 4)
;;}}} Visual Basic {end}--------------------
;;{{{ Emacs ppt {begin}--------------------
(defun org-mode-reftex-setup ()
(load-library "reftex")
(and (buffer-file-name)
(file-exists-p (buffer-file-name))
(reftex-parse-all))
(define-key org-mode-map (kbd "C-c [") 'reftex-citation)
)
(add-hook 'org-mode-hook 'org-mode-reftex-setup)
;; for ditaa support in org mode
(require 'org-exp-blocks)
;; ditaa: java package to convert text graphics to png files, very good for flow charts
(setq ditaa-cmd "java -jar C:/downloads/software/ditaa/ditaa0_6b.jar")
(defun draw (saveas)
(interactive "FSave As: ")
(shell-command
(concat ditaa-cmd " \"" buffer-file-name "\"" " " "\"" saveas "\""))) ;; use \" to pass "" for the path name
;; org mode && beamer integration
;; allow for export=>beamer by placing
;; #+LaTeX_CLASS: beamer in org files
(unless (boundp 'org-export-latex-classes)
(setq org-export-latex-classes nil))
(add-to-list 'org-export-latex-classes
'("beamer"
"\\documentclass[red]{beamer}\n
\\usetheme{Darmstadt}\n
\\usefonttheme[onlylarge]{structurebold}\n
\\setbeamerfont*{frametitle}{size=\\normalsize,series=\\bfseries}\n
\\setbeamertemplate{navigation symbols}{}\n
\\usepackage[english]{babel}\n
\\usepackage{times}\n
\\usepackage[T1]{fontenc}\n
\\usepackage{graphicx}\n
\\usepackage{color}\n
\\usepackage{tikz}\n
\\usetikzlibrary{arrows}\n
\\tikzstyle{block}=[draw opacity=0.7,line width=1.4cm]\n
\\usepackage{listings}
\\lstset{numbers=none,language=[ISO]C++,tabsize=4,
frame=single,
basicstyle=\\small,
showspaces=false,showstringspaces=false,
showtabs=false,
keywordstyle=\\color{blue}\\bfseries,
commentstyle=\\color{red},
}\n
\\institute{Mass General Imaging}\n"
("\\section{%s}" . "\\section*{%s}")
("\\begin{frame}[fragile]\\frametitle{%s}"
"\\end{frame}"
"\\begin{frame}[fragile]\\frametitle{%s}"
"\\end{frame}")))
(add-to-list 'org-export-latex-classes
'("article"
"\\documentclass [letterpaper, 11pt]{article}\n
\\usepackage{fullpage}\n
\\usepackage{setspace}\n
\\doublespacing\n
\\usepackage{amssymb}\n
\\usepackage{graphicx}\n
\\usepackage{subfigure}\n
\\usepackage{float}\n
\\usepackage{amsmath}\n
\\usepackage{cite}\n
\\usepackage{times}\n
\\usepackage[pdfpagemode = colorlinks, pdffitwindow = true, bookmarks = true, pdftoolbar = false, pdfmenubar = true, pdfnewwindow = true]{hyperref}\n
\\usepackage[left]{lineno}\n"
("\\section{%s}" . "\\section*{%s}")))
(add-to-list 'org-export-latex-classes
'("compact"
"\\documentclass [letterpaper, 10pt]{article}\n
\\usepackage{fullpage}\n
\\usepackage{setspace}\n
\\singlespacing\n
\\usepackage{times}\n
\\usepackage[compact]{titlesec}\n
\\titlespacing{\\section}{0pt}{*0}{*0}\n
\\titlespacing{\\subsection}{0pt}{*0}{*0}\n
\\titlespacing{\\subsubsection}{0pt}{*0}{*0}\n
\\usepackage{mdwlist}\n
\\usepackage[left=2cm,top=1cm,right=2cm,nohead,nofoot]{geometry}\n"
("\\section{%s}" . "\\section*{%s}")))
(add-to-list 'org-export-latex-classes
'("MP"
"\\documentclass [aip, numerical, linenumbers, preprint, prb, groupedaddress]{revtex4-1}\n
\\usepackage{graphicx}\n
\\usepackage{float}\n
\\usepackage{subfigure}\n
\\usepackage{amssymb}\n
\\usepackage{amsmath}\n"
("\\section{%s}" . "\\section*{%s}")))
;;}}} Emacs ppt {end}--------------------
;;{{{ Org to S5 {begin}--------------------
(load-file "C:/Emacs/site-lisp/org-export-as-s5.el")
(setq org-s5-theme "railscast") ; based off `color-theme-railscasts'
(setq org-s5-theme "default") ; the default S5 theme
(setq org-s5-theme "i18n") ; the i18n theme by the author of S5
;;}}} Org to S5 {end}--------------------
;;{{{ Ediff {begin}--------------------
;; Diff the current buffer with the file contents
(global-set-key (kbd "C-c w") 'diff-buffer-with-file)
;;}}} Ediff {end}--------------------
;;{{{ CUA {begin}--------------------
;; only use the rectangular functionality of CUA mode
(setq cua-enable-cua-keys nil) ;; only for rectangles
(cua-mode t)
;; (global-set-key (kbd "<C-M-return>") 'cua-set-rectangle-mark)
;;}}} CUA {end}--------------------
;;{{{ Comment line {begin}--------------------
(defun comment-line ()
"comment line at point."
(interactive)
(beginning-of-line)
(let
((beg (point)))
(end-of-line)
(comment-region beg (point))))
(global-set-key (kbd "C-M-;") 'comment-line)
;;}}} comment line {end}--------------------
;;{{{ windmove {begin}--------------------
;; Windmove is a package that allows you to move point from window to window
;; using Shift and the arrow keys. This is easier to type than C-x o and, for
;; some users, may be more intuitive
(when (fboundp 'windmove-default-keybindings)
(windmove-default-keybindings))
;;}}} windmove {end}--------------------
;;{{{ sml modeline {begin}--------------------
(if (require 'sml-modeline nil 'noerror) ;; use sml-modeline if available
(progn
(sml-mode t) ;; show buffer pos in the mode line
;; (scroll-bar-mode -1)
) ;; turn off the scrollbar
(scroll-bar-mode 1) ;; otherwise, show a scrollbar...
(set-scroll-bar-mode 'right)) ;; ... on the right
;;}}} sml modeline {end}--------------------
;;{{{ format bib {begin}--------------------
(require 'fbib)
;;}}} format bib {end}--------------------
;;{{{ C++ Programming {begin}--------------------
;; C++ coding style definition
;; (defconst *my-cc-style*
;; '((c-basic-offset . 4)
;; (c-comment-only-line-offset 0 . 0)
;; (c-comment-only-line-offset . 0)
;; (c-hanging-braces-alist . ((brace-list-open)
;; (brace-entry-open)
;; (block-close . c-snug-do-while)
;; (arglist-cont-nonempty)
;; (substatement-open before after)))
;; (c-cleanup-list . (brace-else-brace))
;; (c-offsets-alist . ((statement-block-intro . +)
;; (knr-argdecl-intro . 0)
;; (label . 0)
;; (statement-case-open . +)
;; (statement-cont . +)
;; (substatement-open . 0)
;; (substatement-label . 0)
;; (arglist-intro . c-lineup-arglist-intro-after-paren)
;; (arglist-close . c-lineup-arglist)
;; (inline-open . 0)
;; (innamespace . 0)
;; (case-label . +)
;; (brace-list-open . +)
;; (topmost-intro-cont first c-lineup-topmost-intro-cont c-lineup-gnu-DEFUN-intro-cont)
;; (statement-cont . +)))
;; (c-special-indent-hook . c-gnu-impose-minimum)
;; (c-block-comment-prefix . "")))
(defun my-c-initialization-hook ()
(define-key c-mode-base-map "\C-m" 'c-context-line-break)
(define-key c-mode-base-map (kbd "RET") 'reindent-then-newline-and-indent))
(add-hook 'c-initialization-hook 'my-c-initialization-hook)
;; (setq c-offsets-alist '((member-init-intro . ++)))
;; (c-add-style "PERSONAL" *my-cc-style*)
(defun my-c-mode-common-hook ()
(c-set-style "stroustrup") ;;PERSONAL
(setq tab-width 4
indent-tabs-mode nil
c-hungry-delete-key t)
(c-toggle-auto-newline 1)
(linum-mode 1))
(add-hook 'c-mode-common-hook 'my-c-mode-common-hook)
(add-hook 'c++-mode-common-hook 'my-c-mode-common-hook)
;;}}} C++ Programming {end}--------------------
;;{{{ rainbow mode {begin}--------------------
;; for colorful display of color names when setting up emacs colors
(require 'rainbow-mode)
;;}}} rainbow mode {end}--------------------
;;{{{ folding {begin}--------------------
;; folding: hide/show marked region from viewing. Key bindings are prefixed with
;; "C-c@" instead of old "C-c". To use the old keyboard bindings, uncomment the
;; following lines: (setq folding-default-keys-function
;; 'folding-bind-backward-compatible-keys)
(if (load "folding" 'nomessage 'noerror)
(folding-mode-add-find-file-hook))
;; whether to fold buffer when starting the Folding mode
(setq folding-folding-on-startup t)
(setq folding-narrow-by-default t)
(if (load "folding" 'nomessage 'noerror)
(folding-mode-add-find-file-hook))
;; (global-set-key (kbd "C-c @ C-e") 'folding-show-current-entry)
(global-set-key (kbd "C-c f") 'folding-toggle-show-hide)
;;}}} folding {end}--------------------
;;{{{ cedet 1.0 {begin}--------------------
;; Load CEDET.
;; See cedet/common/cedet.info for configuration details.
(load-file "C:/Emacs/site-lisp/cedet/common/cedet.el")
;; Enable EDE (Project Management) features
(global-ede-mode 1)
;; Enable EDE for a pre-existing C++ project
;; (ede-cpp-root-project "NAME" :file "~/myproject/Makefile")
;; Enabling Semantic (code-parsing, smart completion) features
;; Select one of the following:
;; * This enables the database and idle reparse engines
(semantic-load-enable-minimum-features)
;; * This enables some tools useful for coding, such as summary mode
;; imenu support, and the semantic navigator
(semantic-load-enable-code-helpers)
;; * This enables even more coding tools such as intellisense mode
;; decoration mode, and stickyfunc mode (plus regular code helpers)
;; (semantic-load-enable-gaudy-code-helpers)
;; * This enables the use of Exuberent ctags if you have it installed.
;; If you use C++ templates or boost, you should NOT enable it.
;; (semantic-load-enable-all-exuberent-ctags-support)
;; Or, use one of these two types of support.
;; Add support for new languges only via ctags.
;; (semantic-load-enable-primary-exuberent-ctags-support)
;; Add support for using ctags as a backup parser.
;; (semantic-load-enable-secondary-exuberent-ctags-support)
;; Enable SRecode (Template management) minor-mode.
;; (global-srecode-minor-mode 1)
;; To use additional features for names completion, and displaying of information for tags & classes
(require 'semantic-ia)
;; C/C++, semantic automatically load /usr/include as index database
(setq semanticdb-search-system-databases t)
;; Semantic can automatically find path, where system include files are located when gcc is used
(require 'semantic-gcc)
;; add the following gcc include libraries to the semantic system include list
(eval-after-load "semantic-c"
'(dolist (d (list "C:/cygwin/lib/gcc/i686-pc-cygwin/3.4.4/include"
"C:/cygwin/lib/gcc/i686-pc-cygwin/3.4.4/include/c++"
"C:/cygwin/lib/gcc/i686-pc-cygwin/3.4.4/include/i686-pc-cygwin"
"C:/cygwin/lib/gcc/i686-pc-cygwin/3.4.4/include/c++/backward"
"C:/cygwin/lib/gcc/i686-pc-cygwin/3.4.4/include/c++/bits"
"C:/cygwin/lib/gcc/i686-pc-cygwin/3.4.4/include/c++/debug"
"C:/cygwin/lib/gcc/i686-pc-cygwin/3.4.4/include/c++/ext"
"C:/cygwin/lib/gcc/i686-pc-cygwin/3.4.4/include/c++/i686-pc-cygwin/bits"
"C:/cygwin/usr/local/include"
"C:/cygwin/usr/include/w32api"
))
(semantic-add-system-include d)))
;; set up cedet
(autoload 'speedbar-frame-mode "speedbar" "Popup a speedbar frame" t)
(autoload 'speedbar-get-focus "speedbar" "Jump to speedbar frame" t)
(define-key-after (lookup-key global-map [menu-bar tools])
[speedbar]
'("Speedbar" .
speedbar-frame-mode)
[calendar])
;; set up the default path for semantic to store its analysis results
(setq semanticdb-default-save-directory
(expand-file-name "~/.emacs.d/semanticdb"))
;; prevent semantic use too much of CPU time
(setq-default semantic-idle-scheduler-idle-time 432000)
;; key bindings for auto completion
(defun my-cedet-hook ()
(local-set-key [(meta return)] 'semantic-ia-complete-symbol)
(local-set-key "\C-c?" 'semantic-ia-complete-symbol-menu)
(local-set-key "\C-c>" 'semantic-complete-analyze-inline)
(local-set-key "\C-cp" 'semantic-analyze-proto-impl-toggle)
(local-set-key "." 'semantic-complete-self-insert)
(local-set-key ">" 'semantic-complete-self-insert))
(add-hook 'c-mode-common-hook 'my-cedet-hook)
;; project root path
(setq semanticdb-project-roots
(list
(expand-file-name "/")))
(autoload 'senator-try-expand-semantic "senator")
;; speedbar key binding, n and p for "next" and "previous" movement, + and - as
;; show or hide directory, g for refresh
;; speed bar settings
(setq speedbar-show-unknown-files t) ; display all directories and files
;; (setq dframe-update-speed nil) ; don't use automatic refresh of speed bar, press g instead
;; (setq speedbar-update-flag nil)
;; (setq speedbar-use-images nil) ; don't use image
(setq speedbar-verbosity-level 0)
;; (require 'wisent)
;;}}} cedet 1.0 {end}--------------------
;;{{{ matlab-emacs {begin}--------------------
(add-to-list 'load-path "c:/Emacs/site-lisp/matlab-emacs/")
(require 'matlab-load)
;; Enable CEDET feature support for MATLAB code. (Optional)
(matlab-cedet-setup)
(setq-default matlab-highlight-cross-function-variables t)
(add-hook 'matlab-mode-hook
'(lambda ()
(define-key matlab-mode-map "\M-;" 'comment-dwim)
(linum-mode 1)))
;; some settings for the matlab-mode
(setq matlab-auto-fill nil)
(setq matlab-comment-anti-indent 0)
(setq matlab-indent-level 4)
(setq matlab-comment-column default-fill-column)
(setq matlab-comment-line-s "% ")
(setq matlab-comment-on-line-s " % ")
(setq matlab-comment-region-s "% ")
(setq matlab-completion-technique (quote increment))
(setq matlab-fill-fudge 5)
(setq matlab-fill-fudge-hard-maximum 100)
(setq matlab-fill-strings-flag nil)
(setq matlab-functions-have-end nil)
(setq matlab-highlight-cross-function-variables t)
(setq matlab-highlight-block-match-flag t)
(setq matlab-return-add-semicolon nil)
;; (setq-default matlab-show-mlint-warnings t)
;; (setq mlint-programs (quote ("mlint" "win32/mlint" "C:\\MATLAB2008a\\bin\\win32\\mlint.exe")))
(setq matlab-fill-code t)
;; turn off auto-verify on save
(setq matlab-verify-on-save-flag nil)
;; if you want function bodies indented
(setq-default matlab-indent-function nil)
(setq-default matlab-indent-function-body nil)
;;}}} old matlab emacs integration {end}--------------------
;;{{{ regexp helper {begin}--------------------
(require 're-builder)
(setq reb-re-syntax 'string)
;;}}} regexp helper {end}--------------------
;;{{{ auto byte-compile if .elc exist {begin}--------------------
(defun auto-byte-recompile ()
"If the current buffer is in emacs-lisp-mode and there already exists an `.elc'
file corresponding to the current buffer file, then recompile the file."
(interactive)
(when (and (eq major-mode 'emacs-lisp-mode)
(file-exists-p (byte-compile-dest-file buffer-file-name)))
(byte-compile-file buffer-file-name)))
(add-hook 'after-save-hook 'auto-byte-recompile)
;; ignore byte-compile warnings
(setq byte-compile-warnings '(not nresolved
free-vars
callargs
redefine
obsolete
noruntime
cl-functions
interactive-only
))
;;}}} auto byte-compile if .elc exist {end}--------------------
;;{{{ rainbow matching delimiters {begin}--------------------
(when (require 'rainbow-delimiters nil 'noerror)
(add-hook 'scheme-mode-hook 'rainbow-delimiters-mode)
(add-hook 'emacs-lisp-mode-hook 'rainbow-delimiters-mode)
(add-hook 'c-mode-hook 'rainbow-delimiters-mode)
)
;;}}} rainbow matching delimiters {end}--------------------
;;{{{ browser and google search {begin}--------------------
;;point to the appropriate browser
(setq browse-url-firefox-program "C:/Program Files/Mozilla Firefox/firefox.exe")
(setq browse-url-browser-function 'browse-url-firefox
browse-url-new-window-flag nil
browse-url-firefox-new-window-is-tab nil)
(defun region-or-word (prompt)
"Read a string from the minibuffer, prompting with PROMPT.
If `transient-mark-mode' is non-nil and the mark is active,
it defaults to the current region, else to the word at or before
point. This function returns a list (string) for use in `interactive'."
(list (read-string prompt (or (and transient-mark-mode mark-active
(buffer-substring-no-properties
(region-beginning) (region-end)))
(current-word)))))
(defun google (string)
"Ask a WWW browser to google string.
Prompts for a string, defaulting to the active region or the current word at
or before point."
(interactive (region-or-word "Google: "))
(browse-url (concat "http://google.com/search?num=100&q=" string)))
;;}}} browser and google search {end}--------------------
;;{{{ CUSTOM {begin}--------------------
;; these are setups come from the interactive customization tool CUSTOM:
;; Options-->Customize Emacs-->Browse Customization Groups-->...actually I don't
;; remember.
(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.
'(TeX-electric-escape nil)
'(TeX-electric-sub-and-superscript t)
'(TeX-insert-braces t)
'(TeX-newline-function (quote reindent-then-newline-and-indent))
'(TeX-output-view-style (quote (("^dvi$" "^pstricks$\\|^pst-\\|^psfrag$" "dvips %d -o && start \"\" %f") ("^dvi$" "." "yap -1 %dS %d") ("^pdf$" "." "pdfviewm \"\" %f") ("^html?$" "." "start \"\" %o"))))
'(TeX-source-specials-places (quote ("cr" "display" "hbox" "math" "par" "parend" "vbox")))
'(ediff-diff-options "--binary -w")
'(focus-follows-mouse t)
'(ido-create-new-buffer (quote never))
'(ido-enable-flex-matching t)
'(ido-enable-last-directory-history nil)
'(ido-enable-regexp nil)
'(ido-max-directory-size 300000)
'(ido-max-file-prompt-width 0.1)
'(ido-use-filename-at-point nil)
'(ido-use-url-at-point t)
'(ido-use-virtual-buffers t)
'(ispell-choices-win-default-height 3)
'(muse-file-extension "muse")
'(muse-html-charset-default "utf-8")
'(muse-html-encoding-default (quote utf-8))
'(muse-html-meta-content-encoding (quote utf-8))
'(muse-ignored-extensions (quote ("bz2" "gz" "[Zz]" "rej" "orig" "png" "hgignore" "gif" "css" "jpg" "html" "sh" "lftp" "pdf")))
'(muse-mode-auto-p nil)
'(muse-wiki-allow-nonexistent-wikiword nil)
'(muse-wiki-use-wikiword nil)
'(org-agenda-files (quote ("c:/H/GTD/this_week.org")))
'(org-export-latex-tables-column-borders nil)
'(org-modules (quote (org-bbdb org-bibtex org-gnus org-info org-jsinfo org-irc org-mew org-mhe org-rmail org-vm org-wl org-w3m org-exp-blocks)))
'(org-tags-column -110)
'(overflow-newline-into-fringe nil)
'(preview-auto-cache-preamble t)
'(preview-gs-command "gs")
'(preview-image-type (quote pnm))
'(preview-preserve-counters t)
'(preview-transparent-border nil)
'(preview-transparent-color (quote (default :background)))
'(revert-without-query (quote (".*.m")))
'(uniquify-after-kill-buffer-p t)
'(uniquify-buffer-name-style (quote post-forward-angle-brackets) nil (uniquify))
'(uniquify-ignore-buffers-re "^\\*")
'(uniquify-separator "|")
'(w32shell-cygwin-bin "C:\\cygwin\\bin")
'(weblogger-config-alist (quote (("default" "http://zhangda.wordpress.com/xmlrpc.php" "zhangda" "" "7259137")))))
;; '(preview-gs-command "C:/Program Files/gs/gs8.64/bin/gswin32c.exe")
;; MS default font set as andale mono, 13 pt (height) these are setups come from
;; the interactive customization tool CUSTOM: Options-->Customize Emacs-->Browse
;; Customization Groups-->Faces-->Basic Faces-->Face Default-->height
(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 (:height 120 :width normal :foundry "outline" :family "Bitstream Vera Sans Mono"))))
'(matlab-cellbreak-face ((t (:foreground "YellowGreen" :weight bold))))
'(sml-end-face ((t (:inherit match :background "gray30" :foreground "DarkOrange" :weight bold))))
'(sml-vis-face ((t (:inherit region :weight bold :foreground "orange")))))
;;}}} CUSTOM {end}--------------------
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;temporarily disabled;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;{{{ old matlab emacs integration {begin}--------------------
;; ;; from Matlab 6.5
;; ;; Edit the path in the following line to reflect the
;; ;; actual location of the MATLAB root directory on your system.
;; ;; (add-to-list (add-to-list 'load-path "c:/Matlab6p5/java/extern/EmacsLink/lisp/"))
;; ;; (autoload 'matlab-eei-connect "matlab-eei"
;; ;; "Connects Emacs to MATLAB's external editor interface.")
;; ;; (autoload 'matlab-mode "matlab" "Enter Matlab mode." t)
;; ;; (setq auto-mode-alist (cons '("\\.m\\'" . matlab-mode) auto-mode-alist))
;; ;; (autoload 'matlab-shell "matlab" "Interactive Matlab mode." t)
;; ;; from Matlab 7 or later
;; ;; Edit the path in the following line to reflect the
;; ;; actual location of the MATLAB root directory on your system.
;; ;; (add-to-list 'load-path "C:/MATLAB2008a/java/extern/EmacsLink/lisp")
;; (autoload 'matlab-eei-connect "matlab-eei"
;; "Connects Emacs to MATLAB's external editor interface.")
;; (autoload 'matlab-mode "matlab" "Enter Matlab mode." t)
;; (add-to-list 'auto-mode-alist '("\\.m\\'" . matlab-mode))
;; (autoload 'matlab-shell "matlab" "Interactive Matlab mode." t)
;; ;; Uncomment the next four lines to enable use of the tlc mode
;; ;; (require 'tlc)
;; ;; (autoload 'tlc-mode "tlc" "tlc Editing Mode" t)
;; ;; (add-to-list 'auto-mode-alist '("\\.tlc$" . tlc-mode))
;; ;; (setq tlc-indent-function t)
;; ;; Uncomment the next two lines to enable use of the mlint package provided
;; ;; with EmacsLink.
;; (setq-default matlab-show-mlint-warnings t)
;; (setq-default matlab-highlight-cross-function-variables t)
;; ;; Note: The mlint package checks for common M-file coding
;; ;; errors, such as omitting semicolons at the end of lines.
;; ;; mlint requires Eric Ludlam's cedet package.
;; (add-hook 'matlab-mode-hook
;; '(lambda ()
;; (imenu-add-to-menubar "Find")
;; (define-key matlab-mode-map "\M-;" 'comment-dwim)
;; (linum-mode 1)))
;; ;; if you want function bodies indented
;; (setq-default matlab-indent-function nil)
;; (setq-default matlab-indent-function-body nil)
;; ;; turn off auto-verify on save
;; (setq matlab-verify-on-save-flag nil)
;; ;; some settings for the matlab-mode
;; (setq matlab-auto-fill nil)
;; (setq matlab-comment-anti-indent 0)
;; (setq matlab-comment-column default-fill-column)
;; (setq matlab-comment-line-s "% ")
;; (setq matlab-comment-on-line-s " %")
;; (setq matlab-comment-region-s "% ")
;; (setq matlab-completion-technique (quote increment))
;; (setq matlab-fill-fudge 5)
;; (setq matlab-fill-fudge-hard-maximum 100)
;; (setq matlab-fill-strings-flag nil)
;; (setq matlab-functions-have-end nil)
;; (setq matlab-highlight-cross-function-variables t)
;; (setq matlab-highlight-block-match-flag t)
;; (setq matlab-return-add-semicolon nil)
;; (setq mlint-programs (quote ("mlint" "win32/mlint" "C:\\MATLAB2008a\\bin\\win32\\mlint.exe")))
;; (setq matlab-fill-code t)
;; (defun my-matlab-mode-hook ()
;; (imenu-add-to-menubar "Find")) ; where auto-fill should wrap
;; (add-hook 'matlab-mode-hook 'my-matlab-mode-hook)
;; ;; mode specific key bindings: for matlab-mode, press F5 for save and go.
;; ;; (add-hook 'matlab-mode-hook
;; ;; '(lambda ()
;; ;; (define-key matlab-mode-map [f5] 'matlab-shell-save-and-go)
;; ;; (define-key matlab-mode-map [S-f5] 'matlab-eei-exit-debug)
;; ;; (define-key matlab-mode-map [f9] 'matlab-eei-go-until-cursor)
;; ;; (define-key matlab-mode-map [f10] 'matlab-eei-step)
;; ;; (define-key matlab-mode-map [S-f10] 'matlab-eei-continue)
;; ;; (define-key matlab-mode-map [f11] 'matlab-eei-step-in)
;; ;; (define-key matlab-mode-map [S-f11] 'matlab-eei-step-out)
;; ;; (define-key matlab-mode-map [f12] 'matlab-eei-breakpoint-set-clear)
;; ;; (define-key matlab-mode-map [S-f12] 'matlab-eei-clear-breakpoints)))
;;}}} old matlab emacs integration {end}--------------------
;;{{{ cscope {begin}--------------------
;; (require 'xcscope)
;; (global-set-key "\C-xg" 'cscope-find-global-definition-no-prompting)
;;}}} cscope {end}--------------------
;;{{{ Smart Tab {begin}--------------------
;; ;; Smart Tab
;; (defvar smart-tab-using-hippie-expand t
;; "turn this on if you want to use hippie-expand completion.")
;; ;; (global-set-key [(tab)] 'smart-tab)
;; (defun smart-tab (prefix)
;; "Needs `transient-mark-mode' to be on. This smart tab is
;; minibuffer compliant: it acts as usual in the minibuffer.
;; In all other buffers: if PREFIX is \\[universal-argument], calls
;; `smart-indent'. Else if point is at the end of a symbol,
;; expands it. Else calls `smart-indent'."
;; (interactive "P")
;; (if (minibufferp)
;; (minibuffer-complete)
;; (if (smart-tab-must-expand prefix)
;; (if smart-tab-using-hippie-expand
;; (hippie-expand nil)
;; (dabbrev-expand nil))
;; (smart-indent))))
;; (defun smart-indent ()
;; "Indents region if mark is active, or current line otherwise."
;; (interactive)
;; (if mark-active
;; (indent-region (region-beginning)
;; (region-end))
;; (indent-for-tab-command)))
;; (defun smart-tab-must-expand (&optional prefix)
;; "If PREFIX is \\[universal-argument], answers no.
;; Otherwise, analyses point position and answers."
;; (unless (or (consp prefix)
;; mark-active)
;; (looking-at "\\_>")))
;;}}} Smart Tab {end}--------------------
;;{{{ enable the auto indent so that emacs automatically indent {begin}--------------------
;; (global-set-key "\C-j" 'newline)
;; (global-set-key (kbd "RET") 'reindent-then-newline-and-indent)
;; ;; (global-set-key "\C-m" 'newline-and-indent)
;; ;; OR:
;; ;; (add-hook 'c-mode-common-hook
;; ;; (lambda ()
;; ;; (define-key c-mode-map
;; ;; "\C-m" 'reindent-then-newline-and-indent)))
;;}}} enable the auto indent so that emacs automatically indent {end}--------------------
;;{{{ use hideshow minor mode in programming modes {begin}--------------------
;; ;; add hook to the following major modes so that the hideshow minor mode starts automatically
;; (load-library "hideshow")
;; (add-hook 'c-mode-hook 'hs-minor-mode)
;; (add-hook 'c++-mode-hook 'hs-minor-mode)
;; (add-hook 'java-mode-hook 'hs-minor-mode)
;; (add-hook 'perl-mode-hook 'hs-minor-mode)
;; (add-hook 'php-mode-hook 'hs-minor-mode)
;; (add-hook 'emacs-lisp-mode-hook 'hs-minor-mode)
;; (add-hook 'matlab-mode-hook 'hs-minor-mode)
;; ;;(add-hook 'LaTeX-mode-hook 'hs-minor-mode) ;;==> I think hideshow is better for programs, probably
;; ;; set up some key bindings so that we can use
;; ;; C-c bh to hide a block
;; ;; C-c bs to show a block
;; ;; see the code below for more key bindings
;; ;; (global-set-key (kbd "C-c bh") 'hs-hide-block)
;; ;; (global-set-key (kbd "C-c bs") 'hs-show-block)
;; ;; (global-set-key (kbd "C-c as") 'hs-show-all)
;; ;; (global-set-key (kbd "C-c ah") 'hs-hide-all)
;; ;; (global-set-key (kbd "C-c th") 'hs-toggle-hiding)
;; ;; (global-set-key (kbd "C-c hl") 'hs-hide-level)
;;}}} use hideshow minor mode in programming modes {end}--------------------
;;{{{ predictive {begin}--------------------
;; ;; predictive install location
;; (add-to-list 'load-path "C:/Emacs/site-lisp/predictive")
;; ;; dictionary locations
;; (add-to-list 'load-path "C:/Emacs/site-lisp/predictive/latex/")
;; (add-to-list 'load-path "C:/Emacs/site-lisp/predictive/texinfo/")
;; (add-to-list 'load-path "C:/Emacs/site-lisp/predictive/html/")
;; ;; load predictive package
;; (autoload 'predictive-mode "C:/Emacs/site-lisp/predictive/predictive"
;; "Turn on Predictive Completion Mode." t)
;;}}} predictive {end}--------------------
;;{{{ ECB {begin}--------------------
;; (add-to-list 'load-path
;; "C:/Emacs/site-lisp/ecb-snap/")
;; (require 'ecb-autoloads)
;;}}} ECB {end}--------------------
;;{{{ occur related {begin}--------------------
;; ;; for occur command, listing lines matching a regexp in a buffer called "occur"
;; ;; Tired of having to decide whether to hit M-x occur, or whether SwitchingBuffers
;; ;; to the OccurBuffer Occur is more appropriate? Here is a defun to do either-or,
;; ;; inspired by MeatBall:HumaneInterface:
;; (defun my-occur ()
;; "Switch to *Occur* buffer, or run `occur'."
;; (interactive)
;; (if (get-buffer "*Occur*")
;; (switch-to-buffer "*Occur*")
;; (call-interactively 'occur)))
;; (global-set-key (kbd "C-c o") 'my-occur)
;; ;; This is a slightly different version - keeps the top window displaying the
;; ;; original buffer when typing 'C-c o' for the second time (that is, when
;; ;; both the Occur buffer and the original buffer are visible). The Occur buffer
;; ;; becomes active. Pressing RET (or mouse-2) on an item in the Occur buffer makes
;; ;; the original window active again and moves the point to the occurrence. Thus you
;; ;; can jump back and forth without the windows swapping.
;; ;; Also, once you're done with the Occur buffer (when you no longer need that
;; ;; list), and the original buffer is active, here's a key binding that allows you
;; ;; to kill the Occur buffer. If you only remove the window Occur, and not the
;; ;; buffer Occur (say, as happens with C-x 1), the next time you press
;; ;; 'C-c o', Emacs assumes you're looking for the same regexp (unless you've
;; ;; pressed 'z' in the Occur buffer).
;; (global-set-key (kbd "C-c C-o")
;; '(lambda ()
;; "Kill the *Occur* buffer"
;; (interactive)
;; (kill-buffer "*Occur*")
;; (delete-other-windows)))
;; (require 'color-moccur)
;; (require 'moccur-edit)
;;}}} occur related {end}--------------------
;;{{{ find function {begin}--------------------
;; (require 'find-func)
;; (defun find-function-setup-keys ()
;; "Define some key bindings for the find-function family of functions."
;; (define-key ctl-x-map "F" 'find-function)
;; (define-key ctl-x-4-map "F" 'find-function-other-window)
;; (define-key ctl-x-5-map "F" 'find-function-other-frame)
;; (define-key ctl-x-map "K" 'find-function-on-key)
;; (define-key ctl-x-map "V" 'find-variable)
;; (define-key ctl-x-4-map "V" 'find-variable-other-window)
;; (define-key ctl-x-5-map "V" 'find-variable-other-frame))
;; (find-function-setup-keys)
;;}}} find function {end}--------------------
;;{{{ save macro {begin}--------------------
;; (defun save-macro (name)
;; "save a macro. Take a name as argument
;; and save the last defined macro under
;; this name at the end of your .emacs"
;; (interactive "SName of the macro :") ; ask for the name of the macro
;; (kmacro-name-last-macro name) ; use this name for the macro
;; (find-file "C:/Emacs/site-lisp/my_lisp.el") ; open the .emacs file
;; (goto-char (point-max)) ; go to the end of the .emacs
;; (newline) ; insert a newline
;; (insert-kbd-macro name) ; copy the macro
;; (newline) ; insert a newline
;; (switch-to-buffer nil)) ; return to the initial buffer
;;}}} save macro {end}--------------------
;;{{{ duplicate line {begin}--------------------
;; (defun djcb-duplicate-line (&optional commentfirst)
;; "comment line at point; if COMMENTFIRST is non-nil, comment the original"
;; (interactive)
;; (beginning-of-line)
;; (let
;; ((beg (point)))
;; (end-of-line)
;; (let ((str (buffer-substring beg (point))))
;; (when commentfirst
;; (comment-region beg (point)))
;; (insert-string
;; (concat (if (= 0 (forward-line 1)) "" "\n") str "\n"))
;; (forward-line -1))))
;; ;; or choose some better bindings....
;; ;; duplicate a line
;; (global-set-key (kbd "C-c y") 'djcb-duplicate-line)
;; ;; duplicate a line and comment the first
;; (global-set-key (kbd "C-c c") (lambda()(interactive)(djcb-duplicate-line t)))
;;}}} duplicate line {end}--------------------
;;{{{ ESS mode {begin}--------------------
;; ;;; ESS
;; ;;;
;; ;; Load ESS and activate the nifty feature showing function arguments
;; ;; in the minibuffer until the call is closed with ')'.
;; (require 'ess-site)
;; (require 'ess-eldoc)
;; ;; Following the "source is real" philosophy put forward by ESS, one
;; ;; should not need the command history and should not save the
;; ;; workspace at the end of an R session. Hence, both options are
;; ;; disabled here.
;; (setq-default inferior-R-args "--no-restore-history --no-save ")
;; ;; Set code indentation following the standard in R sources.
;; (setq ess-default-style 'C++)
;; ;; Automagically delete trailing whitespace when saving R script
;; ;; files. One can add other commands in the ess-mode-hook below.
;; (add-hook 'ess-mode-hook
;; '(lambda()
;; (add-hook 'write-file-functions
;; (lambda ()
;; (ess-nuke-trailing-whitespace)))
;; (setq ess-nuke-trailing-whitespace-p t)))
;; ;; Path to R executable. Uncomment and edit as needed if R is
;; ;; installed in such an unusual place that ESS can't find it. (And
;; ;; then keep updating with each R update!)
;; ;(setq-default inferior-R-program-name
;; ; "c:/program files/r/r-2.7.1/bin/rterm.exe")
;; ;; Path to S-Plus GUI; needed only to use ESS with the S-Plus GUI.
;; ;(setq-default inferior-S+6-program-name
;; ; "c:/program files/insightful/splus7/cmd/splus.exe")
;; ;(custom-set-variables '(inferior-ess-start-args "-j"))
;; ;; Path to lightweight Sqpe.exe; needed only to use S-Plus in the
;; ;; Emacs window.
;; ;(setq-default inferior-Sqpe+6-program-name
;; ; "c:/program files/insightful/splus7/cmd/sqpe.exe")
;; ;(setq-default inferior-Sqpe+6-SHOME-name
;; ; "c:/program files/insightful/splus7/")
;;}}} ESS mode {end}---a-----------------
;; ;;{{{ w3m {begin}--------------------
;; (add-to-list 'load-path "c:/Emacs/site-lisp/w3m/")
;; ;; (add-to-list 'load-path "C:/Emacs/site-lisp/w3m")
;; (require 'w3m-load)
;; (add-hook 'w3m-mode-hook
;; (lambda ()
;; (define-key w3m-mode-map (kbd "C-x b") nil)
;; (define-key w3m-mode-map "C" 'w3m-print-this-url)
;; (define-key w3m-mode-map "A" 'w3m-bookmark-add-current-url)
;; (define-key w3m-mode-map "D" 'w3m-download-this-url)
;; (define-key w3m-mode-map "s" 'w3m-search)
;; (define-key w3m-mode-map "f" 'w3m-view-this-url-new-session)
;; (define-key w3m-mode-map "F" 'w3m-view-this-url)
;; (define-key w3m-mode-map "g" 'w3m-goto-url)
;; (define-key w3m-mode-map "G" 'w3m-goto-url-new-session)
;; (define-key w3m-mode-map "h" 'w3m-history)
;; (define-key w3m-mode-map "p" 'w3m-scroll-down-or-previous-url)
;; (define-key w3m-mode-map "n" 'w3m-scroll-up-or-next-url)
;; ;; I don't often w3m to edit pages, so I'm borrowing o and e (right
;; ;; below , / . for tab navigation) for page navigation instead.
;; (define-key w3m-mode-map "o" 'w3m-view-previous-page)
;; (define-key w3m-mode-map "e" 'w3m-view-next-page)
;; ;; i is a more useful mnemonic for toggling images
;; (define-key w3m-mode-map "i" 'w3m-toggle-inline-image)
;; (define-key w3m-mode-map "I" 'w3m-toggle-inline-images)
;; ;; and X for closing the buffer
;; (define-key w3m-mode-map "x" 'w3m-delete-buffer)
;; ;; and b for bookmarks
;; (define-key w3m-mode-map "b" 'w3m-bookmark-view)
;; (define-key w3m-mode-map (kbd "C-b") 'backward-char)
;; (define-key w3m-mode-map (kbd "C-p") 'previous-line)
;; (define-key w3m-mode-map (kbd "C-n") 'next-line)
;; (define-key w3m-mode-map (kbd "C-f") 'forward-char)
;; ;; Browse in new sessions by default
;; (define-key w3m-mode-map (kbd "RET") 'w3m-view-this-url)
;; (define-key w3m-mode-map [(shift return)] 'w3m-view-this-url-new-session)
;; ;; Use cursor keys to scroll
;; (define-key w3m-mode-map [(left)] 'backward-char)
;; (define-key w3m-mode-map [(right)] 'forward-char)
;; (define-key w3m-mode-map [(shift left)] 'w3m-shift-right)
;; (define-key w3m-mode-map [(shift right)] 'w3m-shift-left)
;; ;; Which means I can now use , and . to switch pages
;; (define-key w3m-mode-map "." 'w3m-next-buffer)
;; (define-key w3m-mode-map "," 'w3m-previous-buffer)
;; ))
;; (setq-default w3m-display-inline-images t)
;; ;;}}} w3m {end}--------------------
;; ;;{{{ dictionary {begin}--------------------
;; ;; Loading the package You have to insert some instructions into your .emacs
;; ;; file to load the dictionary package whenever needed. If you installed this
;; ;; dictionary package as Debian package or XEmacs package you don't need the
;; ;; autoloads, they are already supplied. Other users I suggest using the
;; ;; following lines:
;; (autoload 'dictionary-search "dictionary"
;; "Ask for a word and search it in all dictionaries" t)
;; (autoload 'dictionary-match-words "dictionary"
;; "Ask for a word and search all matching words in the dictionaries" t)
;; (autoload 'dictionary-lookup-definition "dictionary"
;; "Unconditionally lookup the word at point." t)
;; (autoload 'dictionary "dictionary"
;; "Create a new dictionary buffer" t)
;; (autoload 'dictionary-mouse-popup-matching-words "dictionary"
;; "Display entries matching the word at the cursor" t)
;; (autoload 'dictionary-popup-matching-words "dictionary"
;; "Display entries matching the word at the point" t)
;; (autoload 'dictionary-tooltip-mode "dictionary"
;; "Display tooltips for the current word" t)
;; (autoload 'global-dictionary-tooltip-mode "dictionary"
;; "Enable/disable dictionary-tooltip-mode for all buffers" t)
;; ;; In addition, some key bindings for faster access can be useful. I use
;; ;; the following ones in my installation:
;; ;; key bindings
;; (global-set-key "\C-cd" 'dictionary-lookup-definition)
;; (global-set-key "\C-cs" 'dictionary-search)
;; (global-set-key "\C-cm" 'dictionary-match-words)
;; ;; choose a dictionary server
;; (setq dictionary-server "dict.org")
;; ;; choose the dictionary: "wn" for WordNet
;; ;; "web1913" for Webster's Revised Unabridged Dictionary(1913)
;; ;; so on
;; (setq dictionary-default-dictionary "wn")
;; (setq dictionary-tooltip-dictionary "wn")
;; ;;}}} dictionary {end}--------------------
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; .emacs ends here
next reply other threads:[~2011-12-02 5:20 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2011-12-02 5:20 Da Zhang [this message]
2011-12-02 7:53 ` bug#10192: Emacs 24.0.92 windows build, fatal error with M-< or M-> Eli Zaretskii
[not found] ` <4ED9DECF.6000500@gmail.com>
2011-12-03 10:05 ` Eli Zaretskii
2011-12-02 14:08 ` Stefan Monnier
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=4ED86015.4010705@gmail.com \
--to=zhangda82@gmail.com \
--cc=10192@debbugs.gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this external index
https://git.savannah.gnu.org/cgit/emacs.git
https://git.savannah.gnu.org/cgit/emacs/org-mode.git
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.