(require 'windresize)
(global-set-key (kbd "C-c C-r")         'windresize) ; Split Buffer Groesse Aendern

(require 'windmove)
(windmove-default-keybindings 'super)
(setq windmove-wrap-around t)

(defun other-window-or-switch-buffer ()
  "Call `other-window' if more than one window is visible, switch
to next buffer otherwise."
  (interactive)
  (if (one-window-p)
      (switch-to-buffer nil)
    (other-window 1)))

(global-set-key (kbd "M-o")             'other-window-or-switch-buffer)

(global-set-key (kbd "C-o")             'other-window-or-switch-buffer)

(defun flip-windows ()
  "Rotate your windows"
  (interactive)
  (cond ((not (> (count-windows)1))
         (message "You can't rotate a single window!"))
        (t
         (setq i 1)
         (setq numWindows (count-windows))
         (while  (< i numWindows)
           (let* (
                  (w1 (elt (window-list) i))
                  (w2 (elt (window-list) (+ (% i numWindows) 1)))
                  (b1 (window-buffer w1))
                  (b2 (window-buffer w2))
                  (s1 (window-start w1))
                  (s2 (window-start w2))
                  )
             (set-window-buffer w1  b2)
             (set-window-buffer w2 b1)
             (set-window-start w1 s2)
             (set-window-start w2 s1)
             (setq i (1+ i)))))))

(if (display-graphic-p)
(global-set-key (kbd "M-O")             'flip-windows)
)

(autoload 'vala-mode "vala-mode" "Major mode for editing Vala code." t)
(add-to-list 'auto-mode-alist '("\\.vala$" . vala-mode))
(add-to-list 'auto-mode-alist '("\\.vapi$" . vala-mode))
(add-to-list 'file-coding-system-alist '("\\.vala$" . utf-8))
(add-to-list 'file-coding-system-alist '("\\.vapi$" . utf-8))

(autoload 'python-mode "python-mode" "Major mode for python scripts" t)

(add-hook
 'python-mode-hook
 (function
  (lambda()
    (local-set-key  [delete] 'py-electric-delete)
    (setq-default indent-tabs-mode nil)
    (setq mode-name "PY")
    (outline-minor-mode 0) ;; turn off outline here. /FIXME/: find out where it's turned on!
    )))

(setq auto-mode-alist
      (append '(("\\.\\(py\\)$"  . python-mode))
              auto-mode-alist))

(autoload 'cperl-mode "cperl-mode" "alternate perl mode" t)
(defalias 'perl-mode 'cperl-mode)

(setq cperl-indent-left-aligned-comments nil)
(setq cperl-comment-column 32)
(setq cperl-hairy t)
(setq cperl-electric-linefeed t)
(setq cperl-electric-keywords t)
(setq cperl-electric-parens t)
(setq cperl-electric-parens-string nil)

(setq perl-run-out-buffer "*Async Shell Command*")

(defun perl-kill ()
  "get rid of hanging perl compile or run buffers"
  (interactive)
  (delete-windows-on perl-run-out-buffer)
  (kill-buffer perl-run-out-buffer))

(defun perl-run (switches parameters prefix)
  "execute current perl buffer"
  (interactive "sPerl-switches:\nsParameter:\nP")
  (let ((file buffer-file-name))
    (if (eq prefix nil)
        (shell-command (concat "perl " switches " " file " " parameters "&"))
      (shell-command (concat "perl -wc " switches " " file " " parameters "&")))
    (save-excursion
      (set-buffer perl-run-out-buffer)
      (setq perl-error-fontified nil
            perl-error-start nil
            perl-error-end nil)
      (goto-char (point-min)))
    ))

(defun perl-next-error ()
  "jump to next perl run error, if any"
  (interactive)
  (let (line
        errorfile
        (window (get-buffer-window (buffer-name)))
        (file buffer-file-name)
        (buffer (buffer-name))
        )
    (select-window (display-buffer perl-run-out-buffer))
    (set-buffer perl-run-out-buffer)
    (if (eq perl-error-fontified t)
        (progn
          (set-text-properties perl-error-start perl-error-end ())
          (setq perl-error-fontified nil)
          )
      )
    (if (re-search-forward (concat "at \\([-a-zA-Z:0-9._~#/\\]*\\) line \\([0-9]*\\)[.,]") (point-max) t)
        ()
      (goto-char (point-min))
      (message "LAST ERROR, jumping to first")
      (re-search-forward (concat "at \\([-a-zA-Z:0-9._~#/\\]*\\) line \\([0-9]*\\)[.,]") (point-max) t)
      )
    (recenter)
    (set-text-properties (match-beginning 1)
                         (match-end 2)
                         (list 'face font-lock-keyword-face))
    (setq perl-error-fontified t
          perl-error-start (match-beginning 1)
          perl-error-end (match-end 2)
          errorfile (buffer-substring
                     (match-beginning 1)
                     (match-end 1))
          line (string-to-int (buffer-substring
                               (match-beginning 2)
                               (match-end 2))))
    (select-window window)
    (find-file errorfile)
    (goto-line line)))

(defun own-cperl-indent-region-or-paragraph (start end)
  (interactive "r")
  (if mark-active
      (cperl-indent-region start end)
    (save-excursion
      (mark-paragraph)
      (cperl-indent-region (point) (mark t))
      )))

(add-hook
 'cperl-mode-hook
 (function
  (lambda()
    (make-variable-buffer-local 'perl-error-fontified)
    (make-variable-buffer-local 'perl-error-start)
    (make-variable-buffer-local 'perl-error-end)
    (make-variable-buffer-local 'perl-old-switches)
    (make-variable-buffer-local 'perl-old-parameters)
    (local-set-key "\C-hF" 'cperl-info-on-current-command)
    (local-set-key "\C-hf" 'describe-function)
    (local-set-key "\C-hV" 'cperl-get-help)
    (local-set-key "\C-hv" 'describe-variable)
    (local-set-key "\C-cr" 'perl-run)
    (local-set-key [f5]          'perl-run) ;F5 perl-run
    (local-set-key [f6]          'perl-kill) ;F6 perl-kill
    (local-set-key "\C-ck" 'perl-kill)
    (local-set-key "\C-c#" 'perl-next-error)
    (local-set-key "\M-\C-q" 'own-cperl-indent-region-or-paragraph)
    (setq mode-name "PL")
    )))

(autoload 'enable-paredit-mode "paredit" "Turn on pseudo-structural editing of Lisp code." t)

(add-hook 'emacs-lisp-mode-hook       #'enable-paredit-mode)
(add-hook 'eval-expression-minibuffer-setup-hook #'enable-paredit-mode)
(add-hook 'ielm-mode-hook             #'enable-paredit-mode)
(add-hook 'lisp-mode-hook             #'enable-paredit-mode)
(add-hook 'lisp-interaction-mode-hook #'enable-paredit-mode)
(add-hook 'scheme-mode-hook           #'enable-paredit-mode)
(add-hook 'slime-repl-mode-hook (lambda () (paredit-mode +1)))

(defalias 'pe        'paredit-mode)

(eval-after-load 'paredit
  '(progn
     ;; force my own bindings for those
     (define-key paredit-mode-map (kbd "C-d") nil)
     (define-key paredit-mode-map (kbd "<M-up>") nil)
     (define-key paredit-mode-map (kbd "<M-down>") nil)))

(require 'etags-select)

(defun etags-create (dir-name)
  "Create tags file."
  (interactive "DDirectory: ")
  (let* ((ctags "/usr/bin/ctags-exuberant")
         (odir  (directory-file-name dir-name))
         (ofile (concat odir "/TAGS"))
         (langs "lisp,python,perl,c,c++,shell")
         (shell-command
          (format "%s -f %s -e -R --languages=%s %s" ctags ofile langs odir))
         (visit-tags-table ofile))))

(global-set-key (kbd "€")               'etags-select-find-tag-at-point) ; alt-right + e: jump to tag definition

(defun etags-find ()
  "Find a tag using ido"
  (interactive)
  (tags-completion-table)
  (let (tag-names)
    (mapatoms (lambda (x)
                (push (prin1-to-string x t) tag-names))
              tags-completion-table)
    (etags-select-find (ido-completing-read "Tag: " tag-names))))

(defalias 'ec        'etags-create)
(defalias 'ef        'etags-find)

(setq sgml-set-face t)
(setq sgml-balanced-tag-edit t)
(setq sgml-omittag-transparent nil)
(setq sgml-auto-insert-required-elements t)

(setq sgml-markup-faces
      '((start-tag . font-lock-function-name-face)
        (end-tag . font-lock-function-name-face)
        (comment . font-lock-comment-face)
        (pi . font-lock-other-type-face)
        (sgml . font-lock-variable-name-face)
        (doctype . font-lock-type-face)
        (entity . font-lock-string-face)
        (shortref . font-lock-keyword-face)))

(require 'web-mode)

(add-to-list 'auto-mode-alist '("\\.phtml\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.tpl\\.php\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.[agj]sp\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.as[cp]x\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.erb\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.mustache\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.djhtml\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode))

(defun tvd-web-mode-hook ()
  "Hooks for Web mode."
  (setq web-mode-markup-indent-offset 2)
  (setq web-mode-css-indent-offset 2)
  (setq web-mode-code-indent-offset 2)
  (setq web-mode-style-padding 1)
  (setq web-mode-script-padding 1)
  (setq web-mode-block-padding 0)
  (setq web-mode-enable-auto-pairing t)
  (setq web-mode-enable-auto-expanding t))
(add-hook 'web-mode-hook  'tvd-web-mode-hook)

(defun html-insert-p()
  (interactive)
  (web-mode-element-wrap "p"))

(defun html-insert-li()
  (interactive)
  (web-mode-element-wrap "li"))

(defun html-insert-ul()
  (interactive)
  (web-mode-element-wrap "ul"))

(defun html-insert-b()
  (interactive)
  (web-mode-element-wrap "b"))

(defun html-listify (beg end)
  (interactive "r")
  (save-excursion
    (let* ((lines (split-string (buffer-substring beg end) "\n" t)))
      (delete-region beg end)
      (insert "<ul>\n")
      (while lines
        (insert "  <li>")
        (insert (pop lines))
        (insert "</li>\n"))
      (insert "</ul>\n")
      )))

(autoload 'cisco-mode "cisco-mode" "Major mode for CISCO configs" t)
(setq auto-mode-alist
      (append '(("\\.\\(cfg\\)$"  . cisco-mode))
              auto-mode-alist))

(autoload 'markdown-mode "markdown-mode"
  "Major mode for editing Markdown files" t)

(add-to-list 'auto-mode-alist '("\\.text\\'"     . markdown-mode))
(add-to-list 'auto-mode-alist '("\\.markdown\\'" . markdown-mode))
(add-to-list 'auto-mode-alist '("\\.md\\'"       . markdown-mode))

(add-hook 'markdown-mode-hook
          (lambda ()
            (when buffer-file-name
              (add-hook 'after-save-hook
                        'check-parens
                        nil t))
            (modify-syntax-entry ?\" "\"" markdown-mode-syntax-table)
            ))

(require 'pod-mode)
(require 'cc-mode)

(add-to-list 'auto-mode-alist '("\\.pod$" . pod-mode))
(add-hook 'pod-mode-hook 'font-lock-mode)

(defun tvd-outline-emphasize(CHAR)
  "expand once if no region and apply emphasize CHAR"
  (interactive)
  (unless (use-region-p)
    (er/expand-region 1))
  (save-excursion
    (goto-char (region-beginning))
    (insert (format "%c<" CHAR))
    (goto-char (region-end))
    (insert ">")))

(defun pod-bold()
  "bold text in outline mode"
  (interactive)
  (tvd-outline-emphasize ?B))

(defun pod-italic()
  "italic text in outline mode"
  (interactive)
  (tvd-outline-emphasize ?I))

(defun pod-code()
  "verbatim text in outline mode"
  (interactive)
  (tvd-outline-emphasize ?C))

(add-hook 'pod-mode-hook
          (lambda ()
            ;; POD contains headers and I'm used to outlining if there are headers
            ;; so, enable outlining
            (setq outline-heading-alist '(("=head1" . 1)
                                          ("=head2" . 2)
                                          ("=head3" . 3)
                                          ("=head4" . 4)))
            (outline-minor-mode)

            ;; my own abbrevs for POD using mode-specific abbrev table
            (c-define-abbrev-table 'pod-mode-abbrev-table '(
                                                            ("ov" "=over\n\n=item\n\n=back\n")
                                                            ("h1" "=head1 ")
                                                            ("h2" "=head2 ")
                                                            ("h3" "=head3 ")
                                                            ("h4" "=head4 ")
                                                            ("b"  "B<>")
                                                            ("c"  "C<>")
                                                            ("l"  "L<>")
                                                            ("i"  "I<>")
                                                            ("e"  "E<>")
                                                            ("f"  "F<>"))
                                   "POD mode abbreviations, see .emacs"
                                   )
            (abbrev-table-put pod-mode-abbrev-table :case-fixed t)
            (abbrev-table-put pod-mode-abbrev-table :system t)

            ;; enable abbreviations
            (setq local-abbrev-table pod-mode-abbrev-table
                  abbrev-mode t)

            ;; POD easy formatting
            (local-set-key (kbd "C-c b") 'pod-bold)
            (local-set-key (kbd "C-c /") 'pod-italic)
            (local-set-key (kbd "C-c c") 'pod-code)
            ))

(defun tvd-disarm-conf-mode()
  (local-set-key  (kbd "C-c C-c") 'comment-or-uncomment-region-or-line)
  (electric-indent-local-mode 0))

(add-something-to-mode-hooks '(conf cisco fundamental conf-space pod) 'tvd-disarm-conf-mode)

(require 'config-general-mode)

(add-hook 'config-general-mode-hook 'electric-indent-mode)

(add-hook 'config-general-mode-hook 'outline-minor-mode)

(require 'expand-region)
(global-set-key (kbd "C-0")             'er/expand-region) ; C-= without pressing shift on DE keyboard

(require 'mark-copy-yank-things-mode)
(mark-copy-yank-things-global-mode)

(define-key mark-copy-yank-things-mode-map (kbd "C-c")   'mcyt-copy-map)
(define-key mark-copy-yank-things-mode-map (kbd "M-a")   'mcyt-mark-map)

(advice-add 'mcyt--copy-thing
            :after
            '(lambda (&rest args)
               (with-temp-buffer
                 (yank)
                 (copy-to-register 'c (point-min) (point-max)))))

(defun tvd-insert-c-register ()
  (interactive)
  (insert-register 'c))

(global-set-key (kbd "C-v")             'tvd-insert-c-register)

(defun tvd-mcyt-copy-euro (&optional arg)
  "Copy  euro  at point  into  kill-ring  and convert  to  german
punctuation"
  (interactive "P")
  (mcyt--blink-and-copy-thing 'mcyt-beginning-of-ip 'mcyt-end-of-ip arg)
  (with-temp-buffer
    (yank)
    (beginning-of-buffer)
    (while (re-search-forward "\\." nil t)
      (replace-match ","))
    (kill-region (point-min) (point-max))))

(eval-after-load "mark-copy-yank-things-mode"
  '(progn
     (add-hook 'mark-copy-yank-things-mode-hook
               (lambda () ;; g like [G]eld
                 (define-key mcyt-copy-map (kbd "g") 'tvd-mcyt-copy-euro)))))

(require 'change-inner)

(defun tvd-ci (beg end &optional ins)
  "change-inner simulator which works with symbols instead of strings.

BEG and END must be executable elisp symbols moving (point). Everything
in between will be killed. If INS is non-nil, it will be inserted then."
  (interactive)
  (let ((B nil))
    (funcall beg)
    (setq B (point))
    (funcall end)
    (kill-region B (point))
    (when ins
      (insert ins))))

(defun tvd-ci-comment ()
  "\"change inner\" a whole comment [block]."
  (interactive)
  (tvd-ci 'mcyt-beginning-of-comment-block
          'mcyt-end-of-comment-block
          (format "%s;# " comment-start)))

(defun tvd-ci-quote ()
  "\"change inner\" quoted text."
  (interactive)
  (tvd-ci 'mcyt-beginning-of-quote
          'mcyt-end-of-quote))

(defun tvd-ci-word ()
  "\"change inner\" a word (like cw in vi)."
  (interactive)
  (tvd-ci 'mcyt-beginning-of-symbol
          'mcyt-end-of-symbol))

(defun tvd-ci-line ()
  "\"change inner\" a whole line."
  (interactive)
  (tvd-ci 'beginning-of-line
          'end-of-line))

(defun tvd-ci-paragraph ()
  "\"change inner\" a whole paragraph."
  (interactive)
  (tvd-ci 'backward-paragraph
          'forward-paragraph))

(defun tvd-ci-buffer ()
  "\"change inner\" a whole buffer."
  (interactive)
  (tvd-ci 'point-min
          'point-max))

(defun tvd-ci-sexp ()
  "\"change inner\" a whole sexp."
  (interactive)
  (er/mark-inside-pairs)
  (call-interactively 'kill-region))

(define-prefix-command 'ci-map)
(global-set-key (kbd "→") 'ci-map)

(define-key ci-map (kbd "→") 'change-inner) ;; <A-i A-i>

(define-key ci-map (kbd "c") 'tvd-ci-comment) ;; <A-i c>
(define-key ci-map (kbd "¢") 'tvd-ci-comment) ;; <A-i A-c>

(define-key ci-map (kbd "q") 'tvd-ci-quote) ;; <A-i q>
(define-key ci-map (kbd "@") 'tvd-ci-quote) ;; <A-i A-q>

(define-key ci-map (kbd "w") 'tvd-ci-word) ;; <A-i w>
(define-key ci-map (kbd "ł") 'tvd-ci-word) ;; <A-i A-w>

(define-key ci-map (kbd "l") 'tvd-ci-line) ;; <A-i l>

(define-key ci-map (kbd "s") 'tvd-ci-sexp) ;; <A-i s>
(define-key ci-map (kbd "ſ") 'tvd-ci-sexp) ;; <A-i A-s>

(define-key ci-map (kbd "p") 'tvd-ci-paragraph) ;; <A-i p>
(define-key ci-map (kbd "þ") 'tvd-ci-paragraph) ;; <A-i A-p>

(define-key ci-map (kbd "a") 'tvd-ci-buffer) ;; <A-i a>
(define-key ci-map (kbd "æ") 'tvd-ci-buffer) ;; <A-i A-a>

(autoload 'rotate-text "rotate-text" nil t)
(autoload 'rotate-text-backward "rotate-text" nil t)

(setq rotate-text-words '(("width" "height")
                          ("left" "right" "top" "bottom")
                          ("ja" "nein")
                          ("off" "on")
                          ("true" "false")
                          ("nil" "t")
                          ("yes" "no")))

(global-unset-key (kbd "C-t"))

(add-something-to-mode-hooks
 '(c c++ cperl vala web emacs-lisp python ruby)
 '(lambda ()
    (local-set-key (kbd "C-t") 'rotate-text)))

(add-something-to-mode-hooks '(tex text eww) 'visual-line-mode)

(setq word-wrap t)

(require 'viking-mode)
(viking-global-mode)
(setq viking-greedy-kill nil)
(define-key viking-mode-map (kbd "M-d") 'viking-repeat-last-kill)

(require 'htmlize)
(setq htmlize-output-type "inline-css")

(require 'iedit)

(global-set-key (kbd "C-c C-e")           'iedit-mode)

(setq tvd-buffer-undo-list nil)
(advice-add 'iedit-mode :before '(lambda (&rest args) ;; save current
                                   (setq tvd-buffer-undo-list buffer-undo-list)))

(advice-add 'iedit-mode :after '(lambda (&rest args) ;; restore previously saved
                                  (setq buffer-undo-list tvd-buffer-undo-list)))

(require 'eshell)

(defmacro with-face (str &rest properties)
  `(propertize ,str 'face (list ,@properties)))

(defun shk-eshell-prompt ()
  (let ((header-bg "Azure"))
    (concat
     (with-face "\n")
     (with-face (format-time-string
                 "[%Y-%m-%d %H:%M] --- ["
                 (current-time)) :background header-bg :foreground "Black")
     (with-face (concat (eshell/pwd) "") :background header-bg :foreground "Blue")
     (with-face "] --- " :background header-bg :foreground "Black")
     (with-face  (or
                  (ignore-errors (format "(%s)" (vc-responsible-backend default-directory)))
                  "") :background header-bg)
     (with-face "\n" :background header-bg)
     (with-face user-login-name :foreground "blue")
     "@"
     (with-face "localhost" :foreground "blue")
     (if (= (user-uid) 0)
         (with-face " #" :foreground "red")
       " $")
     " ")))

(setq eshell-prompt-function 'shk-eshell-prompt)
(setq eshell-highlight-prompt nil)

(defun log-comment ()
  (with-current-buffer (get-buffer-create "*LOG*")
    (insert (format "# %s\n" (time-stamp-string)))))

(defun log-insert (string)
  (with-current-buffer (get-buffer-create "*LOG*")
    (delete-region (point-min) (point-max))
    (log-comment)
    (insert string)
    (message "wrote output to *LOG* buffer")))

(defun log-append (string)
  (with-current-buffer (get-buffer-create "*LOG*")
    (end-of-buffer)
    (newline)
    (log-comment)
    (insert string)
    (message "wrote output to *LOG* buffer")))

(add-to-list 'eshell-virtual-targets '("/dev/log" (lambda (mode)
                                              (if (eq mode 'overwrite)
                                                  'log-insert
                                                'log-append))
                                      t
                                      ))

(eval-after-load "eshell"
  '(progn
     (add-hook 'eshell-mode-hook
               (lambda ()
                 (local-unset-key (kbd "C-c C-r")) ; we're already using this for windresize
                 (add-to-list 'eshell-visual-commands "tail")
                 (add-to-list 'eshell-visual-commands "top")
                 (add-to-list 'eshell-visual-commands "vi")
                 (add-to-list 'eshell-visual-commands "ssh")
                 (add-to-list 'eshell-visual-commands "tail")
                 (add-to-list 'eshell-visual-commands "mutt")
                 (add-to-list 'eshell-visual-commands "note")
                 (setenv "TERM" "xterm")
                 (local-set-key (kbd "C-l") 'eshell/clear)
                 (define-key viking-mode-map (kbd "C-d") nil) ;; need to undef C-d first
                 (local-set-key (kbd "C-d") 'eshell/x)
                 (setq mode-name "ESH"
                       eshell-hist-ignoredups t
                       eshell-history-size 5000
                       eshell-where-to-jump 'begin
                       eshell-review-quick-commands nil
                       eshell-smart-space-goes-to-end t
                       eshell-scroll-to-bottom-on-input 'all
                       eshell-error-if-no-glob t
                       eshell-save-history-on-exit t
                       eshell-prefer-lisp-functions t)))))

(defun eshell/x (&rest args)
  (interactive)
  (eshell-life-is-too-much)
  (define-key viking-mode-map (kbd "C-d") 'viking-kill-thing-at-point))

(defun eshell/emacs (&rest args)
  "Editor commands fired from eshell will be handled by emacs, which already runs anyway."
  (interactive)
  (let* ((framesize (frame-width))
         (winsize (window-body-width)))
    (progn
      (if (eq winsize framesize)
          (split-window-horizontally))
      (other-window 1)
      (if (null args)
          (bury-buffer)
        (mapc #'find-file (mapcar #'expand-file-name (eshell-flatten-list (reverse args))))))))

(defun eshell/clear ()
  "Better clear  command than (recenter  0) which doesn't work  as I
want.  This version really removes  the output of previous commands
and puts the shell to the beginning of a really (then) empty eshell
buffer. However,  just to be sure  that I do no  accidentally clear
some  shell output  that might  be useful  in the  future, it  also
copies   the   cleared   stuff   into   a   backup   buffer   named
*eshell-log-buffer*, just in case."
  (interactive)
  (let ((beg (point-min))
        (end (point-max))
        (savebuffer "*eshell-log-buffer*")
        (log (buffer-substring-no-properties (point-min) (point-max))))
    (progn
      (if (not (get-buffer savebuffer))
          (get-buffer-create savebuffer))
      (with-current-buffer savebuffer
        (goto-char (point-max))
        (insert log))
      (delete-region beg end)
      (eshell-emit-prompt))))

(defun eshell/perldoc (&rest args)
  "Like `eshell/man', but invoke `perldoc'."
  (funcall 'eshell/perldoc (apply 'eshell-flatten-and-stringify args)))

(defun eshell/perldoc (man-args)
  (interactive "sPerldoc: ")
  (require 'man)
  (let ((manual-program "perldoc"))
    (man man-args)))

(defun eshell-here ()
  "Opens up a new shell in the directory associated with the
current buffer's file. The eshell is renamed to match that
directory to make multiple eshell windows easier."
  (interactive)
  (let* ((parent (if (buffer-file-name)
                     (file-name-directory (buffer-file-name))
                   default-directory))
         (height (/ (window-total-height) 3))
         (name   (car (last (split-string parent "/" t)))))
    (split-window-vertically (- height))
    (other-window 1)
    (eshell "new")
    (rename-buffer (concat "*eshell: " name "*"))
    (insert (concat "ls"))
    (eshell-send-input)))

(defun eshell-there (host)
  "Opens a shell on a remote host using tramp."
  (interactive "sHost: ")
  (let ((default-directory (format "/%s:" host)))
    (eshell host)))

(defalias 'es        'eshell-here)
(defalias 'et        'eshell-there)
(defalias 'eshell/vi 'eshell/emacs)

(require 'em-smart)

(setq eshell-command-aliases-list ())

(defun +alias (al cmd)
  "handy wrapper function to convert alias symbols
to alias strings to avoid writing 4 quotes per alias.
AL is a single-word symbol naming the alias, CMD is
a list symbol describing the command."
  (add-to-list 'eshell-command-aliases-list
               (list (symbol-name al)
                     (mapconcat 'symbol-name cmd " "))))

(+alias 'l      '(ls -laF $*))
(+alias 'll     '(ls -l $*))
(+alias 'la     '(ls -a $*))
(+alias 'lt     '(ls -ltr $*))
(+alias '..     '(cd ..))
(+alias '...    '(cd ../..))
(+alias '....   '(cd ../../..))
(+alias '.....  '(cd ../../../..))
(+alias 'md     '(mkdir -p $*))
(+alias 'emacs  '(find-file $1))
(+alias 'less   '(find-file-read-only $1))
(+alias 'x      '(eshell/exit))

(setenv "PAGER" "cat")

(defun tvd-get-code()
  "helper: returns marked region or the whole buffer contents"
  ;; /FIXME/: mv to string helpers?
  (if mark-active
      (let (  ;; save region and buffer
            (partb (buffer-substring-no-properties (region-beginning) (region-end)))
            (whole (buffer-substring-no-properties (point-min) (point-max)))
            )
        (if (> (length partb) 0)
            partb
          whole
          )
        )
    ;; no mark, also return everything
    (buffer-substring-no-properties (point-min) (point-max))))

(defun tvd-send-region-to-repl ()
  "put region or buffer into elisp repl and eval"
  (interactive)
  (let ( ;; fetch region or buffer contents
        (code  (tvd-get-code)))
    (progn
      (if (not (get-buffer "*ielm*"))
          ;; ielm not yet running, start it in split window but stay here
          (progn
            (split-window-horizontally)
            (other-window 1)
            (ielm)
            (other-window 1)))
      ;; finially, paste content into ielm and evaluate it
      ;; still we stay where we are
      (with-current-buffer "*ielm*"
        (goto-char (point-max))
        (insert code)
        (ielm-return)))))

(defun tvd-elisp-eval()
  "just eval region or buffer whatever feasible"
  (interactive)
  (progn
    (if mark-active
        (eval-region)
      (eval-buffer))))

(defun ff ()
  "Jump to function definition at point."
  (interactive)
  (find-function-other-window (symbol-at-point)))

(defun tvd-make-defun-links ()
  "experimental: make function calls clickable, on click, jump to definition of it"
  (interactive)
  (let ((beg 0)
        (end 0)
        (fun nil))
    (goto-char (point-min))
    (while (re-search-forward "(tvd[-a-z0-9]*" nil t)
      (setq end (point))
      (re-search-backward "(" nil t)
      (forward-char 1)
      (setq beg (point))
      (setq fun (buffer-substring-no-properties beg end))
      (make-button beg end 'action
                   (lambda (x)
                     (find-function-other-window (symbol-at-point))))
      (goto-char end))))

(defun emacs-change-log (entry)
  "Add a changelog entry to .emacs Changelog"
  (interactive "Menter change log entry: ")
  (save-excursion
    (beginning-of-buffer)
    (re-search-forward ";; .. Changelog")
    (next-line)
    (forward-paragraph)
    (insert (format ";;    - %s\n" entry))))

(add-hook 'emacs-lisp-mode-hook
          (lambda()
            ;; non-separated x-e == eval hidden, aka current buffer
            (local-set-key (kbd "C-x C-e")  'tvd-elisp-eval)
            ;; separate 'e' == separate buffer
            (local-set-key (kbd "C-x e")    'tvd-send-region-to-repl)
            (setq mode-name "EL"
                  show-trailing-whitespace t)
            (eldoc-mode t)
            ))

(add-hook 'comint-mode-hook
          (lambda()
            (define-key comint-mode-map [up] 'comint-previous-input)))

(defalias 'ee        'eval-expression)

(defalias 'er        'eval-region)

(defalias 'ef        'eval-defun)

(font-lock-add-keywords
 'emacs-lisp-mode
 '(("(\\s-*\\(eq\\|if\\|cond\\|and\\|set\\|or\\|not\\|when\\|setq\\|let**\\|lambda\\|kbd\\|defun\\|car\\|cdr\\)\\s-+"
    1 'font-lock-keyword-face)))

(font-lock-add-keywords
 'emacs-lisp-mode
 '(("'[-a-zA-Z_][-a-zA-Z0-9_]*\\>" 0 'font-lock-constant-face)))

(defun dev ()
  "Open a new emacs frame with some development peripheral buffers."
  (interactive)
  (let ((F (new-frame)))
    (with-selected-frame F
      (with-current-buffer (get-buffer-create "*Help*")
        (help-mode))
      (with-current-buffer (get-buffer-create "*ielm*")
        (ielm))
      (with-current-buffer (get-buffer-create "*suggest*")
        (suggest))
      (switch-to-buffer "*ielm*")
      (split-window-horizontally)
      (split-window-vertically)
      (windmove-down)
      (switch-to-buffer "*suggest*")
      (tvd-suggest-reload)
      (tvd-suggest-reload)
      (calculator)
      (windmove-right)
      (switch-to-buffer "*Help*")
      (split-window-vertically)
      (windmove-down)
      (switch-to-buffer "*scratch*")
      (set-window-dedicated-p (selected-window) t)
      (set-background-color "azure"))))

(require 'el2markdown)

(setq tramp-default-method "ssh")
(setq tramp-default-user nil)

(require 'org)

(require 'org-bullets)

(require 'ob-python)
(require 'ob-perl)
(require 'ob-sh)

(setq org-bullets-bullet-list '("►" "✜" "✸" "✿" "♦"))

(if (null tvd-win-home)
    (setq tvd-org-file (concat tvd-lisp-dir "/notizen.org")
          org-attach-directory (concat tvd-lisp-dir "/attachments"))
  (setq tvd-org-file (concat tvd-win-home "/notizen.org")
        org-attach-directory (concat tvd-win-home "/attachments")))

(defun tvd-org-emphasize(CHAR)
  "expand once if no region and apply emphasize CHAR"
  (interactive)
  (unless (region-active-p)
    (er/expand-region 1))
  (org-emphasize CHAR))

(defun bold()
  "bold text in org mode"
  (interactive)
  (tvd-org-emphasize '42))

(defun italic()
  "italic text in org mode"
  (interactive)
  (tvd-org-emphasize '47))

(defun code()
  "verbatim text in org mode"
  (interactive)
  (tvd-org-emphasize '126))

(defun underline()
  "underline text in org mode"
  (interactive)
  (tvd-org-emphasize '95))

(defun tvd-org-left-or-level-up()
  "jump one word to the left if not on a org heading,
otherwise fold current level and jump one level up."
  (interactive)
  (if (and (org-at-heading-p) (looking-at "*"))
      (progn
        (hide-subtree)
        (outline-up-heading 1))
    (left-word)))

(defun tvd-org-heading-up()
  "If on a heading, fold current heading, jump one level
up and unfold it, otherwise jump paragraph as usual."
  (interactive)
  (if (and (org-at-heading-p) (looking-at "*"))
      (progn
        (hide-subtree)
        (org-backward-heading-same-level 1)
        (org-cycle))
    (backward-paragraph)))

(defun tvd-org-heading-down()
  "If on a heading, fold current heading, jump one level
down and unfold it, otherwise jump paragraph as usual."
  (interactive)
  (if (and (org-at-heading-p) (looking-at "*"))
      (progn
        (hide-subtree)
        (org-forward-heading-same-level 1)
        (org-cycle))
    (forward-paragraph)))

(eval-after-load "org"
  '(progn
     (add-hook 'org-mode-hook
               (lambda ()
                 (setq
                  org-M-RET-may-split-line nil
                  org-agenda-files (list tvd-org-file)
                  org-agenda-restore-windows-after-quit t
                  org-blank-before-new-entry (quote ((heading . auto) (plain-list-item . auto)))
                  org-catch-invisible-edits (quote error)
                  org-columns-default-format "%80ITEM %22Timestamp %TODO %TAGS %0PRIORITY"
                  org-insert-heading-always-after-current (quote t)
                  org-mouse-1-follows-link nil
                  org-remember-store-without-prompt t
                  org-reverse-note-order t
                  org-startup-indented t
                  org-startup-truncated nil
                  org-return-follows-link t
                  org-use-speed-commands t
                  org-yank-adjusted-subtrees t
                  org-refile-targets '((nil . (:maxlevel . 5)))
                  org-refile-use-outline-path t
                  org-outline-path-complete-in-steps nil
                  org-completion-use-ido t
                  org-support-shift-select t
                  org-hide-emphasis-markers t
                  org-fontify-done-headline t
                  org-pretty-entities t
                  org-confirm-babel-evaluate nil)
                                        ; shortcuts
                 (setq org-speed-commands-user
                       (quote (
                               ("0" . ignore)
                               ("1" . delete-other-windows)
                               ("2" . ignore)
                               ("3" . ignore)
                               ("d" . org-archive-subtree-default-with-confirmation) ; delete, keep track
                               ("v" . org-narrow-to-subtree) ; only show current heading ("view")
                               ("q" . widen) ; close current heading and show all ("quit")
                               (":" . org-set-tags-command) ; add/edit tags
                               ("t" . org-todo) ; toggle todo type, same as C-t
                               ("z" . org-refile) ; archive the (sub-)tree
                               ("a" . org-attach) ; manage attachments
                               )))
                                        ; same as toggle
                 (local-set-key (kbd "C-t") 'org-todo)

                                        ; alt-enter = insert new subheading below current
                 (local-set-key (kbd "<M-return>") 'org-insert-subheading)

                                        ; search for tags (ends up in agenda view)
                 (local-set-key (kbd "C-f") 'org-tags-view)

                                        ; run presenter, org-present must be installed and loadedwhite
                 (local-set-key (kbd "C-p") 'org-present)

                                        ; todo colors
                 (setq org-todo-keyword-faces '(
                                                ("TODO"   . (:foreground "#b70101"     :weight bold))
                                                ("START"  . (:foreground "blue"        :weight bold))
                                                ("WAIT"   . (:foreground "darkorange"  :weight bold))
                                                ("DONE"   . (:foreground "forestgreen" :weight bold))
                                                ("CANCEL" . (:foreground "red"         :weight bold))
                                                ))

                 (local-set-key (kbd "C-c b") 'bold)
                 (local-set-key (kbd "C-c /") 'italic)
                 (local-set-key (kbd "C-c c") 'code)
                 (local-set-key (kbd "C-c _") 'underline)

                                        ; edit babel src block in extra buffer:
                                        ; default is C-c ' which is hard to type
                                        ; brings me to src code editor buffer
                                        ; Also note: enter <s then TAB inserts a code block
                                        ; Next, C-c C-c executes the code, adding :results table at the
                                        ; end of the begin line, creates a table of the output
                 (local-set-key (kbd "C-c C-#") 'org-edit-special)

                                        ; faster jumping
                 (local-set-key (kbd "<C-up>")   'tvd-org-heading-up)
                 (local-set-key (kbd "<C-down>") 'tvd-org-heading-down)

                                        ; move word left or heading up, depending where point is
                 (local-set-key (kbd "<C-left>") 'tvd-org-left-or-level-up)

                                        ; use nicer bullets
                 (org-bullets-mode 1))

               (org-babel-do-load-languages
                'org-babel-load-languages
                '((python     . t)
                  (emacs-lisp . t)
                  (shell      . t)
                  (perl       . t)
                  ))
                 )))

(setq org-ellipsis " ⤵")

(setq org-todo-keywords
      '((sequence "TODO" "START" "WAIT" "|" "DONE" "CANCEL")))

(global-set-key (kbd "C-n")             (lambda () (interactive) (org-capture)))

(global-set-key (kbd "C-c C-#")         'org-edit-src-exit)

(setq org-default-notes-file tvd-org-file
      org-startup-indented t
      org-indent-indentation-per-level 4)

(setq org-capture-templates
      '(("n" "Project" entry (file+headline tvd-org-file "Unsorted Tasks")
         "* TODO %^{title}\n%u\n** Kostenstelle\n** Contact Peer\n**Contact Customer\n**ARS\n**Daten\n** Notizen\n  %i%?\n")

        ("j" "Journal" entry (file+headline tvd-org-file "Kurznotizen")
         "* TODO %^{title}\n%u\n  %i%?\n" :prepend t)

        ("c" "Copy/Paste" entry (file+headline tvd-org-file "Kurznotizen")
         "* TODO %^{title}\n%u\n  %x\n" :immediate-finish t :prepend t)))

(if (fboundp 'eww-browse-url)
    (setq browse-url-browser-function 'eww-browse-url))

(advice-add 'org-narrow-to-subtree :after
            '(lambda (&rest args)
               (set-face-attribute 'fringe nil :background tvd-fringe-narrow-bg)))

(defalias 'table     'orgtbl-mode)

(defun tablify (regex)
  "Convert a whitespace separated column list into
an org mode table and enable orgtbl-mode. You can
specify another regex for cell splitting."
  (interactive "MConvert [region] to table with regex ([\t\s]+): ")
  (let ((spc "[\t\s]+"))
    (when (string= regex "")
      (setq regex spc))
    (delete-trailing-whitespace)
    (if (org-region-active-p)
        (org-table-convert-region (region-beginning) (region-end) regex)
      (org-table-convert-region (point-min) (point-max) regex))
    (when (not (eq major-mode 'org-mode))
      (orgtbl-mode))))

(defun sort-table-numeric ()
  "sort org table numerically by current column"
  (interactive)
  (org-table-sort-lines nil ?n))

(defun sort-table-numeric-desc ()
  "reverse sort org table numerically by current column"
  (interactive)
  (org-table-sort-lines nil ?N))

(defun sort-table-alphanumeric ()
  "sort org table charwise by current column"
  (interactive)
  (org-table-sort-lines nil ?a))

(defun sort-table-alphanumeric-desc ()
  "reverse sort org table charwise by current column"
  (interactive)
  (org-table-sort-lines nil ?A))

(defun sort-table-time ()
  "sort org table by times by current column"
  (interactive)
  (org-table-sort-lines nil ?t))

(defun sort-table-time-desc ()
  "reverse sort org table by times by current column"
  (interactive)
  (org-table-sort-lines nil ?T))

(defalias 'stn       'sort-table-numeric)
(defalias 'stnd      'sort-table-numeric-desc)
(defalias 'sta       'sort-table-alphanumeric)
(defalias 'stad      'sort-table-alphanumeric-desc)
(defalias 'stt       'sort-table-time)
(defalias 'sttd      'sort-table-time-desc)

(defun tvd-export-org-table (fmt)
  "export an org table using format FMT"
  (interactive)
  (let ((efile "/tmp/org-table-export.tmp")
        (ebuf (format "*table-%s*" fmt)))
    (when (file-exists-p efile)
      (delete-file efile))
    (org-table-export efile (format "orgtbl-to-%s" fmt))
    (other-window 1)
    (if (not (eq (get-buffer ebuf) nil))
        (kill-buffer (get-buffer ebuf)))
    (set-buffer (get-buffer-create ebuf))
    (insert-file-contents efile)
    (switch-to-buffer ebuf)
    (delete-file efile)))

(defun table-to-csv ()
  "export current org table to CSV format"
  (interactive)
  (tvd-export-org-table "csv"))

(defun table-to-latex ()
  "export current org table to LaTeX format"
  (interactive)
  (tvd-export-org-table "latex"))

(defun table-to-html ()
  "export current org table to HTML format"
  (interactive)
  (tvd-export-org-table "html"))

(defun table-to-csv-tab ()
  "export current org table to CSV format, separated by <tab>"
  (interactive)
  (tvd-export-org-table "tsv"))

(defun table-to-aligned ()
  "export current org table to space-aligned columns format"
  (interactive)
  (tvd-export-org-table "csv")
  (with-current-buffer "*table-csv*"
    (align-regexp (point-min) (point-max) "\\(\\s-*\\)," 1 1 t)
    (while (re-search-forward " ," nil t)
      (replace-match "    "))))

(defalias 'ttc      'table-to-csv)
(defalias 'ttl      'table-to-latex)
(defalias 'tth      'table-to-html)
(defalias 'ttt      'table-to-csv-tab)
(defalias 'tta      'table-to-aligned)

(defun tvd-beginning-of-cell (&optional arg)
  "move (point) to the beginning of a org mode table cell"
  (interactive)
  (if  (re-search-backward "|" (line-beginning-position) 3 1)
      (forward-char)))

(defun tvd-end-of-cell (&optional arg)
  "move (point) to the end of a org mode table cell"
  (interactive)
  (if  (re-search-forward "|" (line-end-position) 3 1)
      (backward-char)))

(defun tvd-copy-org-table-cell(&optional arg)
  "Copy an org mode table cell to the kill ring using MCYT"
  (interactive "P")
  (mcyt--blink-and-copy-thing 'tvd-beginning-of-cell 'tvd-end-of-cell arg))

(defun org-table-goto-col-beginning ()
  "Go to beginning of current column and return `point'."
  (interactive)
  (assert (org-table-p) "Not in org-table.")
  (org-table-align)
  (let ((col (org-table-current-column)))
    (goto-char (org-table-begin))
    (org-table-goto-column col))
  (point))

(defun org-table-col-beginning ()
  "Return beginning position of current column."
  (save-excursion
    (org-table-goto-col-beginning)))

(defun org-table-goto-col-end ()
  "Goto end of current column and return `point'."
  (interactive)
  (assert (org-table-p) "Not in org-table.")
  (org-table-align)
  (let ((col (org-table-current-column)))
    (goto-char (1- (org-table-end)))
    (org-table-goto-column col)
    (skip-chars-forward "^|"))
  (point))

(defun org-table-col-end ()
  "Return end position of current column."
  (save-excursion
    (org-table-goto-col-end)))

(defun org-table-select-col ()
  "Select current column."
  (interactive)
  (set-mark (org-table-col-beginning))
  (org-table-goto-col-end)
  (rectangle-mark-mode))

(defun org-table-copy-col ()
  "Copy current column."
  (interactive)
  (org-table-select-col)
  (sit-for 0.2 t)
  (copy-rectangle-as-kill (org-table-col-beginning) (org-table-col-end)))

(eval-after-load "org"
  '(progn
     (add-hook 'org-mode-hook
               (lambda ()
                 (local-set-key (kbd "C-c o") 'org-table-copy-col)
                 (local-set-key (kbd "C-c t") 'tvd-copy-org-table-cell)))))

(require 'org-present)
(require 'darkroom) ;; hides distractions

(defun slide-return-to-present ()
  "wherever we are, go back to slideshow"
  (interactive)
  (switch-to-buffer-other-window "*slide*")
  (delete-other-windows))

(defun slide-split-to-past ()
  "split slide show and show previous buffer next to it"
  (interactive)
  (split-window-horizontally)
  (other-window 1)
  (if (get-buffer "*eshell*")
      ;; if there's no eshell running, start it, otherwise switch to it
      (switch-to-buffer "*eshell*")
    (eshell)))

(eval-after-load "org-present"
  '(progn
     (add-hook 'org-present-mode-hook
               (lambda ()
                 (org-present-big)
                 (org-display-inline-images)
                 (org-present-hide-cursor)
                 (org-present-read-only)

                 ;; some opticals
                 (setq org-hide-emphasis-markers t)
                 (font-lock-add-keywords 'org-mode
                                         '(("^ +\\([-*]\\) "
                                            (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "•"))))))
                 ;; keys
                 (define-key org-present-mode-keymap [down]    'org-present-next)
                 (define-key org-present-mode-keymap [up]      'org-present-prev)
                 (define-key org-present-mode-keymap (kbd "q") 'org-present-quit)
                 (global-set-key (kbd "C-c p") 'slide-return-to-present) ; used inside eshell to return to slide
                 (define-key org-present-mode-keymap (kbd "s") 'slide-split-to-past)
                 (setq current-buffer (buffer-name)) ; remember slide buffer name
                 (rename-buffer "*slide*")
                 ;;(darkroom-tentative-mode)
                 ))

     (add-hook 'org-present-mode-quit-hook
               (lambda ()
                 (org-present-small)
                 (org-remove-inline-images)
                 (org-present-show-cursor)
                 (org-present-read-write)
                 (setq org-hide-emphasis-markers nil)
                 (rename-buffer current-buffer)
                 (global-unset-key (kbd "C-c p"))
                 ;;(darkroom-tentative-mode)
                 ))))

(defun slide-header (prefix)
  (interactive "P")
  (save-excursion
    (if (eq prefix nil)
        ()
      (goto-char (point-min)))
    (insert "\n* ORG-MODE slide show commands

  | Key   | Command                                                    |
  +-------+------------------------------------------------------------+
  | C-p   | start slide show                                           |
  | q     | stop slide show                                            |
  | s     | slit window and switchto or start eshell                   |
  | C-c p | while in split mode, return to full screen slide show      |
  | C-c r | enter window resize mode, use cursor keys, <ret> to finish |
  | C--   | (CTRL and minus) shrink font size                          |
  | C-+   | (CTRL and plus) increase font size                         |

")))

(require 'outshine)

(add-hook 'outline-minor-mode-hook 'outshine-hook-function)

(add-hook 'emacs-lisp-mode-hook '(lambda ()
                                   (outline-minor-mode)))

(make-variable-buffer-local 'tvd-headings)

(defun tvd-outshine-get-level (heading)
  "Return level of HEADING as number, or nil"
  (if (string-match " \\(*+\\) " heading) ; normal outline heading
      (length (match-string 1 heading))
    (when (string-match "^;;\\(;+\\) " heading) ; else look for elisp heading
      (length (match-string 1 heading)))))

(defun tvd-outshine-cl-heading (heading)
  (let ((regex (cadar outshine-imenu-preliminary-generic-expression)))
    (when (string-match regex heading)
      (match-string-no-properties 1 heading))))

(defun tvd-outshine-parse-headings ()
  "extract outshine headings of current buffer"
  (interactive)
  (let ((line nil))
    (save-excursion
      (setq tvd-headings ())
      (beginning-of-buffer)
      (while (not (eobp))
        (setq line (tvd-get-line))
        (when (outline-on-heading-p t)
          (add-to-list 'tvd-headings (cons (tvd-outshine-cl-heading line) (point))))
        (forward-line)))))

(defun tvd-outshine-sparse-tree ()
  "expand outline tree from current position as sparse tree"
  (interactive)
  (let ((done nil)
        (pos (point))
        (tree (list (list (point) 5)))
        (l 0))
    (while (not done)
      (outline-up-heading 1)
      (setq l (tvd-outshine-get-level (tvd-get-line)))
      (add-to-list 'tree (list (point) l))
      (when (eq l 1)
        (setq done t)))
    (outline-hide-other)
    (dolist (pos tree)
      (goto-char (car pos))
      (outline-cycle))))

(defun tvd-outshine-jump ()
  "jump to an outshine heading with IDO prompt,
update heading list if neccessary."
  (interactive)
  (let ((heading nil))
    (when (or (not tvd-headings)
              (buffer-modified-p))
      (tvd-outshine-parse-headings))
    (if (not tvd-headings)
        (message "Current buffer doesn't contain any outshine headings!")
      (setq heading (ido-completing-read "Jump to heading: " (tvd-alist-keys tvd-headings)))
      (when heading
        (show-all)
        (goto-char (cdr (assoc heading tvd-headings)))
        (tvd-outshine-sparse-tree)))))

(eval-after-load "outline"
  '(progn
     (add-hook 'outline-minor-mode-hook
               (lambda ()
                 (defalias 'j    'tvd-outshine-jump)
                 (defalias 'jump 'tvd-outshine-jump)
                 (define-key outline-minor-mode-map (kbd "C-c C-j")  'tvd-outshine-jump)
                 (setq outshine-org-style-global-cycling-at-bob-p t
                       outshine-use-speed-commands t
                       outshine-speed-commands-user
                       (quote (
                               ("v" . outshine-narrow-to-subtree)
                               ("q" . widen)
                               )))))))

(advice-add 'outshine-narrow-to-subtree :before
            (lambda (&rest args) (unless (outline-on-heading-p t)
                                   (outline-previous-visible-heading 1))))

(defun outshine-to-org ()
  (interactive)
  (outorg-convert-to-org)
  (org-mode))

(defun outshine-to-html (file)
  (interactive
   (list
    (read-file-name "HTML output file: "
                    (expand-file-name "~/D/github/dot-emacs")
                    "emacs.html")))
  (let ((B (current-buffer)))
    (with-temp-buffer
      (insert-buffer-substring B)
      ;; remove 'sk spacings for smaller <pre>'s
      (tvd-replace-all ")\s*;" ") ;")
      ;; highlight at least a little
      (tvd-replace-all "/FIXME/" "/FIXME/")
      (emacs-lisp-mode)
      (outshine-to-org)
      (org-export-to-file 'html file))))

(defun export ()
  "Export .emacs to git, do not use."
  ;; /FIXME/: generate version number, add last changelog to git
  (interactive)
  (outshine-to-html "~/D/github/dot-emacs/emacs.html")
  (shell-command "cp ~/.emacs ~/D/github/dot-emacs/")
  (shell-command "cd ~/D/github/dot-emacs && git ci +fixes .emacs emacs.html")
  (shell-command "cd ~/D/github/dot-emacs && git push"))

(defun tvd-outline-left-or-level-up()
  "jump one word to the left if not on a heading,
otherwise fold current level and jump one level up."
  (interactive)
  (if (outline-on-heading-p)
      (progn
        (hide-subtree)
        (outline-up-heading 1))
    (left-word)))

(defun tvd-outline-heading-up()
  "fold current heading, jump one level up and unfold it"
  (interactive)
  (if (not (outline-on-heading-p))
      (backward-paragraph)
    (hide-subtree)
    (outline-backward-same-level 1)
    (outline-cycle)))

(defun tvd-outline-heading-down()
  "fold current heading, jump one level down and unfold it"
  (interactive)
  (if (not (outline-on-heading-p))
      (forward-paragraph)
    (hide-subtree)
    (outline-forward-same-level 1)
    (outline-cycle)))

(defun tvd-outline-jump (part)
  "Jump interactively to next header containing PART using search."
  (interactive "Mjump to: ")
  (let ((done nil)
        (pwd (point)))
    (beginning-of-buffer)
    (outline-show-all)
    (when (re-search-forward (format "^;; \\*+.*%s" part) (point-max) t)
      (when (outline-on-heading-p)
        (beginning-of-line)
        (setq done t)))
    (when (not done)
      (message (format "no heading with '%s' found" part))
      (goto-char pwd))))

(eval-after-load "outline"
  '(progn
     (add-hook 'outline-minor-mode-hook
               (lambda ()
                 ;; narrowing, we use outshine functions, it's loaded anyway
                 (defalias 'n 'outshine-narrow-to-subtree)
                 (defalias 'w 'widen)
                 (define-key outline-minor-mode-map (kbd "<C-up>")   'tvd-outline-heading-up)
                 (define-key outline-minor-mode-map (kbd "<C-down>") 'tvd-outline-heading-down)
                 (define-key outline-minor-mode-map (kbd "<C-left>") 'tvd-outline-left-or-level-up)))))

(advice-add 'outshine-narrow-to-subtree :after
            '(lambda (&rest args)
               (set-face-attribute 'fringe nil :background tvd-fringe-narrow-bg)))

(require 'narrow-indirect)
(defalias 'nf 'ni-narrow-to-defun-indirect-other-window)
(defalias 'nr 'ni-narrow-to-region-indirect-other-window)

(defun tvd-narrowed-fringe-status ()
  "Make the fringe background reflect the buffer's narrowing status."
  (set-face-attribute
   'fringe nil :background (if (buffer-narrowed-p)
                               tvd-fringe-narrow-bg
                             nil)))

(add-hook 'post-command-hook 'tvd-narrowed-fringe-status)

(defadvice term-sentinel (around tvd-advice-term-sentinel (proc msg))
  (if (memq (process-status proc) '(signal exit))
      (let ((buffer (process-buffer proc)))
        ad-do-it
        (kill-buffer buffer))
    ad-do-it))
(ad-activate 'term-sentinel)

(defun tvd-term-use-utf8 ()
  (set-buffer-process-coding-system 'utf-8-unix 'utf-8-unix))
(add-hook 'term-exec-hook 'tvd-term-use-utf8)

(defun tvd-term-paste (&optional string)
                      (interactive)
                      (process-send-string
                       (get-buffer-process (current-buffer))
                       (if string string (current-kill 0))))

(defun tvd-term-hook ()
  (goto-address-mode)
  (define-key term-raw-map (kbd "C-y") 'tvd-term-paste)
  (define-key term-raw-map (kbd "C-c C-d") 'kill-this-buffer)
  (define-key term-raw-map (kbd "C-d") 'kill-this-buffer)
  (define-key term-raw-map (kbd "C-c C-l") 'term-line-mode)
  (define-key term-raw-map (kbd "C-k")
    (lambda ()
      (interactive)
      (term-send-raw-string "\C-k")
      (kill-line))))
(add-hook 'term-mode-hook 'tvd-term-hook)

(defun term-with-args (new-buffer-name cmd &rest switches)
  (setq term-ansi-buffer-name (concat "*" new-buffer-name "*"))
  (setq term-ansi-buffer-name (generate-new-buffer-name term-ansi-buffer-name))
  (setq term-ansi-buffer-name (apply 'make-term term-ansi-buffer-name cmd nil switches))
  (set-buffer term-ansi-buffer-name)
  (term-mode)
  (term-char-mode)
  (message "Line mode: C-c C-l, Char mode: C-c C-k, Exit: C-c C-d")
  (switch-to-buffer term-ansi-buffer-name))

(defun iperl ()
  "interactive perl (via perlbrew if exist or global)"
  (interactive)
  (let ((perlbrew (expand-file-name "~/perl5/perlbrew/bin/perlbrew")))
    (if (file-exists-p perlbrew)
        (term-with-args "*perlbrew-de0*" perlbrew "exec" "--" "perl" "-de0")
      (term-with-args "*perl-de0*" "perl" "-de0"))))

(defun iruby ()
  "interactive ruby"
  (interactive)
  (term-with-args "*ruby-irb*" "irb"))

(defun ipython ()
  "interactive python"
  (interactive)
  (setenv "PYTHONSTARTUP" (expand-file-name "~/.pythonrc"))
  (term-with-args "*python-i*" "python" "-i"))

(defun icalc ()
  "interactive calc"
  (interactive)
  (term-with-args "*calc*" (expand-file-name "~/bin/calc")))

(require 'puppet-mode)

(require 'novel-mode)
(global-set-key (kbd "C-c C-n")         'novel-mode)

(autoload 'macro-math-eval-and-round-region "macro-math" t nil)
(autoload 'macro-math-eval-region "macro-math" t nil)

(global-set-key (kbd "C-x C-0")         'macro-math-eval-region)

(setq slimehelper (expand-file-name "~/quicklisp/slime-helper.el"))

(if (file-exists-p slimehelper)
    (progn
      (load slimehelper)

      ;; Replace "sbcl" with the path to your implementation
      (setq inferior-lisp-program "sbcl")

      ;; Stop SLIME's REPL from grabbing DEL,
      ;; which is annoying when backspacing over a '('
      (defun override-slime-repl-bindings-with-paredit ()
        (define-key slime-repl-mode-map
          (read-kbd-macro paredit-backward-delete-key) nil))
      (add-hook 'slime-repl-mode-hook 'override-slime-repl-bindings-with-paredit)))

(defun info-find-file (file)
  (interactive "f")
  (info-setup file
              (pop-to-buffer-same-window
               (format "*info*<%s>"
                       (file-name-sans-extension
                        (file-name-nondirectory file))))))

(eval-after-load "Info"
  '(progn
     (define-key Info-mode-map (kbd "<C-left>")  'Info-history-back)
     (define-key Info-mode-map (kbd "<C-right>") 'Info-history-forward)))

(defalias 'c         'quick-calc)

(require 'elmacro)
(elmacro-mode)

(setq tvd-macro-name "last-macro")

(add-to-list 'elmacro-unwanted-commands-regexps "^(mouse.*)$")
(add-to-list 'elmacro-unwanted-commands-regexps "^(tvd-start-or-stop-macro)$")

(defun tvd-get-macro-name()
  "Ask for a macro name, check for duplicates.
If the given name is already defined, ask again (and again until unique).
If a buffer with the given name exists, kill it (that is, the buffer is
there but has not been saved or evaluated yet). Return the name as string."
  (interactive)
  (let ((done nil)
        (name nil)
        (mbuf nil)
        (err ""))
    (while (not done)
      (setq name (read-string (format "%s - enter macro name (last-macro): " err) nil nil "last-macro"))
      (if (fboundp (intern name))
          (setq err (format "macro '%s is already defined" name))
        (setq mbuf (format "* elmacro - %s *" name))
        (if (get-buffer mbuf)
            (with-current-buffer mbuf
              (kill-buffer mbuf)))
        (setq done t)))
    name))

(defun tvd-get-exec-macro-name()
  "Ask for a macro name to be executed"
  (interactive)
  (let ((macros ())
        (N 1)
        (S nil)
        (T ""))
    (dolist (entry (cdr (assoc tvd-macro-file load-history )))
      (setq S (cdr entry))
      (setq T (symbol-name S))
      (push (list T N) macros)
      (setq N (1+ N)))
    (completing-read "enter macro name: " macros nil t nil)))

(defun tvd-start-or-stop-macro()
  "start macro or stop if started"
  (interactive)
  (if (eq defining-kbd-macro nil)
      (progn
        (elmacro-clear-command-history)
        (start-kbd-macro nil)
        (message "Recording macro. Finish with <shift-F6> ..."))
    (progn
      (call-interactively 'end-kbd-macro)
      (setq tvd-macro-name (tvd-get-macro-name))
      (elmacro-show-last-macro tvd-macro-name)
      (message "Recording done. Execute with <C-F6>, save or <C-x C-e> buffer..."))))

(defun tvd-exec-last-macro(&optional ARG)
  "execute last macro (or ARG, if given) repeatedly after every
<ret>, abort with C-g or q, and repeat until EOF after pressing a.

If macro defun is known (i.e. because you evaluated the elmacro buffer
containing the generated defun), it will be executed. Otherwise the
last kbd-macro will be executed."
  (interactive)
  (let ((melm-count 0)
        (melm-all nil)
        (melm-abort nil)
        (melm-beg (eobp))
        (melm-code (or ARG tvd-macro-name)))
    (if (eobp)
        (if (yes-or-no-p "(point) is at end of buffer. Jump to top?")
            (goto-char (point-min))))
    (while (and (not melm-abort)
                (not (eobp)))
       (when (not melm-all)
         (message (concat
                   (format
                    "Executing last macro '%s (%d). Keys:\n"  melm-code melm-count)
                   "<enter>      repeat once\n"
                   "a            repeat until EOF\n"
                   "e            enter macro name to execute\n"
                   "<C-g> or q   abort ..\n "))
         (setq K (read-event))
         (cond ((or (eq K 'return) (eq K 'C-f6)) t)
               ((equal (char-to-string K) "q") (setq melm-abort t))
               ((equal (char-to-string K) "a") (message "Repeating until EOF")(setq melm-all t))
               ((equal (char-to-string K) "e") (setq tvd-macro-name (tvd-get-exec-macro-name)))
               (t (setq melm-abort t))))
       (if (not melm-abort)
           (progn
             (if (fboundp (intern melm-code))
                 (call-interactively (intern melm-code))
               (call-interactively 'call-last-kbd-macro))
             (setq melm-count (1+ melm-count)))))
    (if (and (eq melm-count 0) (eq (point) (point-max)))
        (message "(point) is at end of buffer, aborted")
      (message (format "executed '%s %d times" melm-code melm-count)))))

(global-set-key (kbd "<f6>")            'tvd-start-or-stop-macro)
(global-set-key (kbd "<C-f6>")          'tvd-exec-last-macro)

(setq tvd-macro-file (concat tvd-lisp-dir "/macros.el"))

(if (file-exists-p tvd-macro-file)
    (load-file tvd-macro-file))

(defun tvd-macro-store()
  "store current macro to emacs config"
  (interactive)
  (copy-region-as-kill (point-min) (point-max))
  (if (not (get-buffer "macros.el"))
      (find-file tvd-macro-file))
  (with-current-buffer "macros.el"
    (goto-char (point-max))
    (newline)
    (insert ";;")
    (newline)
    (insert (format ";; elmacro added on %s" (current-time-string)))
    (newline)
    (yank)
    (newline)
    (save-buffer))
  (switch-to-buffer nil)
  (delete-window))

(defalias 'ms        'tvd-macro-store)

(defun tvd-macro-gen-repeater-and-save()
  "generate repeater and save the defun's
Runs when (point) is at 0,0 of generated
defun."
  (next-line)
  (goto-char (point-max))
  (newline)
  (insert (format "(defun %s-repeat()\n" tvd-macro-name))
  (insert "  (interactive)\n")
  (insert (format "  (tvd-exec-last-macro \"%s\"))\n" tvd-macro-name))
  (newline)
  (eval-buffer)
  (tvd-macro-store))

(advice-add 'elmacro-show-defun :after '(lambda (&rest args)
                                          (tvd-macro-gen-repeater-and-save)))

(require 'eww)

(defun eww-render-current-buffer ()
  "Render HTML in the current buffer with EWW"
  (interactive)
  (beginning-of-buffer)
  (eww-display-html 'utf8 (buffer-name)))

(defalias 'render-html 'eww-render-current-buffer)

(add-hook 'eww-mode-hook #'toggle-word-wrap)
(add-hook 'eww-mode-hook #'visual-line-mode)

(define-key eww-mode-map "o" 'eww) ; aka other page
(define-key eww-mode-map "f" 'eww-browse-with-external-browser) ; aka firefox
(define-key eww-mode-map "j" 'next-line)
(define-key eww-mode-map "r" 'eww-reload)
(define-key eww-mode-map "s" 'shr-save-contents)
(define-key eww-mode-map "v" 'eww-view-source)
(define-key eww-mode-map "b" 'eww-add-bookmark)
(define-key eww-mode-map "p" 'eww-back-url)
(define-key eww-mode-map "n" 'eww-forward-url)

(define-key eww-link-keymap "c" 'shr-copy-url)
(define-key eww-link-keymap "s" 'shr-save-contents)

(require 'tablist)

(define-key tablist-minor-mode-map (kbd "q") nil)
(define-key tablist-minor-mode-map (kbd "q") 'tvd-close-window)

(defun tvd-close-window ()
  (interactive)
  (kill-this-buffer)
  (delete-window))

(eval-after-load "tabulated-list"
  '(progn
     (add-hook 'tabulated-list-mode-hook
               (lambda ()
                 (tablist-minor-mode)
                 (local-set-key (kbd "Q") 'delete-other-windows)
                 (hl-line-mode)))))

(eval-after-load "Help"
  '(progn
     (add-hook 'help-mode-hook
               (lambda ()
                 (local-set-key (kbd "q") 'tvd-close-window)
                 (local-set-key (kbd "x") 'quit-window)
                 (local-set-key (kbd "p") 'help-go-back)
                 (local-set-key (kbd "b") 'help-go-back)
                 (local-set-key (kbd "n") 'help-go-forward)
                 (local-set-key (kbd "f") 'help-go-forward)
                 ))))

(require 'suggest) ;; depends on dash, s, f, loop

(defun tvd-suggest-reload ()
  "Clear suggest buffer and re-paint it."
  (interactive)
  (let ((inhibit-read-only t))
    (erase-buffer)
    (suggest--insert-heading suggest--inputs-heading)
    (insert "\n\n\n")
    (suggest--insert-heading suggest--outputs-heading)
    (insert "\n\n\n")
    (suggest--insert-heading suggest--results-heading)
    (insert "\n")
    (suggest--nth-heading 1)
    (forward-line 1)))

(defun tvd-suggest-jump ()
  "Jump between input and output suggest buffer."
  (interactive)
  (forward-line -1)
  (if (eq (line-number-at-pos) 1)
      (suggest--nth-heading 2)
    (suggest--nth-heading 1))
  (forward-line 1))

(eval-after-load "suggest"
  '(progn
     (add-hook 'suggest-mode-hook
               (lambda ()
                 (local-set-key (kbd "C-l") 'tvd-suggest-reload)
                 (local-set-key (kbd "<tab>") 'tvd-suggest-jump)))))

(show-paren-mode 1)

(setq show-paren-style 'mixed)

(require 'fic-mode)
(add-something-to-mode-hooks '(c c++ cperl vala web emacs-lisp ruby python) 'turn-on-fic-mode)

(require 'undo-tree)

(global-undo-tree-mode)

(global-set-key (kbd "C-:")             'undo-tree-redo) ; C-: == REDO   C-_ == UNDO

(safe-wrap
 (progn
   (require 'smex)
   (smex-initialize)
   (global-set-key (kbd "M-x") 'smex)
   (global-set-key (kbd "M-X") 'smex-major-mode-commands))
 (message "ignoring unsupported smex"))

(add-something-to-mode-hooks
    '(c c++ cperl vala makefile ruby shell-script python)
    'which-func-mode)

(require 'fringe-current-line)
(global-fringe-current-line-mode 1)

(set-face-attribute 'fringe nil :foreground "NavyBlue")

(require 'recentf)
(require 'cl-lib)
(setq recentf-auto-cleanup 'never) ;; avoid stat() on tramp buffers
(recentf-mode 1)

(setq recentf-max-menu-items 200
      recentf-max-menu-items 30)

(defun tvd-buffer-exists-p (bufname)
  (not (eq nil (get-file-buffer bufname))))

(defun recentf-ido-find-file ()
  "Find a recent file using ido."
  (interactive)
  (let ((file (ido-completing-read
               "Choose recent file: "
               (cl-remove-if 'tvd-buffer-exists-p recentf-list) nil t)))
    (when file
      (find-file file))))

(global-set-key (kbd "C-x C-r")         'recentf-ido-find-file) ; open recent files, same as M-x rf

(defun undo-kill-buffer (arg)
  "Re-open the last buffer killed.  With ARG, re-open the nth buffer."
  (interactive "p")
  (let ((recently-killed-list (copy-sequence recentf-list))
        (buffer-files-list
         (delq nil (mapcar (lambda (buf)
                             (when (buffer-file-name buf)
                               (expand-file-name (buffer-file-name buf)))) (buffer-list)))))
    (mapc
     (lambda (buf-file)
       (setq recently-killed-list
             (delq buf-file recently-killed-list)))
     buffer-files-list)
    (find-file
     (if arg (nth arg recently-killed-list)
       (car recently-killed-list)))))

(setq recentf-exclude (list "ido.last"
                            "/elpa/"
                            ".el.gz$"
                            '(not (file-readable-p))
                            ))

(ido-mode t)
(ido-everywhere nil)
(setq ido-enable-flex-matching t)
(setq ido-use-filename-at-point nil)
(setq ido-use-virtual-buffers t)
(setq ido-auto-merge-work-directories-length -1)

(defvar tvd-ido-disabled nil)
(advice-add 'ido-write-file :before '(lambda (&rest args) (ido-mode 0) (setq tvd-ido-disabled t)))
(advice-add 'ido-write-file :after  '(lambda (&rest args) (ido-mode 1) (setq tvd-ido-disabled nil)))

(defun tvd-keyboard-quit-advice (fn &rest args)
  (when tvd-ido-disabled
    (ido-mode 1)
    (setq tvd-ido-disabled nil))
  (apply fn args))

(advice-add 'abort-recursive-edit :around #'tvd-keyboard-quit-advice)

(setq ido-decorations (quote ("\n-> " "" "\n   " "\n   ..." "[" "]"
                              " [No match]" " [Matched]" " [Not readable]"
                              " [Too big]" " [Confirm]")))

(defun ido-disable-line-truncation () (set (make-local-variable 'truncate-lines) nil))
(add-hook 'ido-minibuffer-setup-hook 'ido-disable-line-truncation)
(defun ido-define-keys ()
  (define-key ido-completion-map (kbd "<down>") 'ido-next-match)
  (define-key ido-completion-map (kbd "<up>") 'ido-prev-match))
(add-hook 'ido-setup-hook 'ido-define-keys)

(add-hook 'ido-setup-hook
 (lambda ()
   ;; Go straight home
   (define-key ido-file-completion-map
     (kbd "~")
     (lambda ()
       (interactive)
       (if (looking-back "/")
           (insert "~/")
         (call-interactively 'self-insert-command))))))

(defadvice ido-find-file (after find-file-sudo activate)
  "Find file as root if necessary."
  (unless (and buffer-file-name
               (file-writable-p buffer-file-name))
    (let* ((file-name (buffer-file-name))
           (file-root (if (string-match "/ssh:\\([^:]+\\):\\(.*\\)" file-name)
                          (concat "/ssh:"  (match-string 1 file-name)
                                  "|sudo:" (match-string 1 file-name)
                                  ":"      (match-string 2 file-name))
                        (concat "/sudo:localhost:" file-name))))
      (find-alternate-file file-root))))

(if (version< emacs-version "25.0")
    (progn
      (require 'saveplace)
      (setq-default save-place t))
  (save-place-mode 1))

(require 'doremi)
(require 'doremi-frm)
(require 'doremi-cmd)

(defalias 'cb 'doremi-buffers+)

(defface extra-whitespace-face
  '((t (:background "pale green")))
  "Used for tabs and such.")

(defvar tvd-extra-keywords
  '(("\t" . 'extra-whitespace-face)))

(add-something-to-mode-hooks '(c c++ vala cperl emacs-lisp python shell-script)
                             (lambda () (font-lock-add-keywords nil tvd-extra-keywords)))

(require 'browse-kill-ring)
(setq browse-kill-ring-highlight-current-entry t
      browse-kill-ring-highlight-inserted-item t)

(require 'goto-last-change)

(global-set-key (kbd "C-b")             'goto-last-change)

(setq bookmark-save-flag 1
      bookmark-version-control t)

(defalias 'to        'bookmark-jump)
(defalias 'bm        'bookmark-set)
(defalias 'bl        'bookmark-bmenu-list)

(require 'which-key)
(which-key-mode)
(which-key-setup-side-window-right)

(require 'ibuffer)

(require 'ibuffer-vc)
(require 'ibuffer-tramp)

(global-set-key (kbd "C-x C-b")         'ibuffer)

(setq tvd-ibuffer-filter-group-name "tvd-filters")

(setq ibuffer-saved-filter-groups
      (list (nreverse
             `(
               ("Org" (mode . org-mode))
               ("Shell" (or (mode . term-mode)
                            (mode . eshell-mode)
                            (mode . shell-mode)))
               ("Emacs-Config"  (filename . "emacs"))
               ("Cisco-Config" (mode . cisco-mode))
               ("Code" (or (mode . cperl-mode)
                           (mode . c-mode)
                           (mode . python-mode)
                           (mode . shell-script-mode)
                           (mode . makefile-mode)
                           (mode . cc-mode)))
               ("Text" (or (mode . text-mode)
                           (filename . "\\.pod$")))
               ("LaTeX" (mode . latex-mode))
               ("Interactive" (or
                               (mode . inferior-python-mode)
                               (mode . slime-repl-mode)
                               (mode . inferior-lisp-mode)
                               (mode . inferior-scheme-mode)
                               (name . "*ielm*")))
               ("Crab" (or
                        (name . "^\\*\\(Help\\|scratch\\|Messages\\)\\*")
                          ))
               ,tvd-ibuffer-filter-group-name))))

(defadvice ibuffer-generate-filter-groups
    (after reverse-ibuffer-groups () activate)
  (setq ad-return-value (nreverse ad-return-value)))

(defun ibuffer-add-dynamic-filter-groups ()
  (interactive)
  (dolist (group (ibuffer-vc-generate-filter-groups-by-vc-root))
    (add-to-list 'ibuffer-filter-groups group))
  (dolist (group (ibuffer-tramp-generate-filter-groups-by-tramp-connection))
    (add-to-list 'ibuffer-filter-groups group)))

(defun tvd-ibuffer-hooks ()
  (ibuffer-auto-mode 1)
  (ibuffer-switch-to-saved-filter-groups tvd-ibuffer-filter-group-name)
  (ibuffer-add-dynamic-filter-groups))
(add-hook 'ibuffer-mode-hook 'tvd-ibuffer-hooks)

(setq ibuffer-show-empty-filter-groups nil)

(setq ibuffer-display-summary nil)

(setq ibuffer-expert t)

(add-to-list 'ibuffer-never-show-predicates "^\\*\\(Completions\\|tramp/\\)")

(define-ibuffer-column size-h
  (:name "Size" :inline t)
  (cond
   ((> (buffer-size) 1000000) (format "%7.1fM" (/ (buffer-size) 1000000.0)))
   ((> (buffer-size) 100000) (format "%7.0fk" (/ (buffer-size) 1000.0)))
   ((> (buffer-size) 1000) (format "%7.1fk" (/ (buffer-size) 1000.0)))
   (t (format "%8d" (buffer-size)))))

(setq ibuffer-formats
      '((mark modified read-only " "
              (name 20 40 :left :elide)
              " "
              (size-h 9 -1 :right)
              " "
              (mode 16 16 :left :elide)
              " "
              filename-and-process)))

(defvar ibuffer-collapsed-groups (list "Crab"))

(advice-add 'ibuffer :after '(lambda (&rest args)
  (ignore args)
  (save-excursion
    (dolist (group ibuffer-collapsed-groups)
      (ignore-errors
        (ibuffer-jump-to-filter-group group)
        (ibuffer-toggle-filter-group))))))

(defadvice ibuffer (around ibuffer-point-to-most-recent) ()
           "Open ibuffer with cursor pointed to most recent (non-minibuffer) buffer name"
           (let ((recent-buffer-name
                  (if (minibufferp (buffer-name))
                      (buffer-name
                       (window-buffer (minibuffer-selected-window)))
                    (buffer-name (other-buffer)))))
             ad-do-it
             (ibuffer-jump-to-buffer recent-buffer-name)))
(ad-activate 'ibuffer)

(define-key ibuffer-mode-map (kbd "M-o")    'other-window-or-switch-buffer)

(require 'printing)
(pr-menu-bind)

(when (executable-find "ps2pdf")
  (defun print-to-pdf (&optional filename)
    "Print file in the current buffer as pdf, including font, color, and
underline information.  This command works only if you are using a window system,
so it has a way to determine color values.

C-u COMMAND prompts user where to save the Postscript file (which is then
converted to PDF at the same location."
    (interactive (list (if current-prefix-arg
                           (ps-print-preprint 4)
                         (concat (file-name-sans-extension (buffer-file-name))
                                 ".ps"))))
    (ps-print-with-faces (point-min) (point-max) filename)
    (shell-command (concat "ps2pdf " filename))
    (delete-file filename)
    (message "Deleted %s" filename)
    (message "Wrote %s" (concat (file-name-sans-extension filename) ".pdf"))))

(require 'beacon)

(setq beacon-blink-duration 0.1
      beacon-blink-when-point-moves-vertically 10
      beacon-color 0.3)

(add-hook 'beacon-dont-blink-predicates
          (lambda () (bound-and-true-p novel-mode)))

(beacon-mode)