;;;
;;; My personal .emacs.el file for use with GNU Emacs.
;;; Last big update: Wed Jul 27 15:43:41 CDT 2011
;;;
;;; Instead of splitting this file up, I leave it as one big file for easier sharing.
;;; Here are the major sections, in order (for case-sensitive searching ease):
;;; 1. INIT   - Pre-requisites and figuring out locale.
;;; 2. DEFUN  - Functions I created or borrowed and use.
;;; 3. MAIN   - Call above functions and set up modes.
;;; 4. FINAL  - Final steps and then work.
;;;


;;;
;;; Current : INIT   - Pre-requisites and figuring out locale.
;;; Next    : DEFUN
;;;

(setq load-path (append (list (expand-file-name "~/emacs/lisp")
                         ;; (expand-file-name "~/emacs/lisp/jde-2.1.5")
                         (expand-file-name "~/emacs/lisp/slime-2.0")
                         )
                        load-path))

(defun tjc-ethint-dump nil
"Based on system-type, return interface cfgs as string or nil if unknown.
Cf. Net-utils' ifconfig, which is cross-platform, configurable,
interactive, and creates a buffer."
  (let ((intout))
    (cond
     ((string= system-type "gnu/linux")
      (setq intout (shell-command-to-string "ifconfig")))
     ((string= system-type "windows-nt")
      (setq intout (shell-command-to-string "ipconfig /all")))
     (t nil))))

;; If not specified or undefined via environment, make a best-guess, 
;; based on network config, of our location (for later resource picks).
(or (/= (length (getenv "TJC_PLACE")) 0)
    (let ((intout (tjc-ethint-dump)))
      (and intout
           (setenv "TJC_PLACE"
                   (cond
                    ((string-match "192\.168\.100\." intout)
                     "home")
                    ((string-match "129\.120\." intout)
                     "work")
                    (t
                     nil))))))

;;;
;;; Previous: INIT  
;;; Current : DEFUN  - Functions I created or borrowed and use. 
;;; Next    : MAIN
;;;

;; This function is called when I detect that I am running under a GUI
;; environment.  For example, X or Win32.
(defun configure-for-gui nil
  "Configure environment for use with a graphic user interface (X,NT,95)."
  (message "Configuring for a graphic user interface...")
  (set-language-environment "Latin-1")
  (setq x-select-enable-clipboard t)

  (setq frame-title-format 
        '((multiple-frames ("%b   ") 
                           ("" invocation-name " @ " system-name))))

  ;; This gets emacs/NT to show proper new-frame attribs (ie. speedbar).
  ;; This is a generally appropriate approach for setting defaults anyway.
  (setq default-frame-alist
        '((cursor-color . "white")
          (cursor-type . box)
          (foreground-color . "yellow")
          (border-color . "BlueViolet")
          (width . 120)
          (height . 43)
          (background-color . "black")))
  
  ;; No W32 bold versions of any X fonts (and visa versa)
  (if (equal window-system 'x)
      (progn   (make-face-bold       'modeline)
               (make-face-bold       'region)))

  (tool-bar-mode 0)

  (message "Configuring for a graphic user interface...done."))

;;; 1999-07-12 Noah Friedman <friedman@splode.com>
;;;
(defun make-buffer-file-executable-if-script-p ()
  "Make file executable according to umask if not already executable.
If file already has any execute bits set at all, do not change existing
file modes."
  (and (save-excursion
         (save-restriction
           (widen)
           (goto-char (point-min))
           (save-match-data
             (looking-at "^#!"))))
       (let* ((current-mode (file-modes (buffer-file-name)))
              (add-mode (logand ?\111 (default-file-modes))))
         (or (/= (logand ?\111 current-mode) 0)
             (zerop add-mode)
             (set-file-modes (buffer-file-name)
                             (logior current-mode add-mode))))))

;; This function is called when I detect I am running under a unix system.
(defun configure-for-unix nil
  "Configure environment for use with unix operating system."
  (message "Configuring for a unix operating system...")

  (add-hook 'after-save-hook 'make-buffer-file-executable-if-script-p)

  (and (file-executable-p "/usr/bin/aspell")
       (progn (setq-default ispell-program-name "/usr/bin/aspell")
              (setq-default ispell-dictionary "english")))

  ;; ################################################## python
  ;;  (setq py-python-command "/usr/local/bin/python" )
  ;;   (autoload 'python "python-mode" "Python Mode" t)
  ;;   (autoload 'python-mode "python-mode" "Python Mode" t)
  ;;   (setq auto-mode-alist
  ;;         (append '(("\\.py$" . python-mode)) auto-mode-alist))
  (setq auto-mode-alist
      (cons '("\\.py$" . python-mode) auto-mode-alist))
  (setq interpreter-mode-alist
        (cons '("python" . python-mode)
              interpreter-mode-alist))
  (autoload 'python-mode "python-mode" "Python editing mode." t)
  (add-hook 
   'python-mode-hook
   (function
    (lambda ()
      (define-key py-mode-map [(control meta h)] 'tim-backward-kill-word))))
  
  ;; ##################################################  PS-Print
  ;; (require 'ps-print)
  ;; (setq ps-paper-type 'letter)
  ;; (setq ps-lpr-command "/usr/bin/lpr")
  ;; (setq ps-lpr-switches '("-Pgab550blj")) 
  ;; (define-key global-map "\C-cp" 'ps-print-buffer-with-faces)

  (message "Configuring for a unix operating system...done."))

;; This function is called when I detect I am running under a Win32 system.
(defun configure-for-w32 nil
  "Configure environment for use with W32 operating systems."

  (message "Configuring for a w32 operating system...")

  ;; ################################################## python
  (setq py-python-command "C:/Python21/python.exe" )
  (autoload 'python "python-mode" "Python Mode" t)
  (autoload 'python-mode "python-mode" "Python Mode" t)
  (setq auto-mode-alist
        (append '(("\\.py$" . python-mode)) auto-mode-alist))

  ;; ################################################## url browser
  ;; Configure Emacs to use the default browser on 
  ;; your system
  ;; to display the JDE documentation.
  (defvar shell-execute-helper "shelex.exe")
  (defun shell-execute-url (url &optional new-window)
    "Invoke the shell-execute-helper program to call ShellExecute and launch
       or re-direct a web browser on the specified url."
          (interactive "sURL: ")
          (call-process shell-execute-helper nil nil nil url))
  (setq browse-url-browser-function 'shell-execute-url)

  ;; ################################################## ispell4
  (setq-default ispell-program-name "c:/cygwin/bin/aspell")
  
  (message "Configuring for a w32 operating system...done."))

;; VI-ish paren matching
;; --
;; originally attributed to: michael@uni-paderborn.de
;; embellished by: jxh@cs.wustl.edu
;;                 Fixed it so that it doesn't move off of a closing brace
;;                 if no match is found.
;; --
(defun vi-type-paren-match (arg)
  "Go to the matching parenthesis if on parenthesis otherwise insert %."
  (interactive "p")
  (let ((oldpos (point)))
    (cond
     ((looking-at "[{([]")
      (forward-sexp 1) (backward-char))
     ((looking-at "[])}]")
      (forward-char)
      (condition-case nil
          (progn
            (backward-sexp 1)
            (while (not (looking-at "[{([]")) (forward-char)))
        (error (progn
                 (backward-char)
                 (error (message "Unbalanced parentheses"))))))
     (t (self-insert-command (or arg 1))))))

(defun tjc-kill-line (arg)
  "Kill the current line and move to next line.  Place point in same column 
as deleted line or place point at end of line if line is shorter than deleted
line."
  (interactive "p")
  (let ((orig (point)))
    (beginning-of-line)
    (let ((beg (point)))
      (forward-line 1)
      (delete-region beg (point)))
    ;;If line is shorter than previous line, then just go to end of line.
    (end-of-line)
    (let ((new (point)))
      (if (< orig new)
          (goto-char orig)))))

(defun tjc-duplicate-line (arg)
  "Copy current line beneath itself.  Move point to new copy of line in 
exact same position as previous line."
  (interactive "p")
  (let ((orig (point)))
    (beginning-of-line)
    (let ((beg (point)))
      (end-of-line)
      (let ((end (point)))
        (copy-region-as-kill beg end)
        (newline)
        (yank)
        ;; Place point on copied line at column where point was on 
        ;; previous line.
        (goto-char (+ orig (- end orig) (- orig beg) 1))))))

;; This is a function that kills words the way I like.  Similar to Borland.
(defun tim-kill-word (arg)
  "If point is on a word, kill forward the word. If on a space, kill
forward whitespace (including newlines) until word character.
Inspired by Borland-like editors.  Does not support arg words/spaces
to delete."
  (interactive "p")
  (save-excursion
   ;; if 2 or more whitespace chars, just kill whitespace
    (cond ((looking-at "\[ \t\n\]\[ \t\n\]+") 
           (kill-region (point)
                        (progn 
                          (search-forward-regexp "[ \t\n]+" nil t)
                          (point))))
           ;; otherwise perform regular forward word kill
          (t 
           (kill-region (point) (progn 
                                  (forward-word arg) 
                                  (point)))))))

;; This is a function that kills words the way I like.  Similar to Borland.
(defun tim-backward-kill-word (arg)
  "If there is more than one whitespace character before point, delete
whitespace before point.  Otherwise if the only whitespace character
before point is a newline character, delete newline character.
Otherwise, run kill-word with negactive argument.\n
Very similar to cc-mode's hungry delete, but tied to kill-word routine
for on-demand use.  Inspired by Borland-like editors.  Does not
support arg words/spaces to delete.  Does not perform 100% as expected
because it calls kill-word, which ignores punctuation as it blows away
previous word(s)."
  (interactive "p")
  (save-excursion
    (cond 
         ;; no (looking-before) fun, so must (backward-char) and (looking-at).
         ;; if 2 or more whitespace chars, just kill whitespace
         ((save-excursion 
           (if (and 
                (progn (backward-char) (looking-at "\[ \t\n\]"))
                (progn (backward-char) (looking-at "\[ \t\n\]")))
               (progn 
                 ;(message "killing multiple whitespace chars")
                 (forward-char)
                 (forward-char)
                 (kill-region 
                  (point) 
                  (progn
                    (forward-word -1)
                    (search-forward-regexp "\[^ \t\n\]+" nil t)
                    (point)))))))
          ;; If just one newline char, delete it
          ((save-excursion 
            (backward-char)
            (if (looking-at "\n")
                (progn  
                  ;(message "killing one newline char")
                  (delete-char 1)
                  t))))
          ;; otherwise perform regular backward word kill
          (t
           ;(message "killing one word")
           (kill-word -1)))))

;; I *very* frequently want to execute a shell command on the region
;; and replace region with the results (like a vi motion command).
;; This is a shell for shell-command-on-region.  It just creates
;; a region if there isn't one and runs the shell-command-on-region.
(defun my-shell-command-on-region nil
  "Replace region with ``shell-command-on-region''.

By default, this will make mark active if it is not and then prompt
you for a shell command to run and replaces region with the results.
This is handy for doing things like getting external program locations
in scripts and running grep and whatnot on a region."
  (interactive)
  (save-excursion
    (if (equal mark-active nil)
        (push-mark nil nil -1))
    ;; Next couple lines stolen from simple.el
    (setq string
          (read-from-minibuffer "Shell command on region: " nil nil nil
                                'shell-command-history))
    (shell-command-on-region (region-beginning) (region-end) string -1)
    ;; Get rid of final newline cause I normally did by hand anyway.
    (delete-char -1)))

(defun insert-date ()
  "Insert date at point."
  (interactive)
  (insert (format-time-string "%a %b %d %T %Z %Y")))

(defun author ()
  "Insert email address and date at point."
  (interactive)
  (insert user-mail-address)
  (insert ", ")
  (insert-date)
  (insert ": "))

;;;
;;; Previous: DEFUN
;;; Current : MAIN - Call above functions, set up modes.
;;; Next    : FINAL
;;;

(setq user-full-name "Tim Christian")
(setq default-major-mode 'text-mode)
(fset 'yes-or-no-p 'y-or-n-p)           ; Prevent "y" "e" "s" confirmations
(line-number-mode t)                    ; More useful mode line
(column-number-mode t)                  ; More useful mode line
(menu-bar-mode 0)                       ; More screen real estate
(setq track-eol t)                      ; if @ eol, then up/down goes to prev/next eol
;(setq scroll-step 0)                   ; Reduce screen jumping
;(setq hscroll-step 0)                  ; Reduce screen jumping
;`->  Decided that I end up scrolling more anyway, so defaul screen jump is faster.
(autoload 'align "align" nil t)         ; Align items within a region
(put 'downcase-region 'disabled nil)
(put 'upcase-region 'disabled nil)
(setq auto-save-default nil)            ; Don't periodically save
(setq make-backup-files nil)            ; Don't make back-ups
(setq-default indent-tabs-mode nil)     ; Don't insert tabs when indenting
(setq next-line-add-newlines nil)       ; Don't LF @ EOF
(setq resize-mini-windows t)            ; Dynamically re-size mini-buffer 

;; Edit remote files via ssh
(require 'tramp)
(autoload 'ssh  "ssh" "Secure SHell Mode" t)

;; Emacs server start up, for use with emacsclient (and tty mode emacs).
(unless (string-equal "root" (getenv "USER")) (server-start))
(remove-hook 'kill-buffer-query-functions 'server-kill-buffer-query-function)
(add-hook 'server-switch-hook 'raise-frame)

;; Printing 
(and (string= (getenv "TJC_PLACE") "work")
     (setq printer-name "Techs"))
(and (string= (getenv "TJC_PLACE") "home")
     (setq printer-name "aio"))
(setq ps-paper-type 'letter)
(setq ps-print-color-p t)

;; Display file name's context in buffer list.
(require 'uniquify)
(setq uniquify-buffer-name-style 'reverse)

;; Hide passwords entered into the password prompt.
(add-hook 'comint-output-filter-functions 'comint-watch-for-password-prompt)

(setq frame-background-mode 'dark)
(global-font-lock-mode t)                         ; Enable syntax highlighting
(setq-default truncate-lines t)                   ; Don't wrap lines

(setq-default
  transient-mark-mode      t                      ; Show me what I highlight
  search-highlight         t                      ; Highlight search results
  query-replace-highlight  t                      ; Highlight query/replace expressions
  show-paren-mode          1                      ; Show matching set
)
(show-paren-mode t)
(global-hl-line-mode 1)                           ; Subtly highlight line containing point (cursor)
(set-face-background 'hl-line "#333")

;; These change all frames
;; Setting this munges hl-line.el: (set-face-background  'highlight "FireBrick2")
(set-face-foreground  'modeline  "Yellow"    )
(set-face-background  'modeline  "Blue")
(set-face-background  'region    "FireBrick2")

;; Font locking info mode (from Andy.Ling@quantel.com)
(defvar info-font-lock-keywords
  (list
   '("^\\* [^:]+:+" . font-lock-function-name-face)
   '("\\*[Nn]ote\\b[^:]+:+" . font-lock-reference-face)
   '("  \\(Next\\|Prev\\|Up\\):" . font-lock-reference-face))
  "Additional expressions to highlight in Info mode")
(add-hook 'Info-mode-hook
          (lambda ()1
            (make-local-variable 'font-lock-defaults)
            (setq font-lock-defaults '(info-font-lock-keywords nil t))))

(configure-for-gui) ; See previously-defined function

;; Do OS specific things
(if (string-match "unix"    (symbol-name system-type)) (configure-for-unix))
(if (string-match "windows" (symbol-name system-type)) (configure-for-w32))

;; ################################################## Keys
;; Note that keys are also bound near file load areas.
;;  Loaded last to make sure our keys dominate any strokes that other
;;  other packages set (like completion replaces the % char).
(global-set-key "\C-xt" 'upcase-initials-region)
(global-set-key "\C-co" 'occur)
(global-set-key "\C-x\C-b" 'ibuffer)
;; Edits
(global-set-key [C-backspace] 'tim-backward-kill-word)  ; Borland-like kill word
(global-set-key "\M-d" 'tim-kill-word)                  ; Borland-like forwrad kill
(define-key global-map [f4] 'tjc-duplicate-line)        ; Duplicate entire current line.
(define-key global-map [f5] 'tjc-kill-line)             ; Delete entire current line.
(global-set-key "\M-%" 'query-replace-regexp)
;; Jumps
(global-set-key "\C-s" 'isearch-forward-regexp)
(global-set-key "\C-r" 'isearch-backward-regexp)
(global-set-key "\M-g" 'goto-line)
(define-key global-map "%" 'vi-type-paren-match)        ; VI sim paren match; Use quoted-insert key to override
;; Rolodex keys
(global-unset-key "\M-r")
(global-set-key "\M-rf" 'rolo-fgrep)
(global-set-key "\M-rg" 'rolo-grep)
(global-set-key "\M-re" 'rolo-edit)
;; Window keys
(global-set-key [S-up] 'enlarge-window)
(global-set-key [S-down]  'shrink-window)
(global-set-key [S-left]  'shrink-window-horizontally)
(global-set-key [S-right] 'enlarge-window-horizontally)
(global-set-key "\C-xp" '(lambda () (interactive) (other-window -1))) ; Previous window
;; I replace region with shell contents pretty darn frequently
(global-set-key "\M-|" 'my-shell-command-on-region)
(global-set-key "\C-cd" (current-time-string))
(global-set-key "\C-c;" 'comment-region)
(global-set-key "\C-cd" 'insert-date)
(global-set-key "\C-ca" 'author)
;(autoload 'tjc-flashcard "flashcard" "Process flashcard entry file" t)
;(autoload 'tjc-make-flashcard-entry "flashcard" "Make flashcard entry" t)
;(global-set-key "\C-ce" 'tjc-make-flashcard-entry)
;(global-set-key "\C-cf" 'tjc-flashcard)
; `-> Disused and retained for nostalgia.

;; ################################################## mode-compile
;; Compiles using mode as a reference.
;; Useful for working amongst a number of interpreted/compiled languages (e.g., perl)
(autoload 'mode-compile "mode-compile"
 "Command to compile current buffer file based on the major mode" t)
(global-unset-key "\C-cc")
(global-set-key "\C-cc" 'mode-compile)
(autoload 'mode-compile-kill "mode-compile"
 "Command to kill a compilation launched by `mode-compile'" t)
(global-set-key "\C-ck" 'mode-compile-kill)

;; ################################################## ibuffer
(require 'ibuffer)
(setq ibuffer-default-sorting-mode 'major-mode)   ; Handy for deleting man/help buffers.
(setq ibuffer-always-show-last-buffer t)          ; Always show prev buffer
(setq ibuffer-view-ibuffer nil)                   ; No need to see current buffer in list

;; ################################################## ido
(ido-mode 1)
(ido-everywhere 1)
(setq confirm-nonexistent-file-or-buffer nil)     ; Die you annoying confirmations
(setq ido-confirm-unique-completion nil)          ; Die you annoying confirmations
(setq ido-create-new-buffer 'always)              ; Die you annoying confirmations
(setq ido-enable-tramp-completion nil)            ; Requires a set up file
(setq ido-enable-flex-matching t)                 ; More handy than enable-regexp
(setq ido-enable-regexp nil)                      ; Cool idea, but seems to taint flex-matching
(setq ido-show-dot-for-dired nil)                 ; I prefer ido-find-file and use C-d to launch dired
; Disable auto searching for files in "work directories" (see ido-merge-work-directories)
(setq ido-auto-merge-delay-time 99999)
; Explicitly call searching for files in "work directories" (see ido-merge-work-directories)
(define-key ido-file-dir-completion-map (kbd "C-c C-s") 
  (lambda() 
    (interactive)
    (ido-initiate-auto-merge (current-buffer))))
;; Use ido to complete M-x commands
(global-set-key
 "\M-x"
 (lambda ()
   (interactive)
   (call-interactively
    (intern
     (ido-completing-read
      "M-x "
      (all-completions "" obarray 'commandp))))))
;; Integrate ido into recentf
(defun ido-recentf-open ()
  "Use `ido-completing-read' to \\[find-file] a recent file"
  (interactive)
  (if (find-file (ido-completing-read "Find recent file: " recentf-list))
      (message "Opening file...")
    (message "Aborting")))

;; ################################################## recentf
(require 'recentf)
(recentf-mode t)
(setq recentf-max-saved-items 50)
(global-set-key (kbd "C-x C-r") 'ido-recentf-open); Replace find-file-read-only

;; ################################################## text
(load-library "indent-mode")
(add-hook 'text-mode-hook '(lambda ()
                             (auto-fill-mode 1)
                             (indent-mode 1)
                             (flyspell-mode 1)))

(add-hook 'text-mode-hook '(lambda () (indent-mode 1)))
;; Make some chars punctuation so kill-word (etc.) works as I intend.
(modify-syntax-entry ?$ "." text-mode-syntax-table)
(modify-syntax-entry ?/ "." text-mode-syntax-table)
(modify-syntax-entry ?- "." text-mode-syntax-table)

;; ################################################## lisp
;; Make some chars punctuation so kill-word (etc.) works as I intend.
(modify-syntax-entry ?/ "." lisp-mode-syntax-table)
(modify-syntax-entry ?/ "." emacs-lisp-mode-syntax-table)

;; ################################################## perl
; cperl-mode is preferred to perl-mode                                        
(defalias 'perl-mode 'cperl-mode)
(autoload 'cperl-mode "cperl-mode" "alternate mode for editing Perl programs" t)
(setq cperl-font-lock t
      cperl-electric-linefeed t
      cperl-electric-keywords t
      cperl-info-on-command-no-prompt t
      cperl-electric-lbrace-space nil
      cperl-clobber-lisp-bindings t
      cperl-lazy-help-time nil)
(add-hook 'cperl-mode-hook
          (lambda ()
            (define-key cperl-mode-map (kbd "C-c C-c") 'mode-compile)
            (define-key cperl-mode-map (kbd "C-c C-w") 'cperl-check-syntax)))

;; ################################################## org
(setq auto-mode-alist
      (append '(("\\.org$" . org-mode)) auto-mode-alist))
; Wanted <pre> style for <p> text and CSS for org-mode doesn't support that natively, so we use this var hook:
; For white-space value ref, see: http://www.w3.org/TR/CSS21/text.html
; (setq org-export-html-style '"<style type=\"text/css\">\n  html {\nfont-family: Times, serif;\nfont-size: 12pt;\n  }\n  p {\n\twhite-space: pre-wrap;\n\tborder: 1pt solid #AEBDCC;\n\tbackground-color: #F3F5F7;\n\tpadding: 5pt;\n\tfont-family: courier, monospace;\n  }\n  .title { text-align: center; }\n  .todo  { color: red; }\n  .done { color: green; }\n  .timestamp { color: grey }\n  .timestamp-kwd { color: CadetBlue }\n  .tag { background-color:lightblue; font-weight:normal }\n  .target { background-color: lavender; }\n  pre {\nborder: 1pt solid #AEBDCC;\nbackground-color: #F3F5F7;\npadding: 5pt;\nfont-family: courier, monospace;\n  }\n  table { border-collapse: collapse; }\n  td, th {\nvertical-align: top;\n<!--border: 1pt solid #ADB9CC;-->\n  }\n</style>")

;; ################################################## igrep
(autoload (function igrep) "igrep"
   "*Run `grep` PROGRAM to match EXPRESSION in FILES..." t)
(setq igrep-read-options t)
(autoload (function igrep-find) "igrep"
   "*Run `grep` via `find`..." t)
(autoload (function dired-do-igrep) "igrep"
   "*Run `grep` on the marked (or next prefix ARG) files." t)
(autoload (function dired-do-igrep-find) "igrep"
   "*Run `grep` via `find` on the marked (or next prefix ARG) directories." t)
(autoload (function grep) "igrep"
   "*Run `grep` PROGRAM to match EXPRESSION in FILES..." t)
(autoload (function egrep) "igrep"
   "*Run `egrep`..." t)
(autoload (function fgrep) "igrep"
   "*Run `fgrep`..." t)
(autoload (function agrep) "igrep"
   "*Run `agrep`..." t)
(autoload (function grep-find) "igrep"
   "*Run `grep` via `find`..." t)
(autoload (function egrep-find) "igrep"
   "*Run `egrep` via `find`..." t)
(autoload (function fgrep-find) "igrep"
   "*Run `fgrep` via `find`..." t)
(autoload (function agrep-find) "igrep"
   "*Run `agrep` via `find`..." t)
(autoload (function dired-do-grep) "igrep"
   "*Run `grep` on the marked (or next prefix ARG) files." t)
(autoload (function dired-do-grep-find) "igrep"
   "*Run `grep` via `find` on the marked (or next prefix ARG) directories." t)

;; ################################################## sql
;;;
;;; sql-mode.el is COMPLETE crap.  
;;; I've beat on it for several hours, twice!
;;; Use the simple and clean, default sql.el instead.
;;;
;; Assume we'll just use one output buffer
(setq set-buffer "*SQL*")
(autoload 'sql-mysql "sql" "Start SQL interface to MySQL" t)

;; ################################################## rolo-2
(require 'rolo)
(setq rolo-entry-regexp "^*+")
(autoload 'rolo-fgrep "rolo" "Find entries in rolodex." t)
(autoload 'rolo-grep "rolo" "Find entries in rolodex." t)
(autoload 'rolo-edit "rolo" "Edit personal rolodex file." t)
(autoload 'rolo-sort "rolo" "Sort rolodex file." t)
(setq auto-mode-alist
   (append '(("\\.otl$" . outline-mode)) auto-mode-alist))
(setq auto-mode-alist
   (append '(("Rolodex" . outline-mode)) auto-mode-alist))

;; ################################################## calc
;;; Commands added by calc-private-autoloads on Fri Mar  6 17:33:12 1998.
(autoload 'calc-dispatch           "calc" "Calculator Options" t)
(autoload 'full-calc               "calc" "Full-screen Calculator" t)
(autoload 'full-calc-keypad        "calc" "Full-screen X Calculator" t)
(autoload 'calc-eval               "calc" "Use Calculator from Lisp")
(autoload 'defmath                 "calc" nil t t)
(autoload 'calc                    "calc" "Calculator Mode" t)
(autoload 'quick-calc              "calc" "Quick Calculator" t)
(autoload 'calc-keypad             "calc" "X windows Calculator" t)
(autoload 'calc-embedded           "calc" "Use Calc inside any buffer" t)
(autoload 'calc-embedded-activate  "calc" "Activate =>'s in buffer" t)
(autoload 'calc-grab-region        "calc" "Grab region of Calc data" t)
(autoload 'calc-grab-rectangle     "calc" "Grab rectangle of data" t)
(setq load-path (nconc load-path (list "~/emacs/lisp/calc-2.02e")))
(global-set-key "\e#" 'calc-dispatch)
;;; End of Calc autoloads.

;; ################################################## rect-mark
;; Enables a "visual" of a rectangle mark command and includes copy command.
(define-key ctl-x-map "r\C-@" 'rm-set-mark)
(define-key ctl-x-map [?r ?\C-\ ] 'rm-set-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)

;; ################################################## slime
(setq inferior-lisp-program "/usr/bin/lisp") ; your Lisp system
(require 'slime)
(slime-setup)

;;;
;;; Previous: MAIN
;;; Current : FINAL  - Final steps and then work.
;;;

(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.
 '(font-lock-comment-face ((((class color) (background dark)) (:foreground "White"))))
 '(font-lock-constant-face ((((class color) (background dark)) (:foreground "lightsteelblue"))))
 '(font-lock-emphasized-face ((t (:background "brown"))) t)
 '(font-lock-function-name-face ((((class color) (background dark)) (:foreground "cyan"))))
 '(font-lock-keyword-face ((((class color) (background dark)) (:foreground "chartreuse1"))))
 '(font-lock-other-emphasized-face ((t (:italic t :background "brown"))) t)
 '(font-lock-string-face ((((class color) (background dark)) (:foreground "yellow"))))
 '(font-lock-type-face ((((class color) (background dark)) (:foreground "tan1"))))
 '(font-lock-variable-name-face ((((class color) (background dark)) (:foreground "orchid1"))))
 '(highlight ((t (:background "gray24"))))
 '(term-cyanbg ((t (:foreground "brown" :background "cyan"))) t))

;; Customize startup screen, messages, etc.
(setq inhibit-startup-screen t)
(cond ((equal user-real-login-name "Timothy")
       (eval '(setq inhibit-startup-echo-area-message "Timothy")))
      ((equal user-real-login-name "timothy")
       (eval '(setq inhibit-startup-echo-area-message "timothy")))
      ((equal user-real-login-name "tim")
       (eval '(setq inhibit-startup-echo-area-message "tim"))))
(setq initial-scratch-message nil)

(message (concat "Ready to run as of " (format-time-string "%a, %d %b %Y %T %z")))