lriley.el

;;os specific code
;; install hyperspec locally via 'sudo port install lisp-hyperspec' on
;; os x
(cond ((or (string-equal system-type "darwin") (string-equal system-type "mac"))
       (setq common-lisp-hyperspec-root "file:////opt/local/var/macports/software/lisp-hyperspec/7.0_0/opt/local/share/doc/lisp/HyperSpec-7-0/HyperSpec/"))
      (t ;;otherwise assume we're in linux/bsd
       (setq common-lisp-hyperspec-root "")))

;;;w3m web browser - install via 'sudo port install w3m' 'sudo port install emacs-w3m'
(add-to-list 'load-path "/usr/share/emacs/site-lisp/w3m/")
(require 'w3m-load)
(require 'w3m)
(setq browse-url-browser-function 'w3m)

;; Save backups in one place
;; Put autosave files (ie #foo#) in one place, *not*
;; scattered all over the file system!
(defvar autosave-dir
  (concat "/tmp/emacs_autosaves/" (user-login-name) "/"))
 
(make-directory autosave-dir t)
 
(defun auto-save-file-name-p (filename)
  (string-match "^#.*#$" (file-name-nondirectory filename)))
 
(defun make-auto-save-file-name ()
  (concat autosave-dir
          (if buffer-file-name
              (concat "#" (file-name-nondirectory buffer-file-name) "#")
            (expand-file-name
             (concat "#%" (buffer-name) "#")))))
 
;; Put backup files (ie foo~) in one place too. (The backup-directory-alist
;; list contains regexp=>directory mappings; filenames matching a regexp are
;; backed up in the corresponding directory. Emacs will mkdir it if necessary.)
(defvar backup-dir (concat "/tmp/emacs_backups/" (user-login-name) "/"))
(setq backup-directory-alist (list (cons "." backup-dir)))

;; get the vendor dir into the load path for emacs
(add-to-list 'load-path (concat "~/.emacs.d/vendor/"))

(flyspell-mode 'on)

;; Use VI/VIM inside Emacs 
(setq viper-mode t)                ; enable Viper at load time
(setq viper-ex-style-editing nil)  ; can backspace past start of insert / line
(require 'viper)                   ; load Viper
;;(setq vimpulse-experimental nil)   ; don't load bleeding edge code (see 6. installation instruction)
(require 'vimpulse)                ; load Vimpulse

;;(setq woman-use-own-frame nil)     ; don't create new frame for manpages
;;(setq woman-use-topic-at-point t)  ; don't prompt upon K key (manpage display)

;; Indent CSS automatically
(setq css-indent-offset 2)
(add-hook 'css-mode-hook
          (lambda ()
            (local-set-key (kbd "RET") 'reindent-then-newline-and-indent)))


;; Snippets
(require 'yasnippet)
(yas/initialize)
(yas/load-directory "~/.emacs.d/vendor/yasnippet/snippets")

;; Get rid of the toolbar
(tool-bar-mode 0)

;;; set up slime
(set-language-environment "utf-8")
(add-to-list 'load-path "~/Documents/src/slime/") ; your SLIME directory
;; (setq inferior-lisp-program "/opt/local/bin/sbcl") ; your Lisp system
(setq inferior-lisp-program "/usr/local/bin/ccl64 -K utf-8") ;; use Clozure CL

(require 'slime-autoloads)
(add-hook 'lisp-mode-hook (lambda ()
                            (cond ((not (featurep 'slime))
                                   (require 'slime)
                                   (normal-mode)))
                            (auto-fill-mode -1))
          't
          )

(eval-after-load "slime"
  '(progn
    (add-to-list 'load-path "~/Documents/src/slime/contrib/")
    (slime-setup '(slime-fancy slime-asdf slime-banner))
    (slime-banner-init)
    (slime-asdf-init)
    (setq slime-complete-symbol*-fancy t)
    (setq slime-complete-symbol-function 'slime-fuzzy-complete-symbol)
    (setq slime-net-coding-system 'utf-8-unix)
    (slime-setup)))

(setq slime-enable-evaluate-in-emacs t)
(add-hook 'slime-connected-hook (lambda ()
                                  (define-key slime-mode-map (kbd "C-c C-j")  'slime-eval-print-last-expression)
                                  (define-key slime-mode-map (kbd "C-c C-i") 'slime-inspect)
				  ))
;; get a menu of slime buffers
(define-key global-map (kbd "<f7>") 'slime-selector)
;;; end slime config

;;redshank - psuedo structured Lisp code editing
(require 'redshank-loader
    "~/.emacs.d/vendor/redshank/redshank-loader")  

(eval-after-load "redshank-loader"
  `(redshank-setup '(lisp-mode-hook
                     slime-repl-mode-hook) t))

;;; count the number of words in region
(defun wc ()
  (interactive)
  (message "Word count: %s" (how-many "\\w+" (point) (mark))))

;;; folding
(defun langs-selective-display ()
  "Activate selective display based on the column at point"
  (interactive)
  (set-selective-display
   (if selective-display
       nil
     (+ 1 (current-column)))))
(global-set-key [f4] 'langs-selective-display)


;;; set up objective-j mode
(require 'objj-mode)

;;; in emacs 23, use apple command key as meta instead of option key - swap capslock and control using OS X prefs > Modifier Keys
(setq mac-command-modifier 'meta)


;;; turn off auto fill mode and hl-line-mode when editing ruby code
(add-hook 'ruby-mode-hook
          (lambda()
            (auto-fill-mode -1)
            (hl-line-mode -1))
          't
          )

;;; turn off auto-fill for emacs-lisp-mode
(add-hook 'emacs-lisp-mode-hook
          (lambda ()
            (auto-fill-mode -1))
          't
          )

;;; use viper when editing Lisp asd files - already using for everything else
(add-hook 'asdf-mode-hook
          (lambda ()
            (viper-mode))
          't
          )

;;; emacs git interface - too slow for big projects, but nice for some things
(require 'magit)

;;; move the mouse out of the way when typing starts
(mouse-avoidance-mode 'banish)


;;; set up default color scheme - easy on the eyes
(color-theme-arjen)

;; Use tramp for scp based remote file access/editing
;;(require 'tramp)
;;(setq tramp-default-method "scp")

;;; use jabber in emacs
;; (require 'jabber)

                                                                                                                                                                                 
;;; Set frame width - used on toggle out of fullscreen mode
(defun default-frame-width ()
    "Set width of selected frame."
    (modify-frame-parameters
     (selected-frame)
     (list (cons 'width 120)
           (cons 'height 80))))
                            
;;; This used to be in Carbon Emacs, puttin' it back in with my own twist
(defun mac-toggle-max-window ()
  (interactive)
  (set-frame-parameter nil 'fullscreen 
                       (if (frame-parameter nil 'fullscreen)
                           (progn
                             (scroll-bar-mode 1) ;; turn on scrollbars when not in fullscreen mode
                             (default-frame-width)
                             nil)
                         (progn
                           (scroll-bar-mode -1) ;; turn off scrollbars when in fullscreen mode
                           'fullboth)))) 

;;; Toggle full screen via CMD-Return (my meta key is mapped to command on OS X
(define-key global-map [(meta return)]
    'mac-toggle-max-window)

;;; get rid of the blinking cursor
(blink-cursor-mode -1)

;;; show matching parenthesis
(show-paren-mode t)

;;; highlight the marked region
(transient-mark-mode t)

;;; ignore files when invoking C-x C-f; example ".*\\.dx64fsl" ignores Clozure fasl files, e.g., files that end in dx64fsl
(setq ido-ignore-files (quote ("\\`CVS/" "\\`#" "\\`.#" "\\`\\.\\./" "\\`\\./" ".*\\.dx64fsl")))