;;==============================================================================
;;; modules.el
;;
;;; Emacs Modules
;;
;;; Author: Kyle W T Sherman
;;
;; Time-stamp: <2008-07-17 13:27:53 (kyle)>
;;==============================================================================

(message ";;; modules --> Start")

;;==============================================================================
;;; Load Modules
;;==============================================================================

(message ";;; modules --> Load Modules")

;; local paths
(add-to-list 'load-path "~/.emacs.d")
(add-to-list 'load-path "~/.elisp")
(add-to-list 'load-path "~/.elisp/kyle") ; personal elisp projects
(add-to-list 'load-path "~/emacs")

;; ;; allout (outline minor mode)
;; (message ";;; modules --> allout")
;; (when (require-if-available 'allout)
;;   (if (fboundp 'allout-init)
;;       (allout-init t)
;;     (outline-init t)))

;; ;; apel (a portable emacs library)
;; (message ";;; modules --> apel")
;; (add-to-list 'load-path "~/.elisp/apel")

;; ascii (ascii table)
(message ";;; modules --> ascii")
(when (require-if-available 'ascii)
  (autoload 'ascii-on "ascii" "Turn on ASCII code display." t)
  (autoload 'ascii-off "ascii" "Turn off ASCII code display." t)
  (autoload 'ascii-display "ascii" "Toggle ASCII code display." t)
  (autoload 'ascii-customize "ascii" "Customize ASCII code display." t))

;; auto-recomp (auto recompile files with an `auto-recompile:t' local var)
(message ";;; modules --> auto-recomp")
(require-if-available 'auto-recomp)

;; bbdb (big brother database)
(message ";;; modules --> bbdb")
(add-to-list 'load-path "~/.elisp/bbdb/lisp")
(when (require-if-available 'bbdb)
  (bbdb-initialize))

;; boxquote (creates quote text boxes)
(message ";;; modules --> boxquote")
(when (require-if-available 'boxquote)
  (global-set-key (kbd "C-c b y") 'boxquote-yank)
  (global-set-key (kbd "C-c b r") 'boxquote-region)
  (global-set-key (kbd "C-c b u") 'boxquote-unbox-region)
  (global-set-key (kbd "C-c b t") 'boxquote-title)
  (global-set-key (kbd "C-c b i") 'boxquote-insert-file)
  (global-set-key (kbd "C-c b k") 'boxquote-kill)
  (global-set-key (kbd "C-c b s") 'boxquote-shell-command)

  (global-set-key (kbd "C-c b b") 'boxquote-buffer)
  (global-set-key (kbd "C-c b p") 'boxquote-paragraph)
  (global-set-key (kbd "C-c b n") 'boxquote-narrow-to-boxquote)

  (global-set-key (kbd "C-c b w") 'boxquote-where-is)
  (global-set-key (kbd "C-c b d f") 'boxquote-describe-function)
  (global-set-key (kbd "C-c b d k") 'boxquote-describe-key)
  (global-set-key (kbd "C-c b d v") 'boxquote-describe-variable))

;; browse-kill-ring (selectively insert text)
(message ";;; modules --> browse-kill-ring")
(require-if-available 'browse-kill-ring)

;; ;; calc (advanced rpn calculator)
;; (message ";;; modules --> calc")
;; (add-to-list 'load-path "~/.elisp/calc")
;; (when (require-if-available 'calc)
;;   (autoload 'calc-dispatch "calc" "Emacs Calculator" t nil)
;;   (global-set-key "\M-#" 'calc-dispatch))

;; cedet (collection of emacs development environment tools)
(message ";;; modules --> cedet")
(add-to-list 'load-path "~/.elisp/cedet")
(add-to-list 'load-path "~/.elisp/cedet/cogre")
(add-to-list 'load-path "~/.elisp/cedet/common")
(add-to-list 'load-path "~/.elisp/ede")
(add-to-list 'load-path "~/.elisp/eieio")
(add-to-list 'load-path "~/.elisp/semantic")
(add-to-list 'load-path "~/.elisp/speedbar")
(add-to-list 'load-path "~/.elisp/elib")
(require-if-available 'cedet)
;; ;; create sematic cache dir
;; (defconst semanticdb-dir "~/.semanticdb")
;; (make-directory (expand-file-name semanticdb-dir) t)
(require-if-available 'semantic)
;;   ;; semantic code completion
;;   (setq semantic-load-turn-useful-things-on t)
;;   ;;(setq semantic-load-turn-everything-on t)
;;   (setq semanticdb-default-save-directory semanticdb-dir)
;;   (semantic-load-enable-code-helpers)
;;   ;;(semantic-load-enable-guady-code-helpers)
;;   ;;(semantic-load-enable-excessive-code-helpers)
;;   ;;;;(semantic-load-enable-semantic-debugging-helpers)
;;   (semantic-idle-summary-mode t)
;;   )

;; ;; color-theme (crazy color themes)
;; (message ";;; modules --> color-theme")
;; (require-if-available 'color-theme)

;; context (save context from previous sessions)
(message ";;; modules --> context")
(when (require-if-available "context")
  (read-context)
  ;;(context-restore)
  ;; ignore some files
  (push (expand-file-name "~/org") context-ignore-files)
  (push (expand-file-name "~/tmp") context-ignore-files)
  ;; save durring idle time (wait 10s)
  (run-with-idle-timer 10 t 'save-context))

; css-mode (css editing mode)
(message ";;; modules --> css-mode")
(when (require-if-available 'css-mode)
  (autoload 'css-mode "css-mode")
  ;; set mode for various extensions
  (add-to-list 'auto-mode-alist '("\\.css$" . css-mode))
  (setq cssm-indent-function #'cssm-c-style-indenter))

;; cua (windows like cut-and-paste)
(message ";;; modules --> cua")
(if (>= emacs-major-version 22)
    (progn
      (cua-mode t)
      (setq cua-delete-copy-to-register-0 t)
      (setq cua-highlight-region-shift-only nil)
      (global-set-key "\C-@" 'cua-set-mark)
      )
  (when (require-if-available 'cua)
    (CUA-mode t)
    ;;(CUA-keypad-mode 'prefix t)
    (setq CUA-mode-delete-to-register-0 t)
    (setq CUA-mode-remap-cx-shift-only nil)
    (setq CUA-mode-highlight-shift-only nil)
    (setq CUA-mode-inhibit-method 'twice)
    (setq CUA-mode-inhibit-delay 0)
    (global-set-key "\C-@" 'CUA-set-mark))
  )

;; cycle-buffers (buffer cycle commands)
(message ";;; modules --> cycle-buffers")
(when (require-if-available 'cycle-buffer)
  (autoload 'cycle-buffer "cycle-buffer"
    "Cycle forward." t)
  (autoload 'cycle-buffer-backward "cycle-buffer"
    "Cycle backward." t)
  (autoload 'cycle-buffer-permissive "cycle-buffer"
    "Cycle forward allowing *buffers*." t)
  (autoload 'cycle-buffer-backward-permissive "cycle-buffer"
    "Cycle backward allowing *buffers*." t)
  (autoload 'cycle-buffer-toggle-interesting "cycle-buffer"
    "Toggle if this buffer will be considered." t))

;; desktop history
(when (>= emacs-major-version 22)
  (message ";;; modules --> desktop history")
  (desktop-save-mode t)
  (setq history-length 250)
  (add-to-list 'desktop-globals-to-save 'file-name-history)
  (setq desktop-buffers-not-to-save
        (concat "\\("
                "\\.log\\|(ftp)\\|^tags\\|^TAGS"
                "\\.diary\\|\\diary\\|\\.bbdb"
                "\\)$"))
  ;; (concat "\\(" "^nn\\.a[0-9]+\\|\\.log\\|(ftp)\\|^tags\\|^TAGS"
  ;;         "\\|\\.emacs.*\\|\\.diary\\|\\.newsrc-dribble\\|\\.bbdb"
  ;;         "\\)$"))
  ;;(add-to-list 'desktop-modes-not-to-save 'dired-mode)
  (add-to-list 'desktop-modes-not-to-save 'Info-mode)
  (add-to-list 'desktop-modes-not-to-save 'info-lookup-mode)
  ;;(add-to-list 'desktop-modes-not-to-save 'fundamental-mode)
  )

;; dictionary (dictionary server word lookup)
(message ";;; modules --> dictionary")
(add-to-list 'load-path "~/.elisp/dictionary")
(when (require-if-available 'dictionary)
  (load "dictionary-init"))

;; dired (built-in dired mode)
(message ";;; modules --> dired")
(when (require-if-available 'dired)
  ;; only prompt once for recursive deletes
  (setq dired-recursive-deletes 'top)

  ;; ;; dired load hook
  ;; (defun local-dired-init ()
  ;;   ;; key bindings
  ;;   (define-key dired-mode-map [return] 'dired-maybe-insert-subdir)
  ;;   (define-key dired-mode-map "\C-m" 'dired-maybe-insert-subdir)
  ;;   (define-key dired-mode-map [mouse-1] 'dired-maybe-insert-subdir))
  ;; ;; if dired's already loaded, then update the keymap
  ;; (if (boundp 'dired-mode-map)
  ;;     (local-dired-init)
  ;;   ;; otherwise, add bindings to the load-hook
  ;;   (add-hook 'dired-load-hook 'local-dired-init))

  ;; dired hook for more settings
  (defun local-dired-mode-hook ()
    ;; only use one buffer
    ;;(define-key dired-mode-map (kbd "RET") 'dired-find-alternate-file)
    ;; edit file names within dired
    (define-key dired-mode-map "e" 'wdired-change-to-wdired-mode))

  ;; add hook to dired mode
  (add-hook 'dired-mode-hook 'local-dired-mode-hook)
  )

;; dired-single (single buffer dired mode)
(message ";;; modules --> dired-single")
(when (require-if-available 'dired-single)
  (defun local-dired-single-init ()
    ;; key bindings
    (define-key dired-mode-map [return] 'joc-dired-single-buffer)
    (define-key dired-mode-map "\C-m" 'joc-dired-single-buffer)
    (define-key dired-mode-map [mouse-1] 'joc-dired-single-buffer-mouse)
    (define-key dired-mode-map "^"
      (function (lambda () (interactive) (joc-dired-single-buffer "..")))))
  ;; if dired's already loaded, then update the keymap
  (if (boundp 'dired-mode-map)
      (local-dired-single-init)
    ;; otherwise, add bindings to the load-hook
    (add-hook 'dired-load-hook 'local-dired-single-init)))

;; ebby (collaborative editing using obby protocol)
;; (message ";;; modules --> ebby")
;;(require-if-available 'ebby)

;; ;; ecb (source code browser)
;; (message ";;; modules --> ecb")
;; (add-to-list 'load-path "~/.elisp/ecb")
;; (when (require-if-available 'ecb)
;;   (autoload 'ecb-activate "ecb" "ecb-activate" t))

;; ;; ee (categorizing information manager)
;; (message ";;; modules --> ee")
;; (add-to-list 'load-path "~/.elisp/ee/")
;; (when (require-if-available 'ee-autoloads)
;;   (global-set-key "\C-x\C-b" 'ee-buffers))

;; ;; eieio (enhanced integration of emacs interpreted objects)
;; ;; (depends on cedet)
;; (message ";;; modules --> eieio")
;; (add-to-list 'load-path "~/.elisp/cedet/eieio")

;; elib (emacs lisp library)
(message ";;; modules --> elib")
(add-to-list 'load-path "~/.elisp/elib")

;; ;; ell (browse emacs lisp library)
;; (message ";;; modules --> ell")
;; (setq ell-locate t)
;; (setq ell-goto-addr nil)
;; (require-if-available 'ell)

;; ;; elscreen (screen like functionality)
;; ;; (depends on apel)
;; (message ";;; modules --> elscreen")
;; (add-to-list 'load-path "~/.elisp/elscreen")
;; (when (require-if-available 'elscreen)
;;   (global-unset-key [(meta ?a)])
;;   (global-set-key "\M-ab" 'elscreen-split)
;;   (global-set-key "\M-al" 'elscreen-link)
;;   (global-set-key "\M-ai" 'elscreen-number-mode-line)
;;   (global-set-key "\M-av" 'elscreen-show-version)
;;   (global-set-key "\M-aA" 'elscreen-name)
;;   (global-set-key "\M-at" 'elscreen-show-time)
;;   (global-set-key "\M-am" 'elscreen-show-last-message)
;;   (global-set-key [(meta ?a) (ret)] 'elscreen-show-last-message)
;;   (global-set-key "\M-aw" 'elscreen-show-list)
;;   (global-set-key "\M-a\M-w" 'elscreen-show-list)
;;   (global-set-key "\M-ab" 'elscreen-switch-to-buffer)
;;   (global-set-key "\M-a\M-f" 'elscreen-find-file)
;;   (global-set-key "\M-a?" 'elscreen-help)
;;   (global-set-key "\M-a9" 'elscreen-jump)
;;   (global-set-key "\M-a8" 'elscreen-jump)
;;   (global-set-key "\M-a7" 'elscreen-jump)
;;   (global-set-key "\M-a6" 'elscreen-jump)
;;   (global-set-key "\M-a5" 'elscreen-jump)
;;   (global-set-key "\M-a4" 'elscreen-jump)
;;   (global-set-key "\M-a3" 'elscreen-jump)
;;   (global-set-key "\M-a2" 'elscreen-jump)
;;   (global-set-key "\M-a1" 'elscreen-jump)
;;   (global-set-key "\M-a0" 'elscreen-jump)
;;   (global-set-key "\M-ag" 'elscreen-goto)
;;   (global-set-key "\M-aa" 'elscreen-toggle)
;;   (global-set-key "\M-a\M-a" 'elscreen-toggle)
;;   (global-set-key "\M-an" 'elscreen-next)
;;   (global-set-key "\M-a\M-n" 'elscreen-next)
;;   (global-set-key "\M-ap" 'elscreen-previous)
;;   (global-set-key "\M-a\M-p" 'elscreen-previous)
;;   (global-set-key "\M-ak" 'elscreen-kill)
;;   (global-set-key "\M-a\M-k" 'elscreen-kill)
;;   (global-set-key "\M-ac" 'elscreen-create)
;;   (global-set-key "\M-a\M-c" 'elscreen-create))

;; ;; else (emacs language sensitive editor)
;; (message ";;; modules --> else")
;; (add-to-list 'load-path "~/.elisp/else")
;; (require-if-available 'else-mode)

;; emacs-w3m (web browser)
(message ";;; modules --> emacs-w3m")
;; only use if w3m command is available on system
(when (equal (shell-command "which w3m") 0)
  (kill-buffer "*Shell Command Output*")
  (delete-other-windows)
  (add-to-list 'load-path "~/.elisp/emacs-w3m")
  (when (require-if-available 'w3m)
    (autoload 'w3m "w3m" "Interface for w3m on Emacs." t)
    (autoload 'w3m-browse-url "w3m" "Interface for w3m on Emacs." t)
    (autoload 'w3m-find-file "w3m" "w3m interface function for local file." t)
    (autoload 'w3m-search "w3m-search" "Search QUERY using SEARCH-ENGINE." t)
    (autoload 'w3m-weather "w3m-weather" "Display weather report." t)
    (autoload 'w3m-antenna "w3m-antenna" "Report chenge of WEB sites." t)
    (autoload 'w3m-namazu "w3m-namazu" "Search files with Namazu." t)
    (setq w3m-icon-directory "/usr/share/emacs-w3m/icon")

    ;; turn on cookies
    (setq w3m-use-cookies t)

;;     ;; add new functionality not in this version
;;     (defun w3m-buffer (&optional url charset)
;;       "Render the current buffer.
;; See `w3m-region' for the optional arguments."
;;       (interactive (list (w3m-expand-file-name-as-url (or (buffer-file-name)
;;                                                           default-directory))))
;;       (w3m-region (point-min) (point-max) url charset))

    ;; add new functionality not in this version
    (defun w3m-buffer (&optional buffer)
      "Render the current buffer or BUFFER if given."
      (interactive)
      (when buffer
        (switch-to-buffer buffer))
      (w3m-region (point-min) (point-max)))

    ;; w3m-session (persistent sessions)
    (message ";;; modules --> w3m-session")
    (when (require-if-available 'w3m-session)
      (defun w3m-session-local-hook ()
        (define-key w3m-mode-map "S" 'w3m-session-save)
        (define-key w3m-mode-map "L" 'w3m-session-load))
      (add-hook 'w3m-mode-hook 'w3m-session-local-hook)
      ;;(setq w3m-session-file "~/.w3m-session")
      ;;(setq w3m-session-save-always nil)
      ;;(setq w3m-session-load-always nil)
      ;;(setq w3m-session-show-titles t)
      ;;(setq w3m-session-duplicate-tabs 'ask) ; 'never, 'always, 'ask
      )
    ))

;; ;; eperiodic (periodic table of elements)
;; (message ";;; modules --> eperiodic")
;; (add-to-list 'load-path "~/.elisp/eperiodic")
;; (when (require-if-available 'eperiodic)
;;   (autoload 'eperiodic "eperiodic" "Display the periodic table of elements." t))

;; ;; flash-paren (flash parenthesis)
;; (message ";;; modules --> flash-paren")
;; (when (require-if-available 'flash-paren)
;;   (flash-paren-mode 1))

;; flymake mode
(message ";;; modules --> flymake-mode")
(when (require-if-available 'flymake-mode)
  ;; turn on flymake mode
  (flymake-mode t)
  ;; set key bindings
  ;;(global-set-key [f3] 'flymake-display-err-menu-for-current-line)
  ;;(global-set-key [f4] 'flymake-goto-next-error)
  )
;;(add-hook 'find-file-hook 'flymake-find-file-hook)

;; flyspell (active spell checking)
(message ";;; modules --> flyspell")
(when (require-if-available 'flyspell)
  (autoload 'flyspell-mode "flyspell" "On-the-fly spelling checker." t)
  (setq flyspell-sort-corrections nil)
  (setq flyspell-use-meta-tab nil))

;; ;; folding (folding mode for colapsing text sections)
;; (message ";;; modules --> folding")
;; (when (require-if-available 'folding)
;;   (autoload 'folding-mode "folding" "Folding mode." t)
;;   (autoload 'turn-off-folding-mode "folding" "Folding mode." t)
;;   (autoload 'turn-on-folding-mode  "folding" "Folding mode." t)
;;   (folding-mode-add-find-file-hook)
;;   ;;(setq folding-default-keys-function 'folding-bind-backward-compatible-keys)
;;   (setq folding-default-keys-function 'folding-bind-outline-compatible-keys)
;;   ;;(defun local-folding-bind-keys ()
;;   ;;  (define-key folding-mode-map "\C-cf" 'folding-toggle-show-hide)
;;   ;;  (define-key folding-mode-map "\C-co" 'folding-open-buffer)
;;   ;;  (define-key folding-mode-map "\C-cc" 'folding-whole-buffer))
;;   ;;(setq folding-default-keys-function 'local-folding-bind-keys)
;;   )

;; ;; g-client (google client utilities)
;; (message ";;; modules --> g-client")
;; (add-to-list 'load-path "~/.elisp/g-client")
;; (when (require-if-available 'g)
;;   ;; set email address
;;   (when user-mail-address
;;     (setq g-user-email user-mail-address))
;;   ;; set html handler
;;   (setq g-html-handler 'w3m-buffer)
;;   ;; set curl proxy
;;   ;;(setq g-curl-program "curl -x mwmspproxy.dowjones.net:80")
;;   )

;; ;; highline (line highlighting)
;; (message ";;; modules --> highline")
;; (add-to-list 'load-path "~/.elisp/highline")
;; (when (require-if-available 'highline)
;;    (highline-off))
;; (global-set-key "\C-c\C-a" 'highline-on)
;; (global-set-key "\C-c\C-b" 'highline-off)
;; (global-set-key "\C-c\C-l" 'highline-local-mode)
;; (global-set-key "\C-c\C-d" 'highline-mode-on)
;; (global-set-key "\C-c\C-e" 'highline-mode-off)
;; (global-set-key "\C-c\C-g" 'highline-mode)
;; (global-set-key "\C-c\C-c" 'highline-customize)
;; (global-set-key "\C-c\C-v\C-n" 'highline-view-on)
;; (global-set-key "\C-c\C-v\C-f" 'highline-view-off)
;; (global-set-key "\C-c\C-v\C-t" 'highline-view-mode))

;; hippie-expand (auto complete text)
(message ";;; modules --> hippie-exp")
(when (require-if-available 'hippie-exp)
  (setq hippie-expand-try-functions-list
        '(try-expand-dabbrev
          try-expand-dabbrev-all-buffers
          try-expand-dabbrev-from-kill
          try-complete-file-name-partially
          try-complete-file-name
          try-expand-all-abbrevs
          try-expand-list
          try-expand-line
          try-complete-lisp-symbol-partially
          try-complete-lisp-symbol)))
;; original: (try-complete-file-name-partially try-complete-file-name try-expand-all-abbrevs try-expand-list try-expand-line try-expand-dabbrev try-expand-dabbrev-all-buffers try-expand-dabbrev-from-kill try-complete-lisp-symbol-partially try-complete-lisp-symbol)

;; htmlize (convert buffer to html)
(message ";;; modules --> htmlize")
(require-if-available 'htmlize)

;; ibuffer (buffer switcher)
(message ";;; modules --> ibuffer")
(when (require-if-available 'ibuffer)
  (autoload 'ibuffer "ibuffer" "List buffers." t)
  (add-to-list 'ibuffer-never-show-regexps "^\\*Compile-Log\\*$")
  (add-to-list 'ibuffer-never-show-regexps "^\\*Completions\\*$")
  (add-to-list 'ibuffer-never-show-regexps "^\\*IBuffer\\*$")
  (add-to-list 'ibuffer-never-show-regexps "^\\*Messages\\*$")
  (add-to-list 'ibuffer-never-show-regexps "^\\*JDEE bsh\\*$")
  (add-to-list 'ibuffer-never-show-regexps "^\\*slime-events\\*$")
  (add-to-list 'ibuffer-never-show-regexps "^\\*inferior-lisp\\*$")
  ;; default groups for ibuffer
  (setq ibuffer-saved-filter-groups
        (quote (("default"
                 ("dired" (mode . dired-mode))
                 ("elisp" (mode . emacs-lisp-mode))
                 ("lisp" (mode . lisp-mode))
                 ("c" (mode . c-mode))
                 ("java" (or
                          (mode . java-mode)
                          (mode . jde-mode)))
                 ("ruby" (mode . ruby-mode))
                 ("python" (mode . python-mode))
                 ("perl" (mode . cperl-mode))
                 ("erc" (mode . erc-mode))
                 ("emacs" (or
                           (name . "^\\*scratch\\*$")
                           (name . "^\\*Messages\\*$")))
                 ("calendar" (or
                             (name . "^\\*Calendar\\*$")
                             (name . "^\\*Remind\\*$")
                             (name . "^diary$")))
                 ("gnus" (or
                          (mode . message-mode)
                          (mode . bbdb-mode)
                          (mode . mail-mode)
                          (mode . gnus-group-mode)
                          (mode . gnus-summary-mode)
                          (mode . gnus-article-mode)
                          (name . "^\\.bbdb$")
                          (name . "^\\.newsrc-dribble")))))))
  ;; add hook
  (add-hook 'ibuffer-mode-hook
            (lambda ()
              (ibuffer-switch-to-saved-filter-groups
               "default")))
;;   (add-to-list 'ibuffer-never-show-regexps "^\\*")
;;   (defun local-ibuffer-mode-hook ()
;;     (hl-line-mode 1))
;;   (add-hook 'ibuffer-mode-hook 'local-ibuffer-mode-hook)
;;   (defun local-ibuffer-mode-hook ()
;;     (defvar cycle-buffer-filter-extra
;;       '((and (not (string-match "^\\*.*\\*\\(<[0-9]+>\\)?$" (buffer-name)))
;;              (not (equal "*slime-repl clisp*" (buffer-name))))
;;         cycle-buffer-interesting)
;;       "*List of forms that are evaluated in addition to cycle-buffer-filter for
;; the non-permissive versions of the cycle-buffer commands."))
;;   (add-hook 'ibuffer-mode-hook 'local-ibuffer-mode-hook)
  )

;; icomplete (mini-buffer type ahead syntax completion)
(message ";;; modules --> icomplete")
(when (require-if-available 'icomplete)
  (require-if-available 'icomplete+))

;; ;; icicles (minibuffer input completion and cycling)
;; (when (require-if-available 'icicles)
;;   (icicle-mode t))

;; ido (buffer and file name wildcard searching)
;; adds wildcard name completion to `switch-buffer' and `find-file'
;; i do not like this feature for `find-file'; too hard to open normal/new files
(when (require-if-available 'ido)
  ;;(ido-mode t)
  ;; use in `switch-buffer' mode only
  (ido-mode 'buffer)
  ;; fuzzy matching
  (setq ido-enable-flex-matching t)
  ;; ido bookmark
  (setq enable-recursive-minibuffers t)
  (defun ido-goto-bookmark (bookmark)
    (interactive
     (list (bookmark-completing-read "Goto bookmark" bookmark-current-bookmark)))
    (unless bookmark
      (error "No bookmark specified"))
    (let ((filename (bookmark-get-filename bookmark)))
      (ido-set-current-directory
       (if (file-directory-p filename)
           filename
         (file-name-directory filename)))
      (setq ido-exit 'refresh
            ido-text-init ido-text
            ido-rotate-temp t)
      (exit-minibuffer)))
  (define-key ido-file-dir-completion-map [(meta control ?b)] 'ido-goto-bookmark))

;; ;; igrep (grep like commands)
;; (message ";;; modules --> igrep")
;; (add-to-list 'load-path "~/.elisp/igrep")
;; (when (require-if-available 'igrep)
;;   (autoload 'igrep "igrep"
;;     "*Run `grep' PROGRAM to match EXPRESSION in FILES..." t)
;;   (autoload 'igrep-find "igrep"
;;     "*Run `grep' via `find'..." t)
;;   (autoload 'igrep-visited-files "igrep"
;;     "*Run `grep' ... on all visited files." t)
;;   (autoload 'dired-do-igrep "igrep"
;;     "*Run `grep' on the marked (or next prefix ARG) files." t)
;;   (autoload 'dired-do-igrep-find "igrep"
;;     "*Run `grep' via `find' on the marked (or next prefix ARG) directories." t)
;;   (autoload 'Buffer-menu-igrep "igrep"
;;     "*Run `grep' on the files visited in buffers marked with `>'." t)
;;   (autoload 'igrep-insinuate "igrep"
;;     "*Define `grep' aliases for the corresponding `igrep' commands." t)
;;   (autoload 'grep "igrep"
;;     "*Run `grep' PROGRAM to match EXPRESSION in FILES..." t)
;;   (autoload 'egrep "igrep"
;;     "*Run `egrep'..." t)
;;   (autoload 'fgrep "igrep"
;;     "*Run `fgrep'..." t)
;;   (autoload 'agrep "igrep"
;;     "*Run `agrep'..." t)
;;   (autoload 'grep-find "igrep"
;;     "*Run `grep' via `find'..." t)
;;   (autoload 'egrep-find "igrep"
;;     "*Run `egrep' via `find'..." t)
;;   (autoload 'fgrep-find "igrep"
;;     "*Run `fgrep' via `find'..." t)
;;   (autoload 'agrep-find "igrep"
;;     "*Run `agrep' via `find'..." t))

;; imdb (search imdb)
(when (>= emacs-major-version 22)
  (message ";;; modules --> imdb")
  (require-if-available 'imdb))

;; ispell (spell checking)
(message ";;; modules --> ispell")
(when (require-if-available 'ispell)
  (autoload 'ispell-word "ispell" "Check the spelling of word in buffer." t)
  (autoload 'ispell-region "ispell" "Check the spelling of region." t)
  (autoload 'ispell-buffer "ispell" "Check the spelling of buffer." t)
  (autoload 'ispell-complete-word "ispell" "Look up current word in dictionary and try to complete it." t)
  (autoload 'ispell-change-dictionary "ispell" "Change ispell dictionary." t)
  (autoload 'ispell-message "ispell" "Check spelling of mail message or news post.")
  (setq text-mode-hook '(lambda () (local-set-key "\M-\t" 'ispell-complete-word)))
  (setq tex-mode-hook '(lambda () (local-set-key "\M-\t" 'ispell-complete-word)))
  (setq latex-mode-hook '(lambda () (local-set-key "\M-\t" 'ispell-complete-word)))
  (setq ispell-enable-tex-parser t))

;; ;; longlines (wraps long lines in buffer view only)
;; (message ";;; modules --> longlines")
;; ;; (when (require-if-available 'longlines-mode)
;; ;;   (autoload 'longlines-mode
;; ;;     "longlines.el"
;; ;;     "Minor mode for automatically wrapping long lines." t))
;; (autoload 'longlines-mode
;;   "longlines.el"
;;   "Minor mode for automatically wrapping long lines." t)

;; ;; magpie (acronym expansion)
;; (message ";;; modules --> magpie")
;; (require-if-available 'magpie)

;; migus (mpd music client)
(message ";;; modules --> migus")
(when (>= emacs-major-version 22)
  (add-to-list 'load-path "~/.elisp/mingus")
  (when (require-if-available 'mingus)
    (autoload 'mingus "mingus-stays-home")))

;; ;; outline-magic (outline mode extensions)
;; (message ";;; modules --> outline-magic")
;; (when (require-if-available 'outline-magic)
;;   (add-hook 'outline-mode-hook '(lambda () (require-if-available 'outline-cycle)))
;;   (add-hook 'outline-minor-mode-hook
;;             '(lambda () (require-if-available 'outline-magic)
;;                (define-key outline-minor-mode-map [(f6)] 'outline-cycle))))

;; ;; pabbrev (auto-completion of words as you type)
;; (message ";;; modules --> pabbrev")
;; (when (require-if-available 'pabbrev)
;;   (setq global-pabbrev-mode t))

;; ;; project (project timer)
;; (message ";;; modules --> project")
;; (require-if-available 'project)

;; ps-ccrypt (file encryption support)
(message ";;; modules --> ps-ccrypt")
(require-if-available 'ps-ccrypt)

;; psvn (svn integration)
(message ";;; modules --> psvn")
(when (require-if-available 'psvn)
  ;; ignore whitespace with diff command
  (setq svn-status-default-diff-arguments '("--diff-cmd" "diff" "-x" "-wbBu")))

;; regex-tool (build regular expressions)
(message ";;; modules --> regex-tool")
(require-if-available 'regex-tool)

;; ;; savehist (save mini-buffer history)
;; (message ";;; modules --> savehist")
;; (when (require-if-available 'savehist)
;;   (savehist-load))

;; ;; saveplace (save position in files edited)
;; (message ";;; modules --> saveplace")
;; (when (require-if-available 'saveplace)
;;   (setq-default save-place t))

;; ;; session (save session state)
;; (message ";;; modules --> session")
;; (when (require-if-available 'session)
;;   (add-hook 'after-init-hook 'session-initialize))

;; setnu (line numbers)
(message ";;; modules --> setnu")
(require-if-available 'setnu)
;;   ;; ;; define toggle function
;;   ;; (defun toggle-setnu-mode ()
;;   ;;   (interactive)
;;   ;;   (if setnu-mode
;;   ;;       (setnu-mode -1)
;;   ;;     (setnu-mode 1)))
;;   )

;; split-move (split based buffer movement)
(message ";;; modules --> split-move")
(require-if-available 'split-move)

;; sudoku (sudoku game)
(message ";;; modules --> sudoku")
(require-if-available 'sudoku)

;; ;; sunrise commander (file manager mode)
;; breaks tramp
;; (message ";;; modules --> sunrise-commander")
;; (require-if-available 'sunrise-commander)

;; table (formats text tables)
(message ";;; modules --> table")
(when (require-if-available 'table)
  (add-hook 'text-mode-hook 'table-recognize)
  (setq table-html-table-attribute
        "cellpadding=\"2\"")
  (setq table-html-th-rows 1))

;; ;; template (file templates)
;; (message ";;; modules --> template")
;; (when (require-if-available 'template)
;;   (template-initialize))

;; timeclock (track time intervals)
(message ";;; modules --> timeclock")
(when (require-if-available 'timeclock)
  ;;(timeclock-modeline-display)
  (global-set-key "\C-xti" 'timeclock-in)
  (global-set-key "\C-xto" 'timeclock-out)
  (global-set-key "\C-xtc" 'timeclock-change)
  (global-set-key "\C-xtr" 'timeclock-reread-log)
  (global-set-key "\C-xtu" 'timeclock-update-modeline)
  (global-set-key "\C-xtw" 'timeclock-when-to-leave-string)
  (global-set-key "\C-xtv" 'timeclock-visit-timelog)
  (global-set-key "\C-xts" 'timeclock-status-string)
  (global-set-key "\C-xtd" 'timeclock-modeline-display)
  (global-set-key "\C-xtg" 'timeclock-generate-report))

;; tramp (edit remote files)
(message ";;; modules --> tramp")
(if (>= emacs-major-version 22)
    (when (require-if-available 'tramp)
      (setq tramp-default-method "ssh")
      (add-to-list 'tramp-default-method-alist '("\\`localhost\\'" "\\`root\\'" "su")))
  (progn
    (add-to-list 'load-path "~/.elisp/tramp")
    (require-if-available 'tramp)
    (when (load "tramp" t)
      (setq auto-save-file-name-transforms
            `(("\\`/[^/]*:\\(.+/\\)*\\(.*\\)"
               ,(expand-file-name "\\2" temporary-file-directory)))))))

;; tramp find-file-root command
(message ";;; modules --> tramp: find-file-root")
(when (require-if-available 'tramp)
  ;; find file as root
  ;; prefix
  (defvar find-file-root-prefix
    (if (featurep 'xemacs) "/[sudo/root@localhost]" "/sudo:root@localhost:" )
    "*The filename prefix used to open a file with `find-file-root'.")
  ;; seperate command history
  (defvar find-file-root-history nil
    "History list for files found using `find-file-root'.")
  ;; hook
  (defvar find-file-root-hook nil
    "Normal hook for functions to run after finding a \"root\" file.")
  ;; find file root
  (defun find-file-root ()
    "*Open a file as the root user.
\nPrepends `find-file-root-prefix' to the selected file name so
that it maybe accessed via the corresponding tramp method."
    (interactive)
    (require 'tramp)
    ;; bind the variable `file-name-history' locally so there is a separate
    ;; history list for "root" files
    (let* ((file-name-history find-file-root-history)
           (name (or buffer-file-name default-directory))
           (tramp (and (tramp-tramp-file-p name) (tramp-dissect-file-name name)))
           path dir file)
      ;; when called from a "root" file, fix up the path
      (when tramp
        (setq path (tramp-file-name-path tramp)
              dir (file-name-directory path)))
      ;; ask for file name
      (when (setq file (read-file-name "Find file (root): " dir path))
        (if (and ido-mode (or (eq ido-mode 'file) (eq ido-mode 'both)))
            (ido-find-file (concat find-file-root-prefix file))
          (find-file (concat find-file-root-prefix file)))
        ;; if this all succeeded, save our new history list
        (setq find-file-root-history file-name-history)
        ;; allow some user customization
        (run-hooks 'find-file-root-hook))))

  ;; find alternative file as root
  (defun find-alternative-file-root ()
    (interactive)
    (when buffer-file-name
      (find-alternate-file
       (concat "/sudo:root@localhost:"
               buffer-file-name))))

  ;; find file as root or find alternative file as root
  (defun find-file-root-or-find-alternative-file-root ()
    "If current buffer is read-only, run `file-alternative-file-root',
otherwise run `find-file-root'."
    (interactive)
    (if buffer-read-only
        (find-alternative-file-root)
      (find-file-root)))
  )

;; ;; twit (twitter mode)
;; (message ";;; modules --> twit")
;; (require-if-available 'twit)

;; ;; uniquify (better duplicate buffer naming)
;; (message ";;; modules --> uniquify")
;; (when (require-if-available 'uniquify)
;;   ;;(setq uniquify-buffer-name-style 'reverse)
;;   ;;(setq uniquify-separator "/")
;;   (setq uniquify-after-kill-buffer-p t)
;;   (setq uniquify-ignore-buffers-re "^\*"))

;; wtf (acronym lookup)
(message ";;; modules --> wtf")
(require-if-available 'wtf)

(message ";;; modules --> End")

;;==============================================================================
;;; End of File
;;==============================================================================