bba.org

# -*- org-export-use-babel: nil;  -*-
#+SETUPFILE: ~/git/github/org-html-themes/setup/theme-bigblow-local.setup
#+STARTUP: showall
#+TITLE: bba emacs configuration
#+OPTIONS: toc:4 h:4

* lexical-binding
[2025-09-28 Sun 17:03]

#+begin_src emacs-lisp
  ;; -*- lexical-binding: t; -*-
#+end_src

* Configuration

<<babel-init>>

Inspired by the [[http://eschulte.github.io/emacs-starter-kit/][Emacs Starter Kit]] and [[http://sachachua.com/blog/][Sacha Chua]] I set up my configuration file
using Org-babel. You could load it with =(org-babel-load-file "/path/to/file")=,
changing the path appropriately, but you'll probably want to tweak it
extensively first.

Some general links regarding these configuration:

- http://www.emacswiki.org/emacs/EmacsCrashCode
- http://www.emacswiki.org/emacs/EmacsCrashTips
- http://www.emacswiki.org/emacs/EmacsNiftyTricks

To be precise, this is what's in the first part of my =~/.emacs.d/init.el= (what used to be the =~/.emacs= file):

#+BEGIN_SRC emacs-lisp :tangle no
  ;; This sets up the load path so that we can override it
  ;; (package-initialize)
  ;; Override the packages with the git version of Org and other packages

    (setq load-path
    (append
    (list (expand-file-name "~/.emacs.d/") (expand-file-name "~/.emacs.d/elpa/org-9.7.17"))
    ;;           (expand-file-name "/usr/share/emacs/lisp/")
    load-path))


  (add-to-list 'load-path "~/.emacs/elpa/org-9.7.17")

  ;; (add-to-list 'load-path "~/elisp/org-mode/contrib/lisp")
  ;; Load the rest of the packages
  ;; (package-initialize t)
  ;; (setq package-enable-at-startup nil)
  (setq org-use-extra-keys t)
  (require 'org)
  (require 'ob-tangle)
  (require 'ob-sql)
  (require 'ob-async)
  (org-babel-load-file (expand-file-name "~/.emacs.d/bba.org"))

#+END_SRC

This git repository includes a .gitignore file excluding .elc files.
You might want to run =C-u 0 M-x byte-recompile-directory= after a
fresh clone. Install the githooks and your .elc files will get
recompiled after a git pull.

* debugging

If you are in need enable debugging:

#+BEGIN_SRC emacs-lisp :tangle no
(setq debug-on-error t)
#+END_SRC

* run in servermode

#+BEGIN_SRC emacs-lisp
  (require 'server)
  (unless (server-running-p)
    (server-start))

#+END_SRC

* welcome screen

No need for that:

#+BEGIN_SRC emacs-lisp
  (setq inhibit-startup-screen t)
#+END_SRC

* native-compile
[2022-04-18 Mon 16:02]

#+begin_src emacs-lisp
  (if (>= emacs-major-version 28)
      (setq native-comp-deferred-compilation t))
#+end_src

* shell aliases

Some aliases you might want to set in your bash to talk to your Emacs server:

#+BEGIN_SRC sh :tangle no
  alias e='emacsclient -n -a emacs'
  alias magit='emacsclient -n -e "(magit-status \"$(pwd)\")"'
  alias eshell='emacsclient -n -e "(eshell-client)"'
#+END_SRC

* set environment variables on osx
    [2015-07-16 Thu 19:10]

If running standalone on OSX we need to get some environment variables
from bash.

#+BEGIN_SRC emacs-lisp
  (setenv "EDITOR" "emacsclient")

  (if (string-equal system-type "darwin")
          (progn
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $PATH")))
              (setenv "PATH" path)
              (setq exec-path
                    (append
                     (split-string-and-unquote path ":")
                     exec-path)))
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $LANG")))
              (setenv "LANG" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $EMAIL")))
              (setenv "EMAIL" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $ORGANIZATION")))
              (setenv "ORGANIZATION" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $GOPATH")))
              (setenv "GOPATH" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $PYTHONPATH")))
              (setenv "PYTHONPATH" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $SSH_AUTH_SOCK")))
              (setq ssh-auth-sock path)
              (setenv "SSH_AUTH_SOCK" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; pidof ssh-agent | tr -d ' \n'")))
              (setenv "SSH_AGENT_PID" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $GPG_AGENT_INFO")))
              (setenv "GPG_AGENT_INFO" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $ORACLE_HOME")))
              (setenv "ORACLE_HOME" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $PERL5LIB")))
              (setenv "PERL5LIB" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $CLASSPATH")))
              (setenv "CLASSPATH" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $NLS_LANG")))
              (setenv "NLS_LANG" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $TNS_ADMIN")))
              (setenv "TNS_ADMIN" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $DYLD_LIBRARY_PATH")))
              (setenv "DYLD_LIBRARY_PATH" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $SYSENV")))
              (setenv "SYSENV" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $http_proxy")))
              (setenv "http_proxy" path)
              )
            (let ((path (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $https_proxy")))
              (setenv "https_proxy" path)
              )
            (let ((infopath (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; echo -n $INFOPATH")))
              (setenv "INFOPATH" infopath)
              (setq Info-directory-list
                    (append (mapcar #'expand-file-name (split-string-and-unquote infopath ":")) Info-directory-list)))
            (let ((manpath (shell-command-to-string ". ~/.bashrc 2>/dev/null >/dev/null; manpath")))
              (setenv "MANPATH" manpath))
            (push "/opt/local/share/info" Info-directory-list)))
#+END_SRC

* print on osx
[2025-06-18 Wed 14:44]

#+begin_src sh :tangle ~/bin/lpr-ps
  #!/bin/bash
  uuid=$(uuidgen)
  gs -sDEVICE=pdfwrite -o $TMPDIR/$uuid.pdf - && open $TMPDIR/$uuid.pdf && sleep 1 && rm $TMPDIR/$uuid.pdf
#+end_src

#+begin_src emacs-lisp
  (if (string-equal system-type "darwin")
      (if (file-exists-p "~/bin/lpr-ps")
            (setq ps-lpr-command "~/bin/lpr-ps")
          )
      )
#+end_src
* testing steampipe
[2023-04-05 Wed 13:18]

#+begin_src emacs-lisp :tangle never
  (defun bba-steampipe()
    "set sql connection for steampipe"
    (interactive)
    (setq sql-postgres-login-params nil)
    (let (foo (shell-command-to-string "steampipe service start")))
    (add-to-list 'sql-connection-alist
                 `(steampipe (sql-product 'postgres)
                             (sql-database ,(shell-command-to-string "steampipe service status --show-password | grep \"Connection string\" | awk '{print $3}' | tr -d '\n'")))))
#+end_src

* bba open safari url in eww
[2023-05-09 Tue 16:25]

[[file:elpa/org-mac-link-20220616.2340/org-mac-link.el::(org-mac-link-paste-applescript-links][org-mac-link]]

#+begin_src emacs-lisp :tangle never
  (defun bba-open-safari-in-eww ()
    "AppleScript to get the links to the frontmost window of the Safari.app and open in eww."
    (interactive)
    (let* ((noquote-as-link-list
            (if (string-prefix-p "\"" as-link-list)
                (substring as-link-list 1 -1)
              as-link-list))
           (link-list
            (mapcar (lambda (x) (if (string-match "\\`\"\\(.*\\)\"\\'" x)
                                    (setq x (match-string 1 x)))
                      x)
                    (split-string noquote-as-link-list "[\r\n]+")))
           split-link URL description orglink rtn orglink-list)
      (while link-list
        (setq split-link (split-string (pop link-list) "::split::"))
        (setq URL (car split-link))
        (setq description (cadr split-link))
        (when (not (string= URL ""))
          (setq orglink (org-link-make-string URL description))
          (push orglink orglink-list)))
      (setq rtn (mapconcat #'identity orglink-list "\n"))
      (kill-new rtn)
      rtn)
    (org-mac-link-do-applescript
     (concat
      "tell application \"Safari\"\n"
      "	set theUrl to URL of document 1\n"
      "	set theName to the name of the document 1\n"
      "	return theUrl & \"::split::\" & theName & \"\n\"\n"
      "end tell\n")))
#+end_src


* temporary load f

#+begin_src emacs-lisp
  (add-to-list 'load-path "~/.emacs.d/elpa/f-20241003.1131")
  (require 'f)
#+end_src

* temporary load emacsql
[2023-05-06 Sat 12:04]

BUGBUG

#+begin_src sql emacs-lisp :tangle no
  (add-to-list 'load-path "~/.emacs.d/elpa/emacsql-20251130.1841")
  (require 'emacsql)

  (add-to-list 'load-path "~/.emacs.d/elpa/emacsql-sqlite-20230225.2205")
  (require 'emacsql-sqlite)
#+end_src

* [[https://github.com/leoliu/play-sound-osx][play sound on osx]]
[2021-01-22 Fri 11:58]

#+begin_src emacs-lisp
  (if (string-equal system-type "darwin")
          (progn
            (load-file (expand-file-name "~/.emacs.d/lisp/play-sound.el"))
            (unless (and (fboundp 'play-sound-internal)
                         (subrp (symbol-function 'play-sound-internal)))
              (require 'play-sound))
    (setq ring-bell-function (lambda ()
                               (play-sound-file "~/.emacs.d/bell.wav")))))
#+end_src
* move files to trash on osx
[2017-02-10 Fri 15:12]

If trash is missing you might want to run

=sudo port install trash=

#+BEGIN_SRC emacs-lisp :tangle no
  (if (string-equal system-type "darwin")
      (if (file-exists-p "/opt/local/bin/trash")
          (progn
            (defun system-move-file-to-trash (file)
              "Use osx port trash to move files to trash"
              (call-process "trash" nil nil nil file)
              ))))
#+END_SRC

With trash you can recover files to it's original location.

* define emacs shutdown function

I like to commit my notes in my org and workorg folders after a days work.
Keep track of your important stuff!

#+BEGIN_SRC emacs-lisp

  ;; define function to shutdown emacs server instance
  (defun server-shutdown ()
    "Save buffers, Quit, and Shutdown (kill) server"
    (interactive)
    (save-some-buffers)
    (shell-command "git --work-tree ~/org/ --git-dir ~/org/.git commit -a -m 'autocommit'")
    (shell-command "git --work-tree ~/org/ --git-dir ~/org/.git push origin")
    (if (equal "work" (getenv "SYSENV"))
        (progn
          (shell-command "git --work-tree ~/workorg/ --git-dir ~/workorg/.git commit -a -m 'autocommit'")
          (shell-command "git --work-tree ~/workorg/ --git-dir ~/workorg/.git push origin")
          ))
    (kill-emacs)
    )

#+END_SRC

* ansi
[2025-12-05 Fri 11:21]

#+begin_src emacs-lisp
  (require 'ansi-color)
  (defun display-ansi-colors ()
    (interactive)
    (ansi-color-apply-on-region (point-min) (point-max)))
#+end_src

* async
#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa/async-20251005.634")
        (require 'async)
        )
    )
#+END_SRC

* [[http://www.emacswiki.org/emacs/ELPA][ELPA]]

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa")
        (add-to-list 'load-path "~/.emacs.d/elpa/popup-20250101.843")
        (require 'package)
        ;; (package-initialize)
        (add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))
        (add-to-list 'package-archives '("elpa" . "https://elpa.gnu.org/packages/"))
        (setq package-install-upgrade-built-in t)
        ))
#+END_SRC

* calendar
[2019-09-30 Mon 10:30]

#+begin_src emacs-lisp
  (defun calendar-insert-date ()
    "Capture the date at point, exit the Calendar, insert the date."
    (interactive)
    (seq-let (month day year) (save-match-data (calendar-cursor-to-date))
      (calendar-exit)
      (insert (format "%d-%02d-%02d" year month day))))

  (define-key calendar-mode-map (kbd "RET") 'calendar-insert-date)
#+end_src

* [[https://www.emacswiki.org/emacs/BookmarkPlus][Bookmark+]]
[2022-02-10 Thu 15:22]

#+BEGIN_SRC emacs-lisp
  (if (equal "work" (getenv "SYSENV"))
      (setq bookmark-default-file "~/workorg/bookmarks")
    (setq bookmark-default-file "~/org/bookmarks"))
  (load-file (expand-file-name "~/.emacs.d/lisp/bookmark+.el"))
  (load-file (expand-file-name "~/.emacs.d/lisp/bookmark+-mac.el"))
  (load-file (expand-file-name "~/.emacs.d/lisp/bookmark+-bmu.el"))
  (load-file (expand-file-name "~/.emacs.d/lisp/bookmark+-1.el"))
  (load-file (expand-file-name "~/.emacs.d/lisp/bookmark+-key.el"))
  (load-file (expand-file-name "~/.emacs.d/lisp/bookmark+-lit.el"))

#+END_SRC

* fullframe
open ibuffer and magit-status in fullframe mode.
#+BEGIN_SRC emacs-lisp :tangle no
    (if (>= emacs-major-version 25)
        (progn
          (add-to-list 'load-path "~/.emacs.d/elpa/fullframe-20210226.1057")
          (require 'fullframe)
          (fullframe magit-status magit-mode-quit-window)
          )
      )
#+END_SRC

* [[http://www.gnu.org/software/emacs/manual/html_node/emacs/Window-Convenience.html][winner-mode]]
    [2015-06-10 Wed 09:33]

Get undo for your window layout.

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (winner-mode 1))
#+END_SRC

* smartparens-mode

Enable smart parens in all modes.
See [[https://github.com/toctan/smartparens][Smartparens on github]].
Some key bindings taken from [[https://ebzzry.github.io/emacs-pairs.html][emacs-pairs]].

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa/smartparens-20250612.1050")
        (add-to-list 'load-path "~/.emacs.d/elpa/dash-20250312.1307")
        (require 'smartparens)
        (smartparens-global-mode 1)
        (defmacro def-pairs (pairs)
          `(progn
             ,@(cl-loop for (key . val) in pairs
                     collect
                     `(defun ,(read (concat
                                     "wrap-with-"
                                     (prin1-to-string key)
                                     "s"))
                          (&optional arg)
                        (interactive "p")
                        (sp-wrap-with-pair ,val)))))

        (def-pairs ((paren        . "(")
                    (bracket      . "[")
                    (brace        . "{")
                    (single-quote . "'")
                    (double-quote . "\"")
                    (back-quote   . "`")))

        (define-key smartparens-mode-map (kbd "C-'") 'sp-rewrap-sexp)
        (define-key smartparens-mode-map (kbd "C-c (") 'wrap-with-parens)
        (define-key smartparens-mode-map (kbd "C-c ]") 'sp-backward-unwrap-sexp)
        (define-key smartparens-mode-map (kbd "C-c )") 'sp-unwrap-sexp)
        (define-key smartparens-mode-map (kbd "C-c [") 'wrap-with-brackets)
        (define-key smartparens-mode-map (kbd "C-c {") 'wrap-with-braces)
        (define-key smartparens-mode-map (kbd "<C-S-kp-4>") 'sp-beginning-of-sexp)
        (define-key smartparens-mode-map (kbd "<C-S-kp-6>") 'sp-end-of-sexp)
        (define-key smartparens-mode-map (kbd "<C-S-kp-8>") 'sp-up-sexp)
        (define-key smartparens-mode-map (kbd "<C-S-kp-2>") 'sp-down-sexp)
        ))
#+END_SRC

* [[https://github.com/Fanael/rainbow-delimiters][rainbow-delimiters]]

Highlight delimiters such as parentheses, brackets or braces according
to their depth.
But we use it only in graphical mode as text mode lacks color depth.

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (when (display-graphic-p)
        (add-to-list 'load-path "~/.emacs.d/elpa/rainbow-delimiters-20210515.1254")
        ))

  (add-hook 'sql-mode-hook 'rainbow-delimiters-mode)
  (add-hook 'sql-interactive-mode-hook 'rainbow-delimiters-mode)
#+end_src

* docker
[2025-11-25 Tue 12:48]

#+begin_src emacs-lisp
    (require 'docker)
    (global-set-key "\C-cd" 'docker)
    (eval-after-load 'docker
      '(add-hook 'dockerfile-mode-hook '(lambda()   (define-key dockerfile-mode-map "\C-c\C-c" 'compile)
  (setq compile-command "docker build -t tag ."))))
#+end_src
* [[https://github.com/hrs/engine-mode][engine-mode]]

search the web on your fingertips. C-c /.

|---+-------------|
| a | amazon.de   |
| b | bing        |
| c | cfengine    |
| g | google      |
| G | github      |
| M | google maps |
| m | mysql       |
| p | postgresql  |
| P | puppet      |
| u | usenix
| v | vertica     |
| w | wikipedia   |
| y | youtube     |
|---+-------------|


#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (require 'engine-mode)

        (defengine amazon
          "http://www.amazon.de/s/ref=nb_sb_noss?url=search-alias=aps&filed-keywords=%s"
          :keybinding "a")

        (defengine aws
          "https://docs.aws.amazon.com/search/doc-search.html?searchPath=documentation-guide&searchQuery=%s"
          :keybinding "A")

        (defengine bing
          "http://www.bing.com/search?q=%s&qs=bs&form=QBLH"
          :browser 'eww-browse-url
          :keybinding "b")

        (defengine cfengine
          "https://docs.cfengine.com/latest/search.html?q=%s"
          :keybinding "c")

        (defengine github
          "http://www.github.com/search?q=%s"
          :browser 'eww-browse-url
          :keybinding "G")

        (defengine google
          "http://www.google.com/?q=%s"
          :keybinding "g")

        (defengine google-maps
          "http://maps.google.com/maps?q=%s"
          :keybinding "M")

        (defengine leo
          "http://dict.leo.org/ende/index_de.html#/search=%s"
          :keybinding "l")

        (defengine mysql
          "https://dev.mysql.com/doc/search/?d=201&p=1&q=%s"
          :keybinding "m")

        (defengine postgresql
            "https://www.postgresql.org/search/?u=/docs/14/&q=%s"
            :keybinding "p")

        (defengine puppet
          "https://puppet.com/search/docs?keys=%s"
          :keybinding "P")

        (defengine usenix
          "https://www.usenix.org/search/site/%s"
          :keybinding "u")

        (defengine vertica
          "https://docs.vertica.com/24.4.x/en/searchResults.html?search=%s"
          :keybinding "v")

        (defengine wikipedia
          "http://www.wikipedia.org/search-redirect.php?language=en&go=Go&search=%s"
          :browser 'eww-browse-url
          :keybinding "w")

        (defengine youtube
          "http://www.youtube.com/results?aq=f&oq=&search_query=%s"
          :keybinding "y")

        (engine-mode 1)
        (engine/set-keymap-prefix (kbd "C-c C-/"))))
#+END_SRC

* xah-lookup
[2017-03-20 Mon 17:46]

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa/xah-lookup-20181225.1942")
        (require 'xah-lookup)
        )
    (setq xah-lookup-browser-function 'eww)
    )
#+END_SRC

* xah-html-decode
[2026-01-28 Wed 16:35]

#+begin_src emacs-lisp
  (defun xah-html-encode-ampersand-entity (&optional Begin End)
    "Replace HTML chars & < > \" to &amp; &lt; &gt; &quot; on current block or selection.

  URL `http://xahlee.info/emacs/emacs/elisp_replace_html_entities_command.html'
  Created: 2020-08-30
  Version: 2025-08-11"
    (interactive)
    (let (xbeg xend)
      (seq-setq
       (xbeg xend)
       (if (and Begin End)
           (list Begin End)
         (if (region-active-p)
             (list (region-beginning) (region-end))
           (list (save-excursion
                   (if (re-search-backward "\n[ \t]*\n" nil 1)
                       (match-end 0)
                     (point)))
                 (save-excursion
                   (if (re-search-forward "\n[ \t]*\n" nil 1)
                       (match-beginning 0)
                     (point)))))))
      (save-restriction
        (narrow-to-region xbeg xend)
        (progn
          (goto-char (point-min))
          (while (re-search-forward "&\\|<\\|>\\|\"" nil t)
            (cond
             ((string-equal "&" (match-string 0)) (replace-match "&amp;" t t))
             ((string-equal "<" (match-string 0)) (replace-match "&lt;" t t))
             ((string-equal ">" (match-string 0)) (replace-match "&gt;" t t))
             ((string-equal "\"" (match-string 0)) (replace-match "&quot;" t t)))
            (overlay-put (make-overlay (match-beginning 0) (match-end 0)) 'face 'highlight))))))


  (defun xah-html-decode-ampersand-entity (&optional Begin End)
    "Replace &amp; &lt; &gt; &quot; to & < > ' on current block or selection.

  URL `http://xahlee.info/emacs/emacs/elisp_replace_html_entities_command.html'
  Created: 2020-08-30
  Version: 2025-08-11"
    (interactive)
    (let (xbeg xend)
      (seq-setq (xbeg xend) (if (and Begin End) (list Begin End) (if (region-active-p) (list (region-beginning) (region-end)) (list (save-excursion (if (re-search-backward "\n[ \t]*\n" nil 1) (match-end 0) (point))) (save-excursion (if (re-search-forward "\n[ \t]*\n" nil 1) (match-beginning 0) (point)))))))

      (save-restriction
        (narrow-to-region xbeg xend)
        (progn
          (goto-char (point-min))
          (while (re-search-forward "&amp;\\|&lt;\\|&gt;\\|&quot;" nil t)
            (cond
             ((string-equal "&amp;" (match-string 0)) (replace-match "&" t t))
             ((string-equal "&lt;" (match-string 0)) (replace-match "<" t t))
             ((string-equal "&gt;" (match-string 0)) (replace-match ">" t t))
             ((string-equal "&quot;" (match-string 0)) (replace-match "\"" t t)))
            (overlay-put (make-overlay (match-beginning 0) (match-end 0)) 'face 'highlight))))))
#+end_src

* expand-region
    [2015-04-02 Thu 10:32]

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa/expand-region-20221030.957")
        (require 'expand-region)
        (define-key global-map (kbd "C-c C-<f12>") 'er/contract-region )
        (define-key global-map (kbd "C-c <f12>") 'er/expand-region )
        ))

#+END_SRC
* [[https://emacs.stackexchange.com/a/36800][toggle-quotes]]
[2022-04-15 Fri 12:33]

#+begin_src emacs-lisp
  (defun toggle-quotes (uarg)
    "Toggle single and double quotes around a string.

  Does the change only if the point is inside quotes that are
  syntactically correct under the current major mode. For example,
  single quotes are not valid strings under elisp-mode. You can
  force the change by using the universal argument C-u."
    (interactive "p")
    (let ((quotes-re "['\"]")
          (forward-char "")
          (new-quote-char "'"))
      (if (or (nth 3 (syntax-ppss)) (= uarg 4))
          (save-excursion
            (when (re-search-forward quotes-re nil t)
              (setq forward-char (match-string 0))
              (if (string-match forward-char "'")
                  (setq new-quote-char "\""))
              (when (re-search-backward forward-char nil t 2)
                (goto-char (match-beginning 0))
                (replace-match new-quote-char)
                (re-search-forward quotes-re nil t)
                (replace-match new-quote-char))))
        (message "Point not inside a valid string! Universal argument overrides."))))

  (define-key global-map (kbd "C-c C-'") #'toggle-quotes)
#+end_src
* yasnippet

My first thought: Nice. But do I have a use case? After half a year I
cannot live without it. I write most of my [[http://www.cfengine.com][CFEngine]] code with
snippets. Some help for Perl and even for org-mode.
Thought about using snippets for shell-mode and eshell-mode?
snippets for =aws cli= are awesome!
=ha-autoinsert-yas-expand= copied from Howard Abrams.

#+BEGIN_SRC emacs-lisp
  (add-to-list 'load-path
               "~/.emacs.d/elpa/yasnippet-20250602.1342")
  (require 'yasnippet)

  (if (equal "work" (getenv "SYSENV"))
      (add-to-list 'yas-snippet-dirs "~/workorg/snippets"))
  (add-to-list 'yas-snippet-dirs "~/.emacs.d/snippets")
  (add-to-list 'yas-snippet-dirs "~/.emacs.d/lisp/snippets")
  (yas-reload-all)
  (yas-global-mode 1)
  (setq yas-indent-line nil)
  (setq yas-triggers-in-field t)
  (auto-insert-mode 1)
  (setq auto-insert-directory "~/.emacs.d/templates")
  (define-key global-map "\C-cy" 'yas-insert-snippet)
    (if (>= emacs-major-version 24)
        (add-to-list 'yas-prompt-functions 'shk-yas/helm-prompt))
  (defun ha-autoinsert-yas-expand()
    "Replace text in yasnippet template."
    (yas-expand-snippet (buffer-string) (point-min) (point-max)))
  (define-auto-insert "cfbs.json$" ["default-cfbs.json" ha-autoinsert-yas-expand])
  (define-auto-insert "main.cf$" ["default-main.cf" ha-autoinsert-yas-expand])
  (define-auto-insert "\\.go$" ["default-go.go" ha-autoinsert-yas-expand])
  (define-auto-insert "\\.sh$" ["default-sh.sh" ha-autoinsert-yas-expand])
  (define-auto-insert "\\.pl$" ["default-pl.pl" ha-autoinsert-yas-expand])
  (define-auto-insert "\\.tex$" ["default-tex.tex" ha-autoinsert-yas-expand])
  (define-auto-insert "\\.emacs.d/snippets/[^/]*/" ["default-snippet" ha-autoinsert-yas-expand])

#+END_SRC

From http://emacswiki.org/emacs/Yasnippet

#+begin_src emacs-lisp
  (defun shk-yas/helm-prompt (prompt choices &optional display-fn)
      "Use helm to select a snippet. Put this into `yas-prompt-functions.'"
      (interactive)
      (if (require 'helm-config nil t)
          (let ((result (helm-other-buffer
                         (list `((name . ,prompt)
                                 (candidates . ,(if display-fn (mapcar display-fn choices)
                                                  choices))
                                 (action . (("Expand" . identity)))))
                         "*helm-select-yasnippet")))
            (cond ((null result)
                   (signal 'quit "user quit!"))
                  (display-fn
                   (catch 'result
                     (dolist (choice choices)
                       (when (equal (funcall display-fn choice) result)
                         (throw 'result choice)))))
                  (t result)))
        nil))
#+end_src

Default to snippet-mode if we are in a sub directory of snippets:

#+BEGIN_SRC emacs-lisp
  (add-to-list 'auto-mode-alist '("\\.emacs.d/snippets/[^/]*/" . snippet-mode))
#+END_SRC

* define some major modes for yasnippets
[2016-05-25 Wed 10:26]

I use yasnippet for sql a lot.
Languages differ and I need different templates.

#+BEGIN_SRC emacs-lisp
  (define-derived-mode sql-oracle-mode sql-mode "OracleSQL"
    "Major mode for ORACLE SQL"
    (setq sql-product 'oracle)
    )
#+END_SRC

#+BEGIN_SRC emacs-lisp
    (define-derived-mode sql-vertica-mode sql-mode "VerticaSQL"
      "Major mode for Vertica"
      (setq sql-product 'ansi)
      )

#+END_SRC

#+BEGIN_SRC emacs-lisp
  (define-derived-mode sql-mysql-mode sql-mode "MySQL"
    "Major mode for MySQL"
    (setq sql-product 'mysql)
    )

#+END_SRC

* [[https://github.com/flycheck/flycheck][flycheck]]

modified puppet-lint definition to include no-80chars-check and fixed
log-format.

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
  	(add-to-list 'load-path "~/.emacs.d/elpa/flycheck-20251128.1706")
  	(require 'flycheck)
  	(add-hook 'after-init-hook #'global-flycheck-mode)))
#+END_SRC

SQL:

#+begin_src sh :tangle never
  gem install --user-install sqlint
#+end_src

#+begin_src sh :eval never
  sudo port install mmark
#+end_src

#+begin_src emacs-lisp
  (eval-after-load 'flycheck
    '(add-hook 'flycheck-mode-hook #'flycheck-mmark-setup))
  (eval-after-load 'markdown
    '(add-hook 'markdown-mode-hook #'flycheck-mode))
#+end_src

* [[https://github.com/kai2nenobu/guide-key][guide-key]]

Probably the best help to keep track of the not every day used keybindings.

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa/popwin-20210215.1849")
        (add-to-list 'load-path "~/.emacs.d/elpa/guide-key-20150108.635")
        (require 'guide-key)
        (setq guide-key/guide-key-sequence '("C-x" "C-x C-k" "C-x 4" "C-c" "C-h" "C-x l" "<ESC>" "<f9>" "s-l"))
        (setq guide-key/recursive-key-sequence-flag t)
        (setq guide-key/idle-delay 3)
        (guide-key-mode 1)
        )
    )
#+END_SRC

* [[https://github.com/jekor/hidepw][hidepw]]
[2016-02-11 Thu 16:10]

Hide passwords on the screen from shoulder surfing.
Single pipes interfere with org tables. Just go double.

#+BEGIN_SRC emacs-lisp
  (load-file (expand-file-name "~/.emacs.d/lisp/hidepw.el"))
  (add-hook 'org-mode-hook  'hidepw-mode)
  (setq hidepw-patterns '("||\\(.*\\)||"))
#+END_SRC

* latex

Use [[http://orgmode.org/manual/A-LaTeX-example.html#A-LaTeX-example][orgtbl]] to create tables.

#+BEGIN_SRC emacs-lisp
  (setq tex-dvi-view-command "(f=*; pdflatex \"${f%.dvi}.tex\" && open \"${f%.dvi}.pdf\")")
  (setq TeX-auto-save t)
  (setq TeX-parse-self t)
  (setq-default TeX-master nil)

  (add-hook 'latex-mode-hook
    (lambda ()
      (auto-fill-mode)
      (orgtbl-mode)
      ))


#+END_SRC

* thesaurus

#+BEGIN_SRC emacs-lisp
  ;; The file names are absolute, not relative, locations
  ;;     - e.g. /foobar/mthesaur.txt.cache, not mthesaur.txt.cache
  (setq synonyms-file        "~/.emacs.d/mthesaur.txt")
  (setq synonyms-cache-file  "~/.emacs.d/mthesaur.txt.cache")
  (require 'synonyms)
;;  (define-key global-map (kbd "C-c ?") 'synonyms)

#+END_SRC

* highlight indentation
[2016-10-09 Sun 17:13]

#+BEGIN_SRC emacs-lisp
  (load-file (expand-file-name "~/.emacs.d/lisp/highlight-indentation.el"))
  (set-face-background 'highlight-indentation-face "#e3e3d3")
  (set-face-background 'highlight-indentation-current-column-face "#c3b3b3")
#+END_SRC
* htmlize

To get syntax highlight for HTML exports:

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (require 'htmlize )
        )
  )


#+END_SRC

* [[https://github.com/abo-abo/avy/blob/master/README.md][avy]]

Replaced the deprecated [[https://github.com/winterTTr/ace-jump-mode][ace-jump-mode]] with [[help:avy-goto-char][avy-goto-char]] and [[help:goto-line][goto-line]]
with [[help:avy-goto-line][avy-goto-line]].

#+BEGIN_SRC emacs-lisp
  (add-to-list 'load-path "~/.emacs.d/elpa/avy-20230420.404")
  (require 'avy)
  (define-key global-map (kbd "C-c C-@") 'avy-goto-word-1)
  (define-key global-map (kbd "C-c C-SPC") 'avy-goto-word-1)
  (define-key global-map (kbd "M-g g") 'avy-goto-line)
  (define-key global-map (kbd "C-c C-S-SPC") 'avy-goto-char-timer)

#+END_SRC

* ido-mode

I still like ido-find-file.

#+BEGIN_SRC emacs-lisp :tangle no
  (ido-mode t)
  (setq ido-enable-prefix nil
        ido-enable-flex-matching t
        ido-case-fold nil
        ido-auto-merge-work-directories-length -1
        ido-create-new-buffer 'always
        ido-use-filename-at-point nil
        ido-max- 10)
  ;; (require 'ido-vertical-mode)
  ;; (ido-vertical-mode)

  ;; (defun sd/ido-define-keys() ;; C-n/p is more intuitive in vertical layout
  ;;   (define-key ido-completion-map (kbd "C-n") 'ido-next-match)
  ;;   (define-key ido-completion-map (kbd "<down>") 'ido-next-match)
  ;;   (define-key ido-completion-map (kbd "C-p") 'ido-prev-match)
  ;;   (define-key ido-completion-map (kbd "<up>") 'ido-prev-match)
  ;; )


#+END_SRC

* visual-regexp

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (require 'visual-regexp)
        (define-key global-map (kbd "M-&") 'vr/query-replace)
        (define-key global-map (kbd "M-/") 'vr/replace)
        )
  )
#+END_SRC

* goto-address-mode
[2018-08-28 Tue 20:34]

#+BEGIN_SRC emacs-lisp
  (eval-after-load "prog-mode"
    '(progn
       (add-hook 'prog-mode-hook 'goto-address-prog-mode)
       (define-key prog-mode-map "\C-c\C-o" 'goto-address-at-point)))
  (eval-after-load "eshell-mode"
    '(progn
       (add-hook 'eshell-mode 'goto-address-mode)
       (define-key eshell-mode-map "\C-c\C-o" 'goto-address-at-point)))
  (eval-after-load "shell-mode"
    '(progn
       (add-hook 'shell-mode 'goto-address-mode)
       (define-key shell-mode-map "\C-c\C-o" 'goto-address-at-point)))
#+END_SRC

* magit
[2023-01-17 Tue 09:33]

#+begin_src emacs-lisp
  (add-to-list 'load-path "~/.emacs.d/elpa/forge-20251201.1658")
  (with-eval-after-load 'magit
    (require 'forge))

  (setq magit-show-long-lines-warning nil)
#+end_src

* mwheel

#+BEGIN_SRC emacs-lisp
  (load-library "mwheel")
  (mwheel-install)

#+END_SRC

* [[http://emacs.wordpress.com/2007/06/21/tip-of-the-day/][tip of the day]]
    [2014-09-24 Wed 12:06]

Display an Emacs tip of the day.
You may start it at the end of the config file.

#+BEGIN_SRC emacs-lisp
(defun totd ()
  (interactive)
  (random t) ;; seed with time-of-day
  (with-output-to-temp-buffer "*Tip of the day*"
    (let* ((commands (cl-loop for s being the symbols
                           when (commandp s) collect s))
           (command (nth (random (length commands)) commands)))
      (princ
       (concat "Your tip for the day is:\n"
               "========================\n\n"
               (describe-function command)
               "\n\nInvoke with:\n\n"
               (with-temp-buffer
                 (where-is command t)
                 (buffer-string)))))))
#+END_SRC

* TRAMP

#+BEGIN_SRC emacs-lisp
  (load-library "tramp")
  (add-to-list 'tramp-remote-path "~/bin")
  (setq default-tramp-method "sshx")
  (add-to-list 'tramp-remote-path 'tramp-own-remote-path)
#+END_SRC

With this you can do /sudo:ssh-host:file-on-ssh-host

#+BEGIN_SRC emacs-lisp
  (add-to-list 'tramp-default-proxies-alist '(nil "\\`root\\'" "/ssh:%h:"))
#+END_SRC

Use our default socket files

#+BEGIN_SRC emacs-lisp
  (if (file-accessible-directory-p "~/.ssh/sockets")
  (setq tramp-ssh-controlmaster-options "-o ControlMaster=auto -o ControlPath='~/.ssh/sockets/ssh.%%r.%%n.%%p' -o ControlPersist=600"))
#+END_SRC

TRAMP gcloud ssh

#+NAME:gssh
#+begin_src sh :eval never :tangle no
  #!/bin/bash

  HOST="$1"

  if [[ $HOST = *"@"* ]] ; then
      USER=$(echo $HOST | cut -d'@' -f1)
      HOST=$(echo $HOST | cut -d'@' -f2)
  fi

  gcloud config list | grep 'Your active'
  ZONE=$(gcloud compute instances list |grep -E "^$HOST[[:space:]]" | awk '{print $2}')
  echo zone: $ZONE
  gcloud compute ssh --zone=$ZONE --tunnel-through-iap "$@"
#+end_src


#+begin_src emacs-lisp
  (require 'tramp)
  (eval-after-load "tramp"
    '(progn
       (add-to-list 'tramp-methods
                    '("gssh"
                      (tramp-login-program        "gssh")
                      (tramp-login-args           (("%h")))
                      (tramp-async-args           (("-q")))
                      (tramp-remote-shell         "/bin/sh")
                      (tramp-remote-shell-args    ("-c"))
                      (tramp-gw-args              (("-o" "GlobalKnownHostsFile=/dev/null")
                                                   ("-o" "UserKnownHostsFile=/dev/null")
                                                   ("-o" "StrictHostKeyChecking=no")))
                      (tramp-default-port         22)))))
#+end_src

if you have multiple docker containers with the same name on different
hosts tramp tramp-default-proxies-alist gets confused.

#+begin_src emacs-lisp
  (setq tramp-show-ad-hoc-proxies t)
#+end_src

* translate
[2022-12-25 Sun 15:02]

#+begin_src emacs-lisp
  (require 'go-translate)

  (setq gt-translate-list '(("en" "de")))

  (setq gt-default-translator
        (gt-translator
         :engines (list (gt-bing-engine) (gt-google-engine))
         :render (gt-buffer-render)))
#+end_src

* [[http://www.mew.org][mew]] email

#+BEGIN_SRC emacs-lisp :eval no :tangle no
  (autoload 'mew "mew" nil t)
  (autoload 'mew-send "mew" nil t)

  ;; Optional setup (Red Mail menu):
  (setq read-mail-command 'mew)

  ;; Optional setup (e.g. C-xm for sending a message):
  (autoload 'new-user-agent-compose "mew" nil t)

  (if (boundp 'mail-user-agent)
      (setq mail-user-agent 'mew-user-agent))
  (if (fboundp 'define-mail-user-agent)
      (define-mail-user-agent
        'mew-user-agent
        'mew-user-agent-compose
        'mew-draft-send-message
        'mew-draft-kill
        'mew-send-hook))
#+END_SRC

When booting, Mew reads the file [[~/.mew.el]]. All Mew configurations
should be written in this file.

To configure your e-mail address, the followings are necessary.

#+BEGIN_SRC emacs-lisp :tangle no
  ;; (setq mew-name "your name") ;; (user-full-name)
  ;; (setq mew-user "user name of e-mail address") ;; (user-login-name)
  (setq mew-mail-domain "domain of e-mail address")
#+END_SRC

To send e-mail messages by SMTP, the following is necessary.

#+BEGIN_SRC emacs-lisp :tangle no
  (setq mew-smtp-server "your SMTP server") ;; if not localhost
  ;; (setq mew-smtp-ssl t)
  ;; (setq mew-smtp-port "587")

#+END_SRC

Here is an example for sending e-mail via gmail:

#+BEGIN_SRC emacs-lisp :tangle no
  (setq
  send-mail-function 'smtpmail-send-it
  message-send-mail-function 'smtpmail-send-it
  user-mail-address "foo@gmail.com"
  smtpmail-starttls-credentials '(("smtp.gmail.com" "587" nil nil))
  smtpmail-auth-credentials (expand-file-name "~/.authinfo.gpg")
  smtpmail-default-smtp-server "smtp.gmail.com"
  smtpmail-smtp-server "smtp.gmail.com"
  smtpmail-smtp-service 587
  smtpmail-debug-info t
  starttls-extra-arguments nil
  starttls-gnutls-program "/opt/local/bin/gnutls-cli"
  starttls-extra-arguments nil
  starttls-use-gnutls t
  )
  (load-library "smtpmail")

#+END_SRC

If you want to use POP to receive e-mail messages, the followings are
necessary.

#+BEGIN_SRC emacs-lisp :tangle no
  ;; (setq mew-pop-user "your POP account") ;; (user-login-name)
  (setq mew-pop-server "your POP server") ;; if not localhost
#+END_SRC

If you want to use a local mailbox to receive e-mail messages, the
followings are necessary.

#+BEGIN_SRC emacs-lisp :tangle no
  ;; To use local mailbox "mbox" or "maildir" instead of POP
  (setq mew-mailbox-type 'mew)
  (setq new-mbox-command "incm")
  (setq mew-mbox-command-arg "-u -d /path/to/mbox")
  ;; If /path/to/mbox is a file, it means "mbox".
  ;; If /path/to/mbox is a directory, it means "maildir".
#+END_SRC

If you want to use IMAP to receive e-mail-messages, the followings are
necessary.

#+BEGIN_SRC emacs-lisp :tangle no
  (setq mew-proto "%")
  ;; (setq mew-imap-user "your IMAP account) ;; (user-login-name)
  (setq mew-imap-server "your IMAP server") ;; if not localhost
  ;; (setq mew-imap-ssl t)
  ;; (setq mew-imap-port "993)
  ;; (setq mew-prog-ssl-arg "fips=no\nverify=0\n")
#+END_SRC

To read and/or write articles of NetNews, the followings are
necessary.

#+BEGIN_SRC emacs-lisp :tangle no
  ;; (setq mew-nntp-user "your NNTP account")
  (setq mew-nntp-server "your NNTP server")
#+END_SRC

* elfeed
#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa/elfeed-20210822.2129")
        (add-to-list 'load-path "~/.emacs.d/elpa/elfeed-org-20250219.950")
        (require 'elfeed-org)
        (elfeed-org)
        (setq rmh-elfeed-org-files (list "~/org/elfeed.org"))))
#+END_SRC

* [[http://www.emacswiki.org/emacs/MalyonMode][Mylon]]

#+BEGIN_SRC emacs-lisp
  (require 'malyon)
#+END_SRC

* EPG/GPG

#+BEGIN_SRC emacs-lisp
  ;; Do not use gpg agent when runing in terminal
  (if (>= emacs-major-version 25)
      (progn
        (defadvice epg--start (around advice-epg-disable-agent activate)
          (let ((agent (getenv "GPG_AGENT_INFO")))
            (when (not (display-graphic-p))
              (setenv "GPG_AGENT_INFO" nil))
            ad-do-it
            (when (not (display-graphic-p))
              (setenv "GPG_AGENT_INFO" agent))))
        (pinentry-start)))
#+END_SRC

list who can decrypt a file:

#+BEGIN_SRC emacs-lisp
  (defun bba-epa-list-packets ()
    "List who can decrypt the current file"
    (interactive)
    (let ((bba-epa-filename (buffer-file-name))
      (bba-epa-packets-buffer (generate-new-buffer "*Packets*")))
      (set-buffer bba-epa-packets-buffer)
      (insert (shell-command-to-string (concat "gpg --batch --list-packets " bba-epa-filename)))
      (display-buffer bba-epa-packets-buffer)
   ))
#+END_SRC

#+BEGIN_SRC emacs-lisp :tangle no
  (defun bba-epa-list-packets ()
    "List who can decrypt the current file"
    (interactive)
    (require 'epa)
    (require 'epg)
    (let ((bba-epa-filename (buffer-file-name))
	  (bba-epa-packets-buffer (generate-new-buffer "*Packets*"))
	  (context (epg-make-context epa-protocol))
	  (epg-context-output-file context)
      )
      (set-buffer bba-epa-packets-buffer)
      ;; (setf (epg-context-output-file context))
      (epg--start context (list "--list-packets" bba-epa-filename))
      (epg-wait-for-completion context)
      (epg-read-output context)
   ))
#+END_SRC

If Emacs hangs while writing a gpg file we need this ignore wait

#+begin_src emacs-lisp
  (fset 'epg-wait-for-status 'ignore)
#+end_src

#+begin_src emacs-lisp
  (defun gs ()
    "gpg --card-status"
    (interactive)
    (shell-command "gpg --card-status")
    )
#+end_src
* auto-completion

#+BEGIN_SRC emacs-lisp
  (add-to-list 'load-path "~/.emacs.d/elpa/auto-complete-20250101.843")
  (require 'auto-complete-config)
  (add-to-list 'ac-dictionary-directories "~/.emacs.d/elpa/auto-complete-20250101.843")
  (add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
  (ac-config-default)
  (add-to-list 'ac-modes 'cfengine3-mode)
  (add-to-list 'ac-modes 'dns-mode)
  (add-to-list 'ac-sources 'ac-source-yasnippet)
  (add-to-list 'ac-sources 'org-mode)

  (setq ac-trigger-key "S-SPC")

#+END_SRC

* abbreviation

Watching [[https://www.youtube.com/watch?v%3DFtieBc3KptU][Emacs For Writers]] by [[https://github.com/incandescentman][Jay Dixit]] I had to configure abbreviations.

#+BEGIN_SRC emacs-lisp
  (setq abbrev-file-name "~/org/abbrev_defs")
  (if (file-exists-p abbrev-file-name)
      (quietly-read-abbrev-file))
  (set-default 'abbrev-mode t)
  (abbrev-mode )
  (setq save-abbrevs 'silently)
#+END_SRC

#+begin_src emacs-lisp
  (cond
   ((executable-find "aspell")
    (setq ispell-program-name "aspell")
    (setq ispell-extra-args '("--sug-mode=ultra" "--lang=en_US"))))
#+end_src

Combine abbrev with Ispell:

[[http://endlessparentheses.com/ispell-and-abbrev-the-perfect-auto-correct.html][Ispell and Abbrev, the Perfect Auto-Correct]]

#+BEGIN_SRC emacs-lisp
  (global-set-key (kbd "M-$") #'endless/ispell-word-then-abbrev)

  (defun endless/simple-get-word ()
    (car-safe (save-excursion (ispell-get-word nil))))

  (defun endless/ispell-word-then-abbrev (p)
    "Call `ispell-word', then create an abbrev for it.
  With prefix P, create local abbrev. Otherwise it will
  be global.
  If there's nothing wrong with the word at point, keep
  looking for a typo until the beginning of buffer. You can
  skip typos you don't want to fix with `SPC', and you can
  abort completely with `C-g'."
    (interactive "P")
    (let (bef aft)
      (save-excursion
        (while (if (setq bef (endless/simple-get-word))
                   ;; Word was corrected or used quit.
                   (if (ispell-word nil 'quiet)
                       nil ; End the loop.
                     ;; Also end if we reach `bob'.
                     (not (bobp)))
                 ;; If there's no word at point, keep looking
                 ;; until `bob'.
                 (not (bobp)))
          (backward-word)
          (backward-char))
        (setq aft (endless/simple-get-word)))
      (if (and aft bef (not (equal aft bef)))
          (let ((aft (downcase aft))
                (bef (downcase bef)))
            (define-abbrev
              (if p local-abbrev-table global-abbrev-table)
              bef aft)
            (message "\"%s\" now expands to \"%s\" %sally"
                     bef aft (if p "loc" "glob")))
        (user-error "No typo at or before point"))))

#+END_SRC

* [[https://www.emacswiki.org/emacs/stripes.el][stripes]]
[2017-07-11 Tue 15:17]

#+BEGIN_SRC emacs-lisp
  (load-file (expand-file-name "~/.emacs.d/lisp/stripes.el"))
  (custom-set-faces
   '(stripes-face ((t :background "gray0"))))

#+END_SRC
* syntax-highlighting
#+BEGIN_SRC emacs-lisp
  (font-lock-mode)
  (global-font-lock-mode 1)

#+END_SRC
* lsp
[2020-01-16 Thu 11:26]

#+begin_src sh :eval never
  cpan -i Complier::Lexer
  cpan -i Perl::LanguageServer
#+end_src

cpan only has Version 2.0.2.
thus installed via github.


#+begin_src emacs-lisp :tangle no
  (require 'lsp-mode)
  (require 'lsp-ui)
  (setq lsp-keymap-prefix "s-l")
  (add-hook 'sh-mode-hook #'lsp)
  ;; crashes currently in our configuration (add-hook 'cperl-mode-hook #'lsp)
  (setq lsp-ui-doc-enable t)
  (setq lsp-ui-doc-header t)
  (setq lsp-ui-doc-include-signature t)
  (setq lsp-ui-doc-position 'top)
  (setq lsp-ui-sideline-enable nil)
  (setq lsp-ui-sideline-ignore-duplicate t)
  (setq lsp-ui-sideline-show-code-actions nil)
  (add-hook 'sql-mode-hook 'lsp)
  (add-hook 'org-src-mode-hook 'lsp)
#+end_src

#+begin_src emacs-lisp :tangle no
  (lsp-define-stdio-client lsp-sql "sql"
                           (lsp-make-traverser #'(lambda (dir) (directory-files dir nil "sss.sql"))) '("~/.vscode/extensions/ms-mssql.mssql-1.4.0/sqltoolsservice/1.4.0/Ubuntu16/MicrosoftSqlToolsServiceLayer"))
#+end_src
* gptel
[2026-01-29 Thu 10:14]

#+begin_src emacs-lisp
  (if (file-exists-p "/usr/local/bin/ollama")
      (progn (require 'gptel)
             (gptel-make-ollama "Ollama"             ;Any name of your choosing
               :host "localhost:11434"               ;Where it's running
               :stream t                             ;Stream responses
               :models '(gpt-oss:20b))
             (setq
              gptel-model 'gpt-oss:20b
              gptel-backend (gptel-make-ollama "Ollama"
                              :host "localhost:11434"
                              :stream t
                              :models '(gpt-oss:20b))
              gptel-expert-commands t)
             (define-key global-map (kbd "C-c <return>") 'gptel-send)))
#+end_src

* sql
[2016-11-27 Sun 17:56]

#+begin_src emacs-lisp
  (load-file (expand-file-name "~/.emacs.d/lisp/sql.el"))


  (setq sql-imenu-generic-expression
        (append sql-imenu-generic-expression '(("Projections" "^\\s-*create\\s-+\\(?:\\w+\\s-+\\)*\\(?:projection\\)\\s-+?\\(\\(?:\\w+\\s-*[_.]\\s-*\\)*\\w+\\)" 1))))
#+end_src

thanks to https://truongtx.me/2014/08/23/setup-emacs-as-an-sql-database-client

have a look in [[file:/Applications/Emacs.app/Contents/Resources/lisp/progmodes/sql.el.gz::(let%20((connect-set%20(assoc-string%20connection%20sql-connection-alist%20t)))][sql.el]] and extract the sql-product and set it before
starting sql-connect.

#+BEGIN_SRC emacs-lisp
  (if (file-exists-p "~/.emacs_secrets.el.gpg")
  (progn (defun my-sql-connect ()
    (interactive)
    (require 'my-password "~/.emacs_secrets.el.gpg")
    (let ((connection (helm-comp-read
                       "Select server: "
                       my-sql-servers-alist
                       )))
      (message connection)
      (if current-prefix-arg
          (progn (let ((conname (sql-generate-unique-sqli-buffer-name (cdr (car (alist-get 'sql-product (assoc 'smaatotst sql-connection-alist)))) connection )))(sql-connect connection conname)))
        (sql-connect connection))))
  (global-set-key (kbd "s-s") 'my-sql-connect)))
#+END_SRC

your =~/.emacs_secrets.el.gpg= might look like:

#+BEGIN_SRC emacs-lisp :tangle never
  (setq my-sql-servers-alist
        '("bbaprd" "bbatst" "mysql"))

  (setq sql-connection-alist
        '((bbaprd (sql-product 'vertica)
                  (sql-server "host42.foo.com")
                  (sql-user "dbadmin")
                  (sql-password "foo")
                  (sql-database "bbaprd"))
          (bbatst (sql-product 'vertica)
                  (sql-server "host42.foo.com")
                  (sql-user "dbadmin")
                  (sql-password "foo")
                  (sql-database "bbatst"))
          (mysql  (sql-product 'mysql)
                  (sql-server "localhost")
                  (sql-user "root")
                  (sql-password "bar")
                  (sql-database "mysql")
                  (sql-mysql-options '("--init-command=SET AUTOCOMMIT=OFF")))))

  (provide 'my-password)
#+END_SRC


#+begin_src emacs-lisp
  (defun my-sql-save-history-hook ()
    (let ((lval 'sql-input-ring-file-name)
          (rval 'sql-product))
      (if (symbol-value rval)
          (let ((filename
                   (concat (if (equal "work" (getenv "SYSENV"))
                               "~/workorg/sql/"
                             "~/org/sql/")
                           (symbol-name (symbol-value rval))
                           "-history.sql")))
              (set (make-local-variable lval) filename))
          (error
           (format "SQL history will not be saved because %s is nil"
                   (symbol-name rval))))))

    (add-hook 'sql-interactive-mode-hook 'my-sql-save-history-hook)
#+end_src

incorporate helm-comint-mode-list

#+begin_src emacs-lisp
  (require 'sql)
  (require 'helm-comint)
  (defun helm-comint-sqli-input-ring ()
    "Preconfigured `helm' that provide completion of `comint' history."
    (interactive) ;; seq-contains helm-comint-mode-list major-mode
    (when (or (member major-mode helm-comint-mode-list)
              (derived-mode-p 'comint-mode))
      (helm :sources 'helm-comint-input-ring
            :input (buffer-substring-no-properties (comint-line-beginning-position)
                                                   (point-at-eol))
            :buffer "*helm comint history*")))

  (define-key sql-interactive-mode-map (kbd "M-p") 'helm-comint-sqli-input-ring)

#+end_src

#+begin_src emacs-lisp
  (require 'bicycle)
  (define-key outline-minor-mode-map [S-tab] 'bicycle-cycle)
  (defvar sql-outline-regexp "-- [*\^L]+"
    "Regular expression to match the beginning of a heading.
  Any line whose beginning matches this regexp is considered to start a heading.
  Note that Outline mode only checks this regexp at the start of a line,
  so the regexp need not (and usually does not) start with `^'.
  The recommended way to set this is with a Local Variables: list
  in the file it applies to.  See also `outline-heading-end-regexp'.")

    (add-hook 'sql-mode-hook
              (lambda ()
                (outline-minor-mode)
                (set (make-local-variable 'outline-regexp) sql-outline-regexp)))



#+end_src

* [[https://github.com/steckerhalter/sqlformat.el][sqlformat]]
[2016-08-19 Fri 16:20]

Provides the sqlformat command, which uses the external Python tool
sqlformat to format SQL in the current buffer.

Be aware that if the buffer is mixed code/SQL then you need to select
the SQL so that sqlformat only operates on the region, otherwise it
acts on the whole buffer.

On OS X you might want to run =sudo port install sqlparse= to have
=sqlformat= available.

#+BEGIN_SRC emacs-lisp
  (require 'sqlformat)

#+END_SRC

#+BEGIN_SRC emacs-lisp
  (add-hook 'sql-mode-hook
            (lambda ()
              (key-chord-define sql-mode-map "FF" 'sqlformat)))
#+END_SRC
* [[https://github.com/Trevoke/sqlup-mode.el][sqlup]]
[2016-11-24 Thu 13:31]

Takes care of doing upper-case for keywords.

#+BEGIN_SRC emacs-lisp
  (add-to-list 'load-path "~/.emacs.d/elpa/sqlup-mode-20170610.1537")
  (require 'sqlup-mode)
  (add-hook 'sql-mode-hook 'sqlup-mode)
  (add-hook 'sql-interactive-mode-hook 'sqlup-mode)
#+END_SRC
* [[https://github.com/alex-hhh/emacs-sql-indent][sql-indent]]
[2019-06-28 Fri 12:34]

#+BEGIN_SRC emacs-lisp
  (add-to-list 'load-path "~/.emacs.d/elpa/sql-indent-1.4")
  (require 'sql-indent)
  (add-hook 'sql-mode-hook 'sqlind-minor-mode)
#+END_SRC

* remove trailing whitespace
    [2014-09-24 Wed 16:56]

There are some file formats out there where you shouldn't use this
function. [[http://en.wikipedia.org/wiki/YAML][YAML]] is only one of them.
You can disable this functionality on a per file basis by adding lines
like these:

#+BEGIN_SRC cperl
    # Local Variables:
    # bba-keep-whitespaces: 1
    # End:
#+END_SRC

#+BEGIN_SRC emacs-lisp
  (eval-after-load "cfengine3-mode"
    '(add-hook 'cfengine3-mode-hook (lambda() (add-hook 'write-contents-functions
                                                   (lambda()
                                                      (unless (boundp 'bba-keep-whitespaces)
                                                        (save-excursion
                                                          (delete-trailing-whitespace))))))))


  (eval-after-load "cperl-mode"
    '(add-hook 'cperl-mode-hook (lambda() (add-hook 'write-contents-functions
                                                    (lambda()
                                                      (unless (boundp 'bba-keep-whitespaces)
                                                        (save-excursion
                                                          (delete-trailing-whitespace))))))))

  (eval-after-load "dns-mode"
    '(add-hook 'dns-mode-hook (lambda() (add-hook 'write-contents-functions
                                                  (lambda()
                                                    (save-excursion
                                                      (delete-trailing-whitespace)))))))

  (eval-after-load "js-mode"
    '(add-hook 'js-mode-hook (lambda() (add-hook 'write-contents-functions
                                                   (lambda()
                                                     (save-excursion
                                                       (delete-trailing-whitespace)))))))

  (eval-after-load "json-mode"
    '(add-hook 'json-mode-hook (lambda() (add-hook 'write-contents-functions
                                                   (lambda()
                                                     (unless (boundp 'bba-keep-whitespaces)
                                                      (save-excursion
                                                        (delete-trailing-whitespace))))))))

  (eval-after-load "org-mode"
    '(add-hook 'org-mode-hook (lambda() (add-hook 'write-contents-functions
                                                  (lambda()
                                                    (unless (boundp 'bba-keep-whitespaces)
                                                      (save-excursion
                                                        (delete-trailing-whitespace))))))))
  (eval-after-load "puppet-mode"
    '(add-hook 'puppet-mode-hook (lambda() (add-hook 'write-contents-functions
                                                   (lambda()
                                                      (unless (boundp 'bba-keep-whitespaces)
                                                        (save-excursion
                                                          (delete-trailing-whitespace))))))))

  (eval-after-load "python-mode"
    '(add-hook 'python-mode-hook (lambda() (add-hook 'write-contents-functions
                                                   (lambda()
                                                      (unless (boundp 'bba-keep-whitespaces)
                                                        (save-excursion
                                                          (delete-trailing-whitespace))))))))
  (eval-after-load "text-mode"
    '(add-hook 'text-mode-hook (lambda() (add-hook 'write-contents-functions
                                                   (lambda()
                                                     (unless (boundp 'bba-keep-whitespaces)
                                                       (save-excursion
                                                         (delete-trailing-whitespace))))))))



#+END_SRC

* rpm spec buildrpm
    [2015-07-23 Thu 13:22]

Use C-c C-c to run rpmbuild if buffer is spec file.

#+BEGIN_SRC emacs-lisp
  (defun bba-build-rpm ()
  "Do rpmbuild -ba, with the current buffers filename."
  (interactive)
  (string-match "\\([^:]*\\)$" buffer-file-name)
  (let* ((spec-file (match-string 1 buffer-file-name))
         )
    (compile (concat "rpmbuild -ba " spec-file))
    ;; (shell-command (concat "rpmbuild -ba " spec-file))
    )
  )

  (add-hook 'sh-mode-hook
            (lambda ()
              (progn
                (if (buffer-file-name)
                    (if (string-match ".spec$" buffer-file-name)
                        (define-key sh-mode-map "\C-c\C-c" 'bba-build-rpm)))
      )))

#+END_SRC

* undo tree

Use undo-tree.

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (global-undo-tree-mode)
    (setq undo-tree-enable-undo-in-region t))

#+END_SRC

* mode-line menu-bar etc

#+BEGIN_SRC emacs-lisp
  (column-number-mode t)
  (line-number-mode t)
  (setq display-time-24hr-format t)
  (display-time)

  ( if (not window-system)
      (menu-bar-mode -1)
    )

  (if window-system
      (progn
	(tool-bar-mode -1)
	(scroll-bar-mode -1)
	)
  )

  (setq initial-scratch-message "") ;; Uh, I know what Scratch is for

#+END_SRC

* Art Bollocks Mode
    [2014-09-28 Sun 22:33]

Keeps track of your writing.
Includes [[http://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch_Reading_Ease][Flesch Reading Ease]] and [[http://en.wikipedia.org/wiki/Flesch–Kincaid_readability_test#Flesch.E2.80.93Kincaid_Grade_Level][Flesch Grade Level]].
With modifications by [[http://sachachua.com/blog/2011/12/emacs-artbollocks-mode-el-and-writing-more-clearly/][Sacha Chua]].

#+BEGIN_SRC emacs-lisp
    (if (>= emacs-major-version 25)
        (progn
          (require 'artbollocks-mode)
          ;; Avoid these phrases
          (setq weasel-words-regex
                (concat "\\b" (regexp-opt
                               '("one of the"
                                 "should"
                                 "just"
                                 "sort of"
                                 "a lot"
                                 "probably"
                                 "maybe"
                                 "perhaps"
                                 "I think"
                                 "really"
                                 "pretty"
                                 "maybe"
                                 "nice"
                                 "action"
                                 "utilize"
                                 "leverage") t) "\\b"))
          ;; Fix a bug in the regular expression to catch repeated words
          (setq lexical-illusions-regex "\\b\\(\\w+\\)\\W+\\(\\1\\)\\b")
          ;; Don't show the art critic words, or at least until I figure
          ;; out my own jargon
          (setq artbollocks nil)
          ;; Make sure keywords are case-insensitive
          (defadvice search-for-keyword (around sacha activate)
            "Match in a case-insensitive way."
            (let ((case-fold-search t))
              ad-do-it))

          (add-hook 'text-mode-hook 'artbollocks-mode)
          (add-hook 'org-mode-hook  'artbollocks-mode)
          )
      )
#+END_SRC

* window management
    [2014-09-24 Wed 13:03]

Bind f3 and f4 to previous/next pane.
Bind shift f3 and shift f4 to previous/next frame.

#+BEGIN_SRC emacs-lisp
  (defun move-cursor-next-pane ()
    "Move cursor to the next pane."
    (interactive)
    (other-window 1))

  (defun move-cursor-previous-pane ()
    "Move cursor to the previous pane."
    (interactive)
    (other-window -1))

  (defun move-cursor-next-frame ()
    "Move cursor to the next frame."
    (interactive)
    (other-frame 1))

  (defun move-cursor-previous-frame ()
    "Move cursor to the previous frame."
    (interactive)
    (other-frame -1))

  (global-set-key (kbd "<f3>") 'move-cursor-previous-pane)
  (global-set-key (kbd "S-<f3>") 'move-cursor-previous-frame)
  (global-set-key (kbd "<f4>") 'move-cursor-next-pane)
  (global-set-key (kbd "S-<f4>") 'move-cursor-next-frame)
#+END_SRC

Right from [[https://gist.github.com/etherald/dcdcf579751c75a2c796][gisthub]]:

#+BEGIN_SRC emacs-lisp
  (defun twist-split ()
    (interactive)
    (setq buffer2 (window-buffer (second (window-list))))
    (if (window-top-child (frame-root-window))
    (progn (delete-other-windows) (split-window-horizontally))
    (progn (delete-other-windows) (split-window-vertically)))
    (set-window-buffer (second (window-list)) buffer2))
#+END_SRC

https://www.masteringemacs.org/article/demystifying-emacs-window-manager

#+begin_src emacs-lisp
  (defun mp-split-below (arg)
    "Split window below from the parent or from root with ARG."
    (interactive "P")
    (split-window (if arg (frame-root-window)
                    (window-parent (selected-window)))
                  nil 'below nil))

  (defun mp-split-right (arg)
    "Split window below from the parent or from root with ARG."
    (interactive "P")
    (split-window (if arg (frame-root-window)
                    (window-parent (selected-window)))
                  nil 'right nil))
#+end_src

#+begin_src emacs-lisp
  (defun toggle-maximize-buffer ()
    "Maximize buffer"
    (interactive)
    (if (= 1 (length (window-list)))
        (jump-to-register '_)
      (progn
        (window-configuration-to-register '_)
        (delete-other-windows))))
#+end_src

* [[https://github.com/dotemacs/ipcalc.el][ipcalc]]
#+BEGIN_SRC emacs-lisp
      (require 'ipcalc)

#+END_SRC
* AWS sessionmanager ssm
[2022-08-11 Thu 10:02]

Somebody decided to replace ssh with [[https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html][AWS Session Manager]]
As a heavy user of Emacs TRAMP i was not very happy with that.

In the beginning I was using [[https://github.com/xen0l/aws-gate][aws-gate]].
With more changes in our environment this stopped working for me.
After I wrote my own wrapper for the aws cli command - [[https://github.com/baron42bba/ec2-connect][ec2-connect]] -
everything was good again.

#+begin_src elisp
  (require 'tramp)
  (eval-after-load "tramp"
    '(progn
       (add-to-list 'tramp-methods
                    '("ssm"
                      (tramp-login-program        "ec2-connect")
                      (tramp-login-args           (("--name")("%h") ("2>/dev/null")))
                      (tramp-remote-shell         "/bin/sh")
                      (tramp-remote-shell-login   ("-l"))
                      (tramp-remote-shell-args    ("-c"))))
       (tramp-set-completion-function "ssm" tramp-completion-function-alist-ssh)))

#+end_src

Now we can again do strange, dark org-babel magic like:

#+begin_src org :eval never
  ,#+begin_src sh :dir /ssm:host01|sudo:host01:
   date
  ,#+end_src
#+end_src

* [[http://www.emacswiki.org/emacs/RecentFiles][RecentFiles]]

#+BEGIN_SRC emacs-lisp
  (require 'recentf)
  (recentf-mode 1)
  (setq recentf-max-saved-items 200
        recentf-max-menu-items 142)
  (if (<= emacs-major-version 23)
      (global-set-key "\C-cr" 'recentf-open-files))
#+END_SRC

* insert-date function

#+BEGIN_SRC emacs-lisp
  (defun bba-insert-date ()
  "Insert the current date"
  (interactive)
  (insert (format-time-string "%B %e, %Y")))

  (defun bba-insert-sql-date ()
  "Insert the current date as sql"
  (interactive)
  (insert (format-time-string "'%Y-%m-%d'")))


  (defun bba-insert-timestamp ()
  "Insert the current timestamp"
  (interactive)
  (insert (format-time-string "%Y%m%d-%H%M")))

  (defun bba-insert-name-timestamp ()
  "Insert the current timestamp"
  (interactive)
  (insert (format-time-string "%a %b %e %Y") " " (or (and (boundp 'user-full-name) user-full-name) (user-full-name))" <" (getenv "EMAIL") ">" ))

  (defun bba-insert-name ()
  "Insert name and emailaddress of current systemuser."
  (interactive)
  (insert (or (and (boundp 'user-full-name) user-full-name) (user-full-name))" <" (getenv "EMAIL") ">" ))
  (define-key global-map (kbd "s-n") 'bba-insert-name)

  (defun bba-insert-changelog-signature ()
    "Insert name and timestamp in changelog format."
    (interactive)
    (insert " -- " (or (and (boundp 'user-full-name) user-full-name) (user-full-name))" <" (getenv "EMAIL") ">  " (format-time-string "%a, %d %b %Y %H:%M:%S %z")))
#+END_SRC

* toggle fullscreen mode
[2016-06-22 Wed 14:23]

toggle full screen with super return. display battery status in
fullscreen mode. disable scroll bar in fullscreen mode.

#+BEGIN_SRC emacs-lisp
  (defun bba-toggle-fullscreen()
    "toggle fullscreen mode"
    (interactive)
    (if (equal 'fullboth (frame-parameter nil 'fullscreen))
        (progn (set-frame-parameter nil 'fullscreen 'maximized)
               (display-battery-mode -1)
               (display-time-mode -1)
               (scroll-bar-mode -1)
               )
      (progn (set-frame-parameter nil 'fullscreen 'fullboth)
             (display-battery-mode 1)
             (display-time-mode 1)
             (scroll-bar-mode -1)
             )
        )
    )
  (global-set-key (kbd "s-<return>") 'bba-toggle-fullscreen)
#+END_SRC

* generate passwords
[2017-05-31 Wed 16:33]

#+BEGIN_SRC emacs-lisp
  (defun bba-insert-pw(v2)
  "insert password"
  (interactive "P")
  (if v2
      (insert (shell-command-to-string "password2.pl"))
    (insert (shell-command-to-string "password.pl"))
    )
  )
  (define-key global-map (kbd "s-p") 'bba-insert-pw)
#+END_SRC

* [[http://www.howardism.org/Technical/Emacs/eshell-fun.html][eshell-here]]
Thanks to Howard Abrams.
modified because current version lacks function have
window-total-height.

Bound to =C-X l !=

#+BEGIN_SRC emacs-lisp
  (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))
      (split-window-vertically '-10)
      (other-window 1)
      (eshell "new")
      (rename-buffer (concat "*eshell: " name "*"))

      (insert (concat "ls"))
      (eshell-send-input)))

  (defun eshell/x ()
    (insert "exit")
    (eshell-send-input)
    (delete-window))



  (defun eshell/ssh (&rest args)
  "Secure shell"
  (let ((cmd (eshell-flatten-and-stringify
  (cons "ssh" args)))
  (display-type (framep (selected-frame))))
  (cond
  ((and
  (eq display-type 't)
  (getenv "STY"))
  (send-string-to-terminal (format "\033]83;screen %s\007" cmd)))
  ((eq display-type 'x)
  (eshell-do-eval
  (eshell-parse-command
  (format "rxvt -e %s &" cmd)))
  nil)
  (t
  (apply 'eshell-exec-visual (cons "ssh" args))))))


  (defun eshell-client (&optional arg)
    "Opens up a new shell in the directory passed as argument.
  The eshell is renamed to match that directory to make multiple
  eshell windows easier."
    (interactive)
    (let* ((name (if arg
                       arg
                     default-directory))
       ;;    (height (/ (window-total-height) 3))
           )
      (eshell "new")
      (rename-buffer (concat "*eshell: " name "*"))

      (insert (concat "ls"))
      (eshell-send-input)))
#+END_SRC

Run commands via vterm

#+begin_src emacs-lisp
  (defalias 'eshell/v 'eshell-exec-visual)
#+end_src

https://fuco1.github.io/2017-10-08-Using-bookmarks-with-eshell-and-docker-tramp.html

#+begin_src emacs-lisp
  (add-hook 'eshell-mode-hook 'eshell-bookmark-setup)
#+end_src

* [[http://stackoverflow.com/questions/3035337/in-emacs-can-you-evaluate-an-emacs-lisp-expression-and-replace-it-with-the-resul][eval emacs lisp expression and replace it]]
    [2014-11-02 Sun 18:21]

Use =C-c E= to evaluate and replace the last s-expression.

#+BEGIN_SRC emacs-lisp
  (defun bba/eval-last-sexp-replace ()
    "replace the last s-expression with its evaluated result"
    (interactive)
    (backward-kill-sexp)
    (prin1 (eval (read (current-kill 0)))
           (current-buffer)))

  (define-key global-map "\C-c\S-e" 'bba/eval-last-sexp-replace)
#+END_SRC

* goto-match-paren
#+BEGIN_SRC emacs-lisp
      (defun goto-match-paren (arg)
        "Go to the matching parenthesis if on parenthesis, otherwise insert %.
      vi style of % jumping to matching brace."
        (interactive "p")
        (cond ((looking-at "\\s\(") (forward-list 1) (backward-char 1))
              ((looking-at "\\s\)") (forward-char 1) (backward-list 1))
              (t (self-insert-command (or arg 1)))))
      (global-set-key "%" 'goto-match-paren)

#+END_SRC

* safe hash bang files executable
safe files with #! in first line as user executable.

#+BEGIN_SRC emacs-lisp
  (add-hook `after-save-hook
            #'(lambda ()
                (if (not
                     (or
                      (string-match ".htm" buffer-file-name)
                      (string-match ".org" buffer-file-name))
                     )
                    (check-parens))

                (and (save-excursion
                       (save-restriction
                         (widen)
                         (goto-char (point-min))
                         (save-match-data
                           (looking-at "^#!"))))
                     (if (file-remote-p buffer-file-name)
                         (progn
                           (not (file-executable-p buffer-file-name))
                           (shell-command (concat "chmod u+x " (file-name-nondirectory buffer-file-name)))
                           (message
                            (concat "Saved as script via tramp: " buffer-file-name))
                           )
                       (progn
                         (not (file-executable-p buffer-file-name))
                         (shell-command (concat "chmod u+x " buffer-file-name))
                         (message
                          (concat "Saved as script: " buffer-file-name)))))))

#+END_SRC

* fill-or-unfill paragraph
[2017-06-09 Fri 12:25]

#+BEGIN_SRC emacs-lisp
  (defun bba-fill-or-unfill ()
    "Like `fill-paragraph', but unfill if used twice."
    (interactive)
    (let ((fill-column
           (if (eq last-command 'bba-fill-or-unfill)
               (progn (setq this-command nil)
                      (point-max))
             fill-column)))
      (call-interactively 'fill-paragraph)))

  (global-set-key [remap fill-paragraph]
                  'bba-fill-or-unfill)
#+END_SRC

* Move Cursor to Beginning of Line/Paragraph
[2017-03-02 Thu 13:46]

Thanks to [[http://ergoemacs.org/emacs/emacs_keybinding_design_beginning-of-line-or-block.html][Xah Lee]]:

#+BEGIN_SRC emacs-lisp
  (defun xah-beginning-of-line-or-block ()
    "Move cursor to beginning of line, or beginning of current or previous text block.

  • When called first time, move cursor to beginning of line.
  • When called again, move cursor to beginning of paragraph.
  • When called again, move cursor to beginning of previous paragraph.

  URL `http://ergoemacs.org/emacs/emacs_keybinding_design_beginning-of-line-or-block.html'
  Version 2017-01-17"
    (interactive)
    (if (or (equal (point) (line-beginning-position))
            (equal last-command this-command ))
	(if (re-search-backward "\n[\t\n ]*\n+" nil "NOERROR")
            (skip-chars-backward "\n\t ")
          (goto-char (point-min)))
      (beginning-of-line)))


  (defun xah-end-of-line-or-block ()
    "Move cursor to end of line, or end of current or next text block.

  • When called first time, move cursor to end of line.
  • When called again, move cursor to end of paragraph.
  • When called again, move cursor to end of next paragraph.

  URL `http://ergoemacs.org/emacs/emacs_keybinding_design_beginning-of-line-or-block.html'
  Version 2017-01-17"
    (interactive)
    (if (or (equal (point) (line-end-position))
            (equal last-command this-command ))
	(re-search-forward "\n[\t\n ]*\n+" nil "NOERROR" )
      (end-of-line)))

  (global-set-key (kbd "s-a") 'xah-beginning-of-line-or-block)
  (global-set-key (kbd "s-e") 'xah-end-of-line-or-block)
#+END_SRC

* move cursor on this and next window
[2022-12-27 Tue 15:48]

sometimes you have to diff files manually.
Here we have some functions to move the cursor on the current and next
window.

#+begin_src emacs-lisp
  (defun bba-cursor-up ()
   "Move cursor up here and next window."
   (interactive)
   (previous-line)
   (move-cursor-next-pane)
   (previous-line)
   (if hl-line-mode (hl-line-highlight))
   (move-cursor-previous-pane)
   )

  (defun bba-cursor-down ()
   "Move cursor down here and next window."
   (interactive)
   (next-line)
   (move-cursor-next-pane)
   (next-line)
   (if hl-line-mode (hl-line-highlight))
   (move-cursor-previous-pane)
   )

  (defun bba-cursor-left ()
   "Move cursor left here and next window."
   (interactive)
   (left-char)
   (move-cursor-next-pane)
   (left-char)
   (move-cursor-previous-pane)
   )

  (defun bba-cursor-right ()
   "Move cursor rioht here and next window."
   (interactive)
   (right-char)
   (move-cursor-next-pane)
   (right-char)
   (move-cursor-previous-pane)
   )

  (define-key global-map (kbd "s-<up>") 'bba-cursor-up)
  (define-key global-map (kbd "s-<down>") 'bba-cursor-down)
  (define-key global-map (kbd "s-<right>") 'bba-cursor-right)
  (define-key global-map (kbd "s-<left>") 'bba-cursor-left)
#+end_src

* move lines
    [2014-11-11 Tue 12:24]

=M-p= and =M-n= to move current line up or down.

#+BEGIN_SRC emacs-lisp
  (defun bba/move-line (n)
    "Move the current line up or down by N lines."
    (interactive "p")
    (let* ((column (current-column))
           (start (progn (beginning-of-line) (point)))
           (end (progn (end-of-line) (forward-char) (point)))
           (line-text (delete-and-extract-region start end)))
      (forward-line n)
      (insert line-text)
      (forward-line -1)
      (forward-char column)))

  (defun bba/move-line-up (n)
    "Move the current line up by N lines."
    (interactive "p")
    (bba/move-line (if (null n) -1 (- n))))

  (defun bba/move-line-down (n)
    "Move the current line down by N lines."
    (interactive "p")
    (bba/move-line (if (null n) 1 n)))

  (define-key global-map (kbd "M-p") 'bba/move-line-up)
  (global-set-key (kbd "M-n") 'bba/move-line-down)

#+END_SRC

* [[http://ergoemacs.org/emacs/emacs_copy_cut_current_line.html][xah-copy-line-or-region]]
[2017-03-17 Fri 14:07]

#+BEGIN_SRC emacs-lisp
  (defun xah-copy-line-or-region ()
    "Copy current line, or text selection.
  When called repeatedly, append copy subsequent lines.
  When `universal-argument' is called first, copy whole buffer (respects `narrow-to-region').

  URL `http://ergoemacs.org/emacs/emacs_copy_cut_current_line.html'
  Version 2016-06-18"
    (interactive)
    (let (-p1 -p2)
      (if current-prefix-arg
          (setq -p1 (point-min) -p2 (point-max))
	(if (use-region-p)
            (setq -p1 (region-beginning) -p2 (region-end))
          (setq -p1 (line-beginning-position) -p2 (line-end-position))))
      (if (eq last-command this-command)
          (progn
            (progn ; hack. exit if there's no more next line
              (end-of-line)
              (forward-char)
              (backward-char))
            ;; (push-mark (point) "NOMSG" "ACTIVATE")
            (kill-append "\n" nil)
            (kill-append (buffer-substring-no-properties (line-beginning-position) (line-end-position)) nil)
            (message "Line copy appended"))
	(progn
          (kill-ring-save -p1 -p2)
          (if current-prefix-arg
              (message "Buffer text copied")
            (message "Text copied"))))
      (if (not (use-region-p))
	  (progn
	    (end-of-line)
	    (forward-char))
      )))

  (define-key global-map (kbd "M-w") 'xah-copy-line-or-region)
#+END_SRC

* bba copy line or region to iterm
[2018-10-10 Wed 12:11]

Based on xah-copy-line-or-region I wrote a version which copies just
the current line or region ( no append) and insert it via Keyboard
Maestro in my iterm. Quite useful to execute SQL commands in a remote
gnu screen session. I don't append a newline thus I can still verify
the clipboard content before executing it.

#+BEGIN_SRC emacs-lisp
  (defun bba-copy-line-or-region-to-iterm ()
    "Copy current line, or text selection and insert it in iterm via Keyboard Maestro.
  When `universal-argument' is called first, copy whole buffer (respects `narrow-to-region')."

    (interactive)
    (let (-p1 -p2)
      (if current-prefix-arg
          (setq -p1 (point-min) -p2 (point-max))
        (if (use-region-p)
            (setq -p1 (region-beginning) -p2 (region-end))
          (setq -p1 (line-beginning-position) -p2 (line-end-position))))
      (progn
        (kill-ring-save -p1 -p2)
        (if current-prefix-arg
            (message "Buffer text copied")
          (message "Text copied")))
      (if (not (use-region-p))
          (progn
            (end-of-line)
            (forward-char))
        ))
    (shell-command "osascript -e \'tell app \"Keyboard Maestro Engine\" to do script \"iterm-insert-clipboard\"'" )
    )

  (define-key global-map (kbd "s-w") 'bba-copy-line-or-region-to-iterm)
#+END_SRC

* bba monitor buffer changes
[2021-08-05 Thu 09:59]

With some code from http://howardism.org/Technical/Emacs/beep-for-emacs.html

#+begin_src emacs-lisp
  (if (string-equal system-type "darwin")
      (progn
        (require 'log4e)
        (require 'alert)

        (setq alert-default-style 'osx-notifier)

        (defvar beep-speech-executable "say %s"
          "An OS-dependent shell string to speak. Replaces `%s' with a phrase.")

        (defvar beep-alert-sound-file
          (expand-file-name "/System/Library/Sounds/Submarine.aiff")
          "A WAV or AU file used at the completion of a function.")

        (defun beep--beep ()
          "Play a default notification sound file.
  Customize the variable, `beep-alert-sound-file' to adjust the sound."
          (play-sound-file beep-alert-sound-file))

        (defun beep--speak (phrase)
          "Call a program to speak the string, PHRASE.
  Customize the variable, `beep-speech-executable'."
          (let ((command (format beep-speech-executable phrase))
                (inhibit-message t))
            (shell-command command)))

        (defun beep--when-finished (phrase)
          "Notify us with string, PHRASE, to grab our attention.
  Useful after a long process has completed, but use sparingly,
  as this can be pretty distracting."
          (message phrase)
          (alert phrase :title "Completed")
          (beep--beep)
          (beep--speak phrase))

        (defun bba-notify-hook(beg end _)
          "notify after changes and remove hook."
          (beep--when-finished "The command has completed")
          (remove-hook 'after-change-functions 'bba-notify-hook t)
          )

        (defun bba-add-notify-hook()
          "add notify hook."
          (interactive)
          (if (buffer-file-name)
              (save-buffer)
            (set-buffer-modified-p nil)) ;; set buffer as unmodified
          (make-local-variable 'after-change-functions)
          (add-hook 'after-change-functions 'bba-notify-hook nil t))))
#+end_src

* bba lookup dictionary
[2019-05-27 Mon 15:15]
coffee mug
#+BEGIN_SRC emacs-lisp
  (defun bba-dict ()
  "Lookup thing at point in OS X Dictionary."
  (interactive)
  (if (use-region-p)
      (shell-command (concat "open dict://\"" (buffer-substring-no-properties (region-beginning)(region-end)) "\""))
    (shell-command (concat "open dict://" (thing-at-point 'symbol)))
    )
  )
  (define-key global-map (kbd "s-L") 'bba-dict)

#+END_SRC


* [[http://ergoemacs.org/emacs/emacs_navigating_keys_for_brackets.html][Xah Lee Move cursor to Bracket]]
[2017-03-27 Mon 22:41]

#+BEGIN_SRC emacs-lisp
  (defvar xah-brackets nil "string of left/right brackets pairs.")
  (setq xah-brackets "()[]{}<>（）［］｛｝⦅⦆〚〛⦃⦄“”‘’‹›«»「」〈〉《》【】〔〕⦗⦘『』〖〗〘〙｢｣⟦⟧⟨⟩⟪⟫⟮⟯⟬⟭⌈⌉⌊⌋⦇⦈⦉⦊❛❜❝❞❨❩❪❫❴❵❬❭❮❯❰❱❲❳〈〉⦑⦒⧼⧽﹙﹚﹛﹜﹝﹞⁽⁾₍₎⦋⦌⦍⦎⦏⦐⁅⁆⸢⸣⸤⸥⟅⟆⦓⦔⦕⦖⸦⸧⸨⸩｟｠⧘⧙⧚⧛⸜⸝⸌⸍⸂⸃⸄⸅⸉⸊᚛᚜༺༻༼༽⏜⏝⎴⎵⏞⏟⏠⏡﹁﹂﹃﹄︹︺︻︼︗︘︿﹀︽︾﹇﹈︷︸")

  (defvar xah-left-brackets '("(" "{" "[" "<" "〔" "【" "〖" "〈" "《" "「" "『" "“" "‘" "‹" "«" )
    "List of left bracket chars.")
  (progn
  ;; make xah-left-brackets based on xah-brackets
    (setq xah-left-brackets '())
    (dotimes (-x (- (length xah-brackets) 1))
      (when (= (% -x 2) 0)
	(push (char-to-string (elt xah-brackets -x))
              xah-left-brackets)))
    (setq xah-left-brackets (reverse xah-left-brackets)))

  (defvar xah-right-brackets '(")" "]" "}" ">" "〕" "】" "〗" "〉" "》" "」" "』" "”" "’" "›" "»")
    "list of right bracket chars.")
  (progn
    (setq xah-right-brackets '())
    (dotimes (-x (- (length xah-brackets) 1))
      (when (= (% -x 2) 1)
	(push (char-to-string (elt xah-brackets -x))
              xah-right-brackets)))
    (setq xah-right-brackets (reverse xah-right-brackets)))

  (defun xah-backward-left-bracket ()
    "Move cursor to the previous occurrence of left bracket.
  The list of brackets to jump to is defined by `xah-left-brackets'.
  URL `http://ergoemacs.org/emacs/emacs_navigating_keys_for_brackets.html'
  Version 2015-10-01"
    (interactive)
    (search-backward-regexp (regexp-opt xah-left-brackets) nil t))

  (defun xah-forward-right-bracket ()
    "Move cursor to the next occurrence of right bracket.
  The list of brackets to jump to is defined by `xah-right-brackets'.
  URL `http://ergoemacs.org/emacs/emacs_navigating_keys_for_brackets.html'
  Version 2015-10-01"
    (interactive)
    (re-search-forward (regexp-opt xah-right-brackets) nil t))

  (define-key global-map (kbd "s-,") 'xah-backward-left-bracket)
  (define-key global-map (kbd "s-.") 'xah-forward-right-bracket)
#+END_SRC

* copy buffer file name to kill ring

Sometimes you need the filename of your current buffer on the command
line or somewhere else.

#+BEGIN_SRC emacs-lisp
  (defun bba-copy-buffer-name ()
    "copy buffer name to kill-ring. if `universal-argument` is called first, copy only filename to kill-ring."
    (interactive)
    (let* ((bba-buffer-name (if current-prefix-arg (file-name-nondirectory (buffer-file-name))
			      (buffer-file-name)
			      )))
      (kill-new bba-buffer-name)
    (message ( format "stored '%s' in kill-ring" bba-buffer-name))
    ))
#+END_SRC

* remove element from kill-ring
[2017-02-15 Wed 11:59]

sometimes you have credentials or other secret stuff in your kill-ring.
savehist is nice but you don't want to store it in the history.

#+BEGIN_SRC emacs-lisp
  (defun bba-rm-kill-ring ()
  "remove current element from kill-ring."
  (interactive)
  (progn (pop kill-ring) nil)
  (message  "removed item from kill-ring")
  )

  (defun bba-yank-rm-kill-ring ()
  "yank and then remove element from kill ring"
  (interactive)
  (insert (pop kill-ring))
  )
  (define-key global-map (kbd "s-y") 'bba-yank-rm-kill-ring)
  (define-key global-map (kbd "s-Y") 'bba-rm-kill-ring)

#+END_SRC

* ggtags

Configure [[https://github.com/leoliu/ggtags][ggtags]] and [[https://github.com/syohex/emacs-helm-gtags][helm-gtags]] to use [[https://www.gnu.org/software/global/][GNU Global]].
If you are new to tags check [[http://tuhdo.github.io/c-ide.html][this]].

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa/ggtags-20230602.133" t)
        (require 'ggtags)
        (add-to-list 'load-path "~/.emacs.d/elpa/helm-gtags-20240925.755" t)
        (require 'helm-gtags)
        (add-hook 'puppet-mode-hook
                  (lambda()
                    (if (locate-dominating-file (file-name-directory buffer-file-name) "GTAGS")
                        (ggtags-mode 1)
                      (helm-gtags-mode 1))))
        (add-hook 'python-mode-hook
                  (lambda()
                    (if (locate-dominating-file (file-name-directory buffer-file-name) "GTAGS")
                        (ggtags-mode 1)
                      (helm-gtags-mode 1))))
        (add-hook 'cperl-mode-hook
                  (lambda()
                    (if (locate-dominating-file (file-name-directory buffer-file-name) "GTAGS")
                        (ggtags-mode 1)
                      (helm-gtags-mode 1))))
        ))
#+END_SRC

* projectile
[2025-01-07 Tue 15:10]

#+begin_src emacs-lisp
  (projectile-mode +1)
  (define-key projectile-mode-map (kbd "C-c s-p") 'projectile-command-map)
#+end_src

* helm

Some links you might check out:

- [[http://tuhdo.github.io/helm-intro.html][A Package in a league of its own: Helm]]
- [[http://wikemacs.org/wiki/Helm][Helm - WikEmacs]]
- [[http://emacs.stackexchange.com/questions/2867/how-should-i-change-my-workflow-when-moving-from-ido-to-helm][How should I change my workflow when moving from IDO to Helm - Emacs
  Stack Exchange]]
- [[https://github.com/ShingoFukuyama/helm-swoop][helm-swoop]]

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
	(add-to-list 'load-path
                     "~/.emacs.d/elpa/helm-20251212.555")
	(require 'helm)
	(helm-mode 1)
	(global-set-key (kbd "M-y") 'helm-show-kill-ring)
	(global-set-key (kbd "C-c w") 'helm-man-woman)
	(global-set-key (kbd "M-x") #'helm-M-x)
	(global-set-key "\C-cr" 'helm-recentf)
	(global-set-key (kbd "M-s o") 'helm-occur)
	(define-key global-map "\C-x\C-b" 'helm-buffers-list)
	(define-key global-map "\C-x\C-k\C-h" 'helm-execute-kmacro)
	(define-key global-map (kbd "C-x r b") 'helm-bookmarks)
	(define-key global-map (kbd "C-x C-f") 'helm-find-files)
	(define-key global-map "\C-cy" 'helm-yas-complete)
      (define-key org-mode-map "\C-ci" 'helm-org-in-buffer-headings)
	(setq helm-yas-display-key-on-candidate t)
	(setq helm-buffer-max-length nil)

	(add-hook 'eshell-mode-hook
                  #'(lambda()
                      (define-key eshell-mode-map
			[remap eshell-pcomplete]
			'helm-esh-pcomplete)
                      (define-key eshell-mode-map
			(kbd "M-p")
			'helm-eshell-history)
                      ))
	(add-hook 'shell-mode-hook
                  #'(lambda()
                      (define-key shell-mode-map
			[remap comint-history-isearch-backward-regexp]
			'helm-comint-input-ring)
                      ))
	(setq helm-mini-default-sources '(helm-source-buffers-list
                                          helm-source-recentf
                                          helm-source-bookmarks
                                          helm-source-buffer-not-found))
	(define-key global-map "\C-xb" 'helm-mini)
	)
  )

#+END_SRC

* helm-descbinds

#+BEGIN_SRC emacs-lisp
  (if (>= emacs-major-version 24)
      (progn
        (add-to-list 'load-path "~/.emacs.d/elpa/helm-descbinds-20190501.935")
        (require 'helm-descbinds)
        (define-key global-map (kbd "C-h b") 'helm-descbinds)
        )
  )
#+END_SRC

* browser switch

switch default browser between eww and default.

#+BEGIN_SRC emacs-lisp
  (defun bba-switch-default-browser ()
      "switch between default browser and eww"
    (interactive)
    (if (string-equal "browse-url-default-browser" browse-url-browser-function)
        (setq browse-url-browser-function 'eww-browse-url)
      (setq browse-url-browser-function 'browse-url-default-browser)
      )
    (message "%s" browse-url-browser-function)
    )

#+END_SRC

* keyfreq
[2016-11-23 Wed 13:33]

#+BEGIN_SRC emacs-lisp
  (add-to-list 'load-path "~/.emacs.d/elpa/keyfreq-20231107.106")
  (require 'json)
  (require 'keyfreq)
  (keyfreq-mode 1)
  (keyfreq-autosave-mode 1)
#+END_SRC

* no-rsi
[2016-12-06 Tue 10:35]



#+BEGIN_SRC emacs-lisp
  (if (string-equal system-type "darwin")
      (setq type-break-keystroke-threshold '(3600 . 18000))
    (type-break-mode t))
#+END_SRC

* aliases

#+BEGIN_SRC emacs-lisp
  (defalias 'ts 'transpose-sentences)
  (defalias 'tp 'transpose-paragraphs)
  (defalias 'om 'org-mode)
  (defalias 'vsql 'sql-vertica)
  (defalias 'mysql 'sql-mysql)
#+END_SRC

* [[http://mbork.pl/2015-10-31_Smart_comma_and_other_punctuation][smart comma]]

Thanks to Marcin Borkowski for this code snippet.

#+BEGIN_SRC emacs-lisp
(defun smart-self-insert-punctuation (count)
  "If COUNT=1 and the point is after a space, insert the relevant
character before any spaces."
  (interactive "p")
  (if (and (= count 1)
           (eq (char-before) ?\s))
      (save-excursion
        (skip-chars-backward " ")
        (self-insert-command 1))
    (self-insert-command count)))

(global-set-key "," #'smart-self-insert-punctuation)

#+END_SRC

* key bindings

#+BEGIN_SRC emacs-lisp
  (if (string-equal system-type "darwin")
      (progn (setq mac-command-modifier 'super)
             (setq mac-option-modifier 'meta)))

  (define-key global-map (kbd "M-@") 'cycle-spacing)
  (define-key global-map (kbd "M-SPC") 'cycle-spacing)
  ;; (define-key global-map (kbd "S-SPC") 'dabbrev-expand)
  (define-key global-map (kbd "S-SPC") 'hippie-expand)

  (setq hippie-expand-try-functions-list
        '(try-expand-dabbrev
          try-expand-dabbrev-all-buffers
          try-complete-file-name-partially
          try-complete-file-name
          try-expand-all-abbrevs
          try-expand-list
          try-expand-line
          try-expand-dabbrev-from-kill
          try-complete-lisp-symbol-partially
          try-complete-lisp-symbol))

  (define-key global-map (kbd "s-r") 'repeat)
  (define-key global-map "\C-x\S-f" 'find-file-at-point)

  (define-key global-map "\C-c\S-t" 'visit-tags-table)
  (define-key global-map "\C-cf" 'tags-search)

  (define-key global-map (kbd "s-c") #'(lambda () "insertwhichfunc" (interactive)(insert (which-function))))
  (define-key sql-mode-map (kbd "s-D") 'bba-insert-sql-date)
  (define-key sql-interactive-mode-map (kbd "s-D") 'bba-insert-sql-date)
  (define-key global-map (kbd "s-b") 'clone-indirect-buffer)
  (define-key global-map (kbd "s-m") 'toggle-maximize-buffer)
   (define-key global-map (kbd "M-s-m") 'maximize-window)

  (define-key global-map (kbd "s-t") 'twist-split)

  (define-key global-map (kbd "C-c M-s") 'string-edit-at-point)

  (define-key global-map (kbd "s-i") 'indent-region)

  (define-key global-map "\C-cp" 'org-mark-ring-push)
  (define-key global-map "\C-cn" 'org-mark-ring-goto)

  (define-prefix-command 'bba/toggle)
  (define-key global-map "\C-ct" 'bba/toggle)

  (define-key bba/toggle "\S-a" 'abbrev-mode)
  (define-key bba/toggle "a" 'artbollocks-mode)
  (define-key bba/toggle "b" 'bba-switch-default-browser)
  (define-key bba/toggle "c" 'rainbow-mode)
  (define-key bba/toggle "\S-c" 'bba-toggle-copyright-update)
  (define-key bba/toggle "e" 'eldoc-mode)
  (define-key bba/toggle "\S-e" 'epoch-view-mode)
  (define-key bba/toggle "f" 'auto-fill-mode)
  (define-key bba/toggle "\S-f" 'follow-mode)
  (define-key bba/toggle "h" 'highlight-indentation-mode)
  (define-key bba/toggle "\S-h" 'highlight-indentation-current-column-mode)
  (define-key bba/toggle "\C-h" 'hl-line-mode)
  (define-key bba/toggle "\M-h" 'highlight-symbol-mode)
  (define-key bba/toggle "p" 'smartparens-mode)
  (define-key bba/toggle "r" 'rainbow-delimiters-mode)
  (define-key bba/toggle "s" 'flyspell-mode)
  (define-key bba/toggle (kbd "s-s") 'stripes-mode)
  (define-key bba/toggle "\S-s" 'smerge-mode)
  (define-key bba/toggle "t" 'toggle-truncate-lines)
  (define-key bba/toggle "v" 'visual-line-mode)
  (define-key bba/toggle "\S-w" 'which-function-mode)

  (define-key dired-mode-map "/" 'dired-narrow-regexp)
#+END_SRC

easy access to secrets.

#+BEGIN_SRC emacs-lisp
  (defun bba-pw-lookup (id)
    "lookup org id and grab hide-pw entry"
    (interactive)
    (org-id-goto id)
    (if (invisible-p (point-at-eol))
        (org-cycle))
    (if (re-search-forward "^||")
        (progn
          (set-mark-command nil)
          (org-end-of-line)
          (backward-char 2)
          (kill-ring-save 1 1 1)
          (org-previous-visible-heading 1)
          (org-end-of-line)
          (org-beginning-of-line)
      (previous-buffer))))
#+END_SRC

duplicate previous line

#+BEGIN_SRC emacs-lisp
  (global-set-key (kbd "s-d") "\C-p\C-a\C- \C-n\M-w\C-y")
#+END_SRC

Toggle Whitespace mode on and off.  Whitespace mode causes all hard
tabs to be highlighted.  You can also configure it to highlight space
characters in a different color.  There is also an untabify function
to convert hard tabs to the appropriate number of spaces, and a tabify
function to convert groups of spaces to hard tabs.

#+BEGIN_SRC emacs-lisp
  (define-key bba/toggle "w" 'whitespace-mode)

  (setq whitespace-display-mappings
         ;; all numbers are Unicode codepoint in decimal. try (insert-char 182 ) to see it
        '(
          (space-mark 32 [183] [46]) ; 32 SPACE, 183 MIDDLE DOT 「·」, 46 FULL STOP 「.」
          (newline-mark 10 [182 10]) ; 10 LINE FEED
          (tab-mark 9 [9655 9] [92 9]) ; 9 TAB, 9655 WHITE RIGHT-POINTING TRIANGLE 「▷」
          ))
#+END_SRC

#+BEGIN_SRC emacs-lisp


  (define-prefix-command 'bba/launcher)
  (define-key global-map "\C-xl" 'bba/launcher)

  (define-key bba/launcher "!" 'eshell-here)
  (define-key bba/launcher "b" 'browse-url-at-point)
  (define-key bba/launcher "B" 'eww)
  (define-key bba/launcher "\C-b" 'helm-safari-bookmarks)
  (define-key bba/launcher "\C-h" 'helm-safari-history)
  (define-key bba/launcher "c" 'helm-calcul-expression)
  (define-key bba/launcher "C" 'atomic-chrome-start-server)
  (define-key bba/launcher "d" 'ediff-buffers)
  (define-key bba/launcher "D" 'ediff-regions-linewise)
  (define-key bba/launcher "e" 'eshell)
  (define-key bba/launcher "E" 'elfeed)
  (define-key bba/launcher "g" #'(lambda()"epa-file-encrypt-to"(interactive) (describe-variable 'epa-file-encrypt-to)))
  (define-key bba/launcher "i" 'ielm)
  (define-key bba/launcher "k" 'bba/keyboard-maestro)
  (define-key bba/launcher "K" 'kubel)
  (define-key bba/launcher (kbd "s-k") 'kubed-transient)
  (define-key bba/launcher "l" 'magit-log-buffer-file)
  (define-key bba/launcher "m" 'bba/multiple-cursors)
  (define-key bba/launcher "n" 'neotree)
  (define-key bba/launcher "o" 'bba-open-file-dir-finder)
  (define-key bba/launcher "s" 'shell)
  (define-key bba/launcher "S" 'synonyms)
  (define-key bba/launcher "\C-s" 'helm-swoop)
  (define-key bba/launcher "t" 'git-timemachine)
  (define-key bba/launcher "v" 'vterm)

  (define-prefix-command 'bba/keyboard-maestro)
  (define-prefix-command 'bba/multiple-cursors)

  (define-key bba/keyboard-maestro "S" 'bba-screen-start-ssh-to-fqdn-at-point)
  (define-key bba/keyboard-maestro "s" 'bba-screen-start-ssm-to-fqdn-at-point)
  (define-key bba/keyboard-maestro "\C-s" 'bba-splunk-search)
  (define-key bba/keyboard-maestro "c" 'bba-open-file-dir-screen)
  (define-key bba/keyboard-maestro "C" 'bba-create-ticket-tmp-dir-open-dir-screen)

  (define-key bba/multiple-cursors "e" 'mc/edit-lines)
  (define-key bba/multiple-cursors "m" 'mc/mark-all-like-this)
  (define-key bba/multiple-cursors "n" 'mc/mark-next-like-this)
  (global-unset-key (kbd "M-<down-mouse-1>"))
  (global-set-key (kbd "M-<mouse-1>") 'mc/add-cursor-on-click)
  (define-key global-map "\C-c\C-t" 'insert-timestamp)

  (define-key global-map "\C-ci" 'imenu)
  (define-key global-map "\C-c\S-g" 'rgrep)
  (define-key global-map "\C-cf" 'load-git-cfengine)

  (define-key global-map "\C-c\C-w" 'fixup-whitespace)

  (define-key global-map "\M-g\M-d" 'magit-diff-unstaged)
  (define-key global-map "\M-g\S-d" #'(lambda()
                                     (interactive)
                                     (call-interactively 'magit-file-delete)
                                     (kill-buffer)
                                     )
    )
  (define-key global-map "\M-g\M-b" 'magit-branch-manager)
  (define-key global-map "\M-gb" 'magit-blame)
  (define-key global-map "\C-cm" 'magit-status)
  (global-set-key (kbd "C-c s-m") 'magit-list-repositories)

  (define-key global-map "\C-c\S-f" (lambda()
                                   (interactive)
                                   (message (buffer-file-name))))
  (define-key global-map (kbd "C-c C-S-f") 'bba-copy-buffer-name)
  (if (<= emacs-major-version 23)
      (progn
        (define-key global-map "\C-cw" (lambda ()
                                         (interactive)
                                         (let ((woman-use-topic-at-point t))
                                           (woman))))
        (define-key global-map "\C-x\C-b" 'ibuffer)
        )
  )

  (define-key global-map "\C-c\M-d" 'diff-buffer-with-file)

  ;;; ** Use C-+ and C-- to adjust font size

  (define-key global-map (kbd "C-+") 'text-scale-increase)
  (define-key global-map (kbd "C--") 'text-scale-decrease)



#+END_SRC

=isearch-forward-regexp= is much more useful than =isearch-forward= so
we use that as default:

#+BEGIN_SRC emacs-lisp
  (global-set-key (kbd "C-s") 'isearch-forward-regexp)
  (global-set-key (kbd "C-r") 'isearch-backward-regexp)
  (global-set-key (kbd "C-M-s") 'isearch-forward)
  (global-set-key (kbd "C-M-r") 'isearch-backward)
#+END_SRC

Thanks to [[http://ergoemacs.org/emacs/emacs_isearch_by_arrow_keys.html][Xah Lee]] for this:

Here's very convenient keys for isearch.

#+BEGIN_SRC emacs-lisp
    (define-key isearch-mode-map (kbd "<up>") 'isearch-ring-retreat )
    (define-key isearch-mode-map (kbd "<down>") 'isearch-ring-advance )

    (define-key isearch-mode-map (kbd "<left>") 'isearch-repeat-backward)
    (define-key isearch-mode-map (kbd "<right>") 'isearch-repeat-forward)

    (define-key minibuffer-local-isearch-map (kbd "<left>") 'isearch-reverse-exit-minibuffer)
    (define-key minibuffer-local-isearch-map (kbd "<right>") 'isearch-forward-exit-minibuffer)
#+END_SRC

Adjust mouse speed:

#+BEGIN_SRC emacs-lisp
  (setq mouse-wheel-scroll-amount '(1 ((shift) . 1) ((control) . nil)))
  (setq mouse-wheel-progressive-speed nil)
#+END_SRC

* string-inflection
[2019-02-08 Fri 12:14]

#+BEGIN_SRC emacs-lisp
  (require 'string-inflection)
  (global-set-key (kbd "M-S-TAB") 'bba-string-inflection-cycle)

  (defun bba-string-inflection-cycle-auto ()
      "switching by major-mode"
      (interactive)
      (cond
       ;; for emacs-lisp-mode
       ((eq major-mode 'emacs-lisp-mode)
        (string-inflection-all-cycle))
       ;; for java
       ((eq major-mode 'java-mode)
        (string-inflection-java-style-cycle))
       ;; for python
       ((eq major-mode 'python-mode)
        (string-inflection-python-style-cycle))
       (t
        ;; default
        (string-inflection-ruby-style-cycle))))

#+END_SRC
* By indentation

Borrowed from [[https://github.com/Wilfred/.emacs.d][github]]:

[[elisp:(describe-key%20(kbd%20"C-a"))][C-a]] normally moves us to the beginning of the line unconditionally
with [[elisp:(describe-function%20#'move-beginning-of-line)][move-beginning-of-line]]. This version is more useful, as it moves
to the first non-whitespace character if we're already at the
beginning of the line. Repeated use of `C-a' toggles between these two
positions.

#+BEGIN_SRC emacs-lisp
  (defun beginning-of-line-dwim ()
    "Toggles between moving point to the first non-whitespace character, and
  the start of the line."
    (interactive)
    (let ((start-position (point)))
      ;; Move to the first non-whitespace character.
      (back-to-indentation)

      ;; If we haven't moved position, go to start of the line.
      (when (= (point) start-position)
        (move-beginning-of-line nil))))

  (global-set-key (kbd "C-a") 'beginning-of-line-dwim)
#+END_SRC

* Beautifying JSON

#+BEGIN_SRC emacs-lisp
  (defun beautify-json ()
  "Use python to prettyprint JSON."
    (interactive)
    (let ((b (if mark-active (min (point) (mark)) (point-min)))
          (e (if mark-active (max (point) (mark)) (point-max))))
      (shell-command-on-region b e
       "python2.7 -mjson.tool" (current-buffer) t)))
#+END_SRC

* [[http://kitchingroup.cheme.cmu.edu/blog/2015/06/29/Getting-Emacs-to-read-to-me/][words-speak]]
[2016-12-18 Sun 15:11]

#+BEGIN_SRC emacs-lisp
  (defvar words-voice "Vicki"
    "Mac voice to use for speaking.")

  (defun words-speak (&optional text)
    "Speak word at point or region. Mac only."
    (interactive)
    (require 'json)
    (unless text
      (setq text (if (use-region-p)
                     (buffer-substring-no-properties
                      (region-beginning) (region-end))
                   (thing-at-point 'word))))
    ;; escape some special applescript chars
    (setq text (replace-regexp-in-string "\\\\" "\\\\\\\\" text))
    (setq text (replace-regexp-in-string "\"" "\\\\\"" text))
    (do-applescript
     (format
      "say \"%s\" using \"%s\""
      text
      words-voice)))
#+END_SRC
* [[http://irreal.org/blog/?p=5585][kill this buffer]]
[2016-09-26 Mon 13:22]

Kill the current buffer without asking if there is no prefix.

#+BEGIN_SRC emacs-lisp
  (defun jcs-kill-a-buffer (askp)
    (interactive "P")
    (if askp
        (kill-buffer (funcall completing-read-function
                              "Kill buffer: "
                              (mapcar #'buffer-name (buffer-list))))
      (kill-current-buffer)))

  (global-set-key (kbd "C-x k") 'jcs-kill-a-buffer)
#+END_SRC

* [[http://stackoverflow.com/questions/18121808/emacs-ediff-marked-files-in-different-dired-buffers][ediff marked pair]]
[2016-10-17 Mon 11:57]

Had to diff files on 2 different servers. What's better then dired and TRAMP?

#+BEGIN_SRC emacs-lisp
  (defun mkm/ediff-marked-pair ()
     "Run ediff-files on a pair of files marked in dired buffer"
     (interactive)
     (let* ((marked-files (dired-get-marked-files nil nil))
            (other-win (get-window-with-predicate
                        (lambda (window)
                          (with-current-buffer (window-buffer window)
                            (and (not (eq window (selected-window)))
                                 (eq major-mode 'dired-mode))))))
            (other-marked-files (and other-win
                                     (with-current-buffer (window-buffer other-win)
                                       (dired-get-marked-files nil)))))
       (cond ((= (length marked-files) 2)
              (ediff-files (nth 0 marked-files)
                           (nth 1 marked-files)))
             ((and (= (length marked-files) 1)
                   (= (length other-marked-files) 1))
              (ediff-files (nth 0 marked-files)
                           (nth 0 other-marked-files)))
             ((= (length marked-files) 1)
              (let ((single-file (nth 0 marked-files)))
                (ediff-files single-file
                             (read-file-name
                              (format "Diff %s with: " single-file)
                              nil (m (if (string= single-file (dired-get-filename))
                                         nil
                                       (dired-get-filename))) t))))
             (t (error "mark no more than 2 files")))))



      (add-hook 'dired-mode-hook
                (lambda ()
                  ;; The 'ls' executable requires the Gnu version on the Mac
                  (define-key dired-mode-map "=" 'mkm/ediff-marked-pair)))

#+END_SRC

* dired git
[2024-05-28 Tue 11:35]

#+begin_src emacs-lisp
  (setq dired-vc-rename-file  t)

  (defun git-add-files(files)
  "Run git add with the input FILES."
    (interactive)
    (shell-command (format "git add %s" files)))

  (defun dired-git-add-marked-files()
  "For each marked file in a DIRED buffer add it to the index."
    (interactive)
    (if (eq major-mode 'dired-mode)
        (let ((filenames (dired-get-marked-files))
              (files ""))
          (dolist (fn filenames)
            (setq fn (shell-quote-argument fn))
            (setq files (concat files " " fn)))
          (git-add-files files))
      (error (format "Not a Dired buffer \(%s\)" major-mode))))

#+end_src


* Get keychain password
[2016-10-21 Fri 13:31]

If I’m on OS X, I can fetch passwords etc. from my Keychain. This is
much more secure than storing them in configuration on disk:

#+BEGIN_SRC emacs-lisp
  (defun bw/chomp (str)
    "Chomp leading and tailing whitespace from `str'."
    (while (string-match "\\`\n+\\|^\\s-+\\|\\s-+$\\|\n+\\'" str)
      (setq str (replace-match "" t t str))) str)

  (defun bw/get-keychain-password (account-name)
    "Get `account-name' keychain password from OS X Keychain"
    (interactive "sAccount name: ")
    (when (executable-find "security")
      (bw/chomp
       (shell-command-to-string
        (concat
         "security find-generic-password -wa "
         account-name)))))
#+END_SRC

* [[http://emacs.stackexchange.com/questions/3925/hide-list-of-minor-modes-in-mode-line][hide minor modes]]
[2017-01-30 Mon 16:28]

We don't need all minor modes listed in the modeline.

#+BEGIN_SRC emacs-lisp
  (defvar hidden-minor-modes ; example, write your own list of hidden
    '(abbrev-mode            ; minor modes
      auto-fill-function
      auto-complete-mode
      inf-haskell-mode
      haskell-indent-mode
      haskell-doc-mode
      smooth-scroll-mode
      hidepw-mode
      helm-mode
      undo-tree-mode
      guide-key-mode
      artbollocks-mode
      ))

  (defun purge-minor-modes ()
    (interactive)
    (dolist (x hidden-minor-modes nil)
      (let ((trg (cdr (assoc x minor-mode-alist))))
	(when trg
	  (setcar trg "")))))

  (add-hook 'after-change-major-mode-hook 'purge-minor-modes)
#+END_SRC

* configure some default values
    [2014-10-02 Thu 00:27]

Specify printing format

#+BEGIN_SRC emacs-lisp
  (setq ps-paper-type 'a4)
#+END_SRC

#+BEGIN_SRC emacs-lisp
  (setq ps-landscape-mode t)
  (setq ps-number-of-columns 2)
#+END_SRC

compilation output

#+BEGIN_SRC emacs-lisp
  (setq compilation-scroll-output 'first-error)
#+END_SRC

Set ispell dictionary

#+BEGIN_SRC emacs-lisp
   (setq ispell-dictionary "english")
#+END_SRC

Set shell for M-| command

#+BEGIN_SRC emacs-lisp
  (setq shell-file-name "/bin/bash")
#+END_SRC

Set Shell used by TeX

#+BEGIN_SRC emacs-lisp
  (setq tex-shell-file-name "/bin/bash")
#+END_SRC

Set grep command options

#+BEGIN_SRC emacs-lisp
  (setq grep-command "grep -i -nH -e ")
#+END_SRC

Give your cursor some context.

#+BEGIN_SRC emacs-lisp
  (setq scroll-margin 3)
#+END_SRC

Confirm quit to avoid hitting C-x C-c by accident.

#+BEGIN_SRC emacs-lisp
  (setq confirm-kill-emacs 'yes-or-no-p)
#+END_SRC

Confirm suspend to avoid suspending by accident.

#+BEGIN_SRC emacs-lisp
  (put 'suspend-frame 'disabled t)
#+END_SRC

Ignore case when completing file names

#+BEGIN_SRC emacs-lisp
  (setq read-file-name-completion-ignore-case t)
#+END_SRC

Highlight parenthesis pairs

#+BEGIN_SRC emacs-lisp
  (show-paren-mode 1)
#+END_SRC

Blinking parenthesis

#+BEGIN_SRC emacs-lisp
  (setq blink-matching-paren-distance nil)
#+END_SRC

Highlight text between parens

#+BEGIN_SRC emacs-lisp
  (setq show-paren-style 'expression)
#+END_SRC

Use buffer name as frame title

#+BEGIN_SRC emacs-lisp
  (setq frame-title-format "%b - emacs")
#+END_SRC

Completion in mini-buffer

#+BEGIN_SRC emacs-lisp
  (icomplete-mode t)
#+END_SRC

Stack minibuffers

#+BEGIN_SRC emacs-lisp
  (setq enable-recursive-minibuffers t)
#+END_SRC

Make dired human readable

#+BEGIN_SRC emacs-lisp
  (setq dired-listing-switches "-alh")
#+END_SRC

Guess copy target. If split window use others current directory.

#+BEGIN_SRC emacs-lisp
  (setq dired-dwim-target t)
#+END_SRC

#+BEGIN_SRC emacs-lisp
  (setq ediff-split-window-function 'split-window-horizontally)
#+END_SRC

use smtp for sending emails.
set your mailserver settings outside of this file.

#+BEGIN_SRC emacs-lisp :tangle no
  (setq smtpmail-smtp-server "your.mailserver")
  (setq smtpmail-smtp-service "25")
#+END_SRC

#+BEGIN_SRC emacs-lisp
  (setq send-mail-function 'smtpmail-send-it)

#+END_SRC

Some nice functions

#+BEGIN_SRC emacs-lisp :tangle no
  ;;(blink-matching-paren 1)
  ;;(paren-activate)
#+END_SRC

XML indentation

#+BEGIN_SRC emacs-lisp
  (if (equal "work" (getenv "SYSENV"))
      (setq nxml-child-indent 4))
#+END_SRC

update copyrights

#+BEGIN_SRC emacs-lisp
  (defvar bba-copyright-update 't)
  (defun bba-toggle-copyright-update()
    "switch copyright-update on save on or off."
    (interactive)
    (if (bound-and-true-p bba-copyright-update)
        (setq bba-copyright-update nil)
      (setq bba-copyright-update t))
    (message "copyright-update is %s" bba-copyright-update)
    )
  (add-hook 'before-save-hook (lambda()
                                     (if (bound-and-true-p bba-copyright-update)
                                         (copyright-update))))
#+END_SRC

#+BEGIN_SRC emacs-lisp
  (add-to-list 'Info-additional-directory-list "~/.emacs.d/info")
#+END_SRC

#+BEGIN_SRC emacs-lisp
  (require 'info-look)
  (info-lookup-add-help
   :mode 'python-mode
   :regexp "[[:alnum:]_]+"
   :doc-spec
   '(("(python)Index" nil "")))
#+END_SRC

#+BEGIN_SRC emacs-lisp
  (setq mouse-yank-at-point t)
#+END_SRC

* TODO other stuff

#+BEGIN_SRC emacs-lisp

  ;;(move-overlay hl-line-overlay
  ;;            (line-beginning-position) (1+ (line-end-position))
  ;;            (current-buffer))

  ;; (set-face-background-pixmap 'default "~/.emacs.d/xemacs-bg.xpm")

  ;; pos1: goto start of line, start of screen, start of buffer
  ;; end: goto end of line, end of screen, end of buffer

  (global-set-key '[(home)] 'chb-home)
  (global-set-key '[(end)] 'chb-end)
  ;;
  (defun chb-home ()
    (interactive)
    (if (not (bolp))
        (beginning-of-line)
      (if (eq this-command last-command)
          (cond
           ((not (= (point) (window-start)))
            (move-to-window-line 0)
            (beginning-of-line))
           (t
            (goto-char (point-min)))))))

  (defun chb-end ()
    (interactive)
    (if (not (eolp))
        (end-of-line)
      (if (eq this-command last-command)
          (cond
           ((not (= (point) (save-excursion
                              (move-to-window-line -1)
                              (end-of-line)
                              (point))))
            (move-to-window-line -1)
            (end-of-line))
           (t
            (goto-char (point-max)))))))




#+END_SRC

Make the window title display the full path of the file I’m currently editing:

#+BEGIN_SRC emacs-lisp
  (when (display-graphic-p)
    (setq frame-title-format
          '((:eval (if (buffer-file-name)
                       (abbreviate-file-name (buffer-file-name))
                     "%b")))))
#+END_SRC

sRGB display fixes

#+BEGIN_SRC emacs-lisp
(setq ns-use-srgb-colorspace t)
#+END_SRC

There are a few applications, such as crontab, that require a trailing
new line. To be safe, always leave a trailing newline.

#+BEGIN_SRC emacs-lisp
  (setq-default require-final-newline t)
#+END_SRC

You have to work hard to be lazy.

#+BEGIN_SRC emacs-lisp
  (defalias 'ts 'transpose-sentences)
  (defalias 'tp 'transpose-paragraphs)
#+END_SRC

Save whatever’s in the current (system) clipboard before
replacing it with the Emacs’ text.
https://github.com/dakrone/eos/blob/master/eos.org

#+BEGIN_SRC emacs-lisp
  (setq save-interprogram-paste-before-kill t)
#+END_SRC

* [[http://editorconfig.org/][editorconfig]]
[2017-01-06 Fri 14:27]

Set default indentation, end of line, trailing whitespaces etc for the
whole team. No matter what editor gets used.

#+BEGIN_SRC emacs-lisp
  (editorconfig-mode '1)

#+END_SRC

* console mode
[2024-01-29 Mon 11:12]

#+begin_src emacs-lisp
  (if (not (display-graphic-p))
      (progn
        (display-battery-mode 1)
        (display-time-mode 1)))
#+end_src
* set theme bba1
[[https://emacsfodder.github.io/emacs-theme-editor/][Emacs Theme Editor]] is a nice tool to define your colors.

#+BEGIN_SRC emacs-lisp
  (if (display-graphic-p)
      (progn
        (setq custom-theme-directory "~/.emacs.d/themes/")
        (load-theme 'bba1 t)
        (when (>= emacs-major-version 27)
          (with-eval-after-load 'org
            (dolist (face '(org-block
                        org-block-begin-line
                        org-block-end-line
                        org-level-1
                        org-quote))
          (set-face-attribute face nil :extend t ))))
        (custom-set-faces
         '(org-block-begin-line ((t (:background "#07538a" :foreground "#84cbef" :extend t))) t)
         '(org-block-end-line ((t (:inherit org-block-begin-line))) t)
         '(org-block ((t (:inherit shadow :background "#29759c" :foreground "#84cbef" :distant-forground "#131313" :extend t))))
         ;; '(show-paren-match ((t (:distant-foreground "#29759c":background "#84cbef" ))))
         ;;'(show-paren-match ((t (:inverse-video t))))
       '(show-paren-match ((t (:underline (:color "#07e30d" :style line)))))
       '(show-paren-mismatch ((t (:underline (:color "red" :style wave)))))
  	 ;; '(show-paren-match ((t (:unterline (:color "#b8bb26" :style wave)))))
  	 )
  	(let* ((variable-tuple (cond ((x-list-fonts "Arial") '(:font "Arial"))
  				     ((x-list-fonts "Source Sans Pro") '(:font "Source Sans Pro"))
  				     ((x-list-fonts "Lucida Grande")   '(:font "Lucida Grande"))
  				     ((x-list-fonts "Verdana")         '(:font "Verdana"))
  				     ((x-family-fonts "Sans Serif")    '(:family "Sans Serif"))
  				     (nil (warn "Cannot find a Sans Serif Font.  Install Source Sans Pro."))))
  	       (base-font-color     (face-foreground 'default nil 'default))
  	       (headline           `(:inherit default :foreground "#62a9cd")))

  	  (custom-theme-set-faces 'user
  				  `(org-level-8 ((t (,@headline ,@variable-tuple))))
  				  `(org-level-7 ((t (,@headline ,@variable-tuple))))
  				  `(org-level-6 ((t (,@headline ,@variable-tuple))))
  				  `(org-level-5 ((t (,@headline ,@variable-tuple))))
  				  `(org-level-4 ((t (,@headline ,@variable-tuple :height 1.1))))
  				  `(org-level-3 ((t (,@headline ,@variable-tuple :height 1.25))))
  				  `(org-level-2 ((t (,@headline ,@variable-tuple :height 1.4))))
  				  `(org-level-1 ((t (,@headline ,@variable-tuple :height 1.6))))
  				  `(org-document-title ((t (,@headline ,@variable-tuple :height 1.5 :underline nil)))))
  	  (custom-set-variables
  	    '(ansi-color-names-vector
  	      ["black" "red3" "green3" "yellow3" "LightSkyBlue1" "magenta3" "cyan3" "gray90"]))
  	  )))


#+end_src

To prevent Emacs from storing faces we have to overwrite the default
function:

#+begin_src emacs-lisp :tangle no
  (defun custom-set-faces (&rest args)
  "Overwrite default function to return just nil as we handle faces in orgmode."
  nil  )
#+end_src

* transparent window
[2018-03-07 Wed 10:42]

#+BEGIN_SRC emacs-lisp
  (set-frame-parameter (selected-frame) 'alpha '(100 . 96 ))
  (add-to-list 'default-frame-alist '(alpha . (100 . 96)))
#+END_SRC

* load custom file
    [2014-10-02 Thu 00:37]

#+BEGIN_SRC emacs-lisp
    (setq custom-file
          (expand-file-name "custom.el"
                            (expand-file-name ".emacs.d" "~")))
  ;;  (load-file user-init-file)
    (load-file custom-file)

#+END_SRC

* Set default font on Mac

https://github.com/IBM/plex/releases

#+begin_src emacs-lisp :tangle no
  (if (string-equal system-type "darwin")
      (seq-filter (lambda (font)
                    (when-let ((info (font-info font)))
                      (string-match-p "spacing=100" (aref info 1))))
                  (font-family-list)))

#+end_src

#+RESULTS:
| Andale Mono | Courier New | IBM 3270 Condensed | IBM 3270 Semi-Condensed | IBM Plex Mono | Menlo | Monaco | PT Mono |

#+BEGIN_SRC emacs-lisp
  (if (string-equal system-type "darwin")
      (if (and (network-interface-info '"en0") (eql 203 (aref (car (cdr (network-interface-info '"en0"))) 2)))
          (set-frame-font "IBM Plex Mono 12" nil 't)
        (set-frame-font "IBM Plex Mono 15" nil 't)))
#+END_SRC

* dns-mode

If you edit zone files via TRAMP you might want to activate them via
=rndc reload=. =C-c C-r= just does that for you.

#+BEGIN_SRC emacs-lisp
  (defun dns-rndc ()
  "Do rndc reload of current buffers filename."
  (interactive)
  (string-match "/\\([^/]*\\)$" buffer-file-name)
  (let* ((zonefile (match-string 1 buffer-file-name))
         )
    (if (y-or-n-p (format "rndc reload %s?" zonefile))
        (shell-command (concat "rndc reload " zonefile ) ) )
    )

  )

  (eval-after-load 'dns-mode
    (add-hook 'dns-mode-hook
             (lambda ()
               (define-key dns-mode-map "\C-c\C-r" 'dns-rndc)
               )))

#+END_SRC

* save history
    [2015-04-05 Sun 12:57]

Write a history of your emacs into your org git repository.
You have it available on every system and it's still private at it's
not in the public git emacs configuration.

- kill ring
- search ring
- regexp-search-ring
- last-kbd-macro
- kmacro-ring
- shell-command-history

all in your history.

#+BEGIN_SRC emacs-lisp
  (setq savehist-additional-variables '(kill-ring search-ring regexp-search-ring last-kbd-macro kmacro-ring shell-command-history register-alist projectile-compilation-cmd-map))
  (setq kmacro-ring-max 42)
  (setq history-delete-duplicates t)
  (if (equal "work" (getenv "SYSENV"))
      (if (file-exists-p "~/workorg")
          (setq savehist-file "~/workorg/emacshistory")
        )
    (if (file-exists-p "~/org")
        (setq savehist-file "~/org/emacshistory")
      )
    (if (file-exists-p savehist-file)
        (load-file savehist-file)
        )

  )
  (savehist-mode 1)
#+END_SRC

* save place
[2019-11-06 Wed 15:53]

#+begin_src emacs-lisp
  (setq save-place-file "~/.emacs-places")
  (save-place-mode 1)
  ;; (setq save-place-forget-unreadable-files nil)
#+end_src

* start ssh in screen session
[2016-02-11 Thu 12:42]

This one uses Keyboard Maestro to launch a ssh in a screen session in iTerm2.
Assumption clipboard is a dns name.

#+BEGIN_SRC emacs-lisp
  (defun bba-screen-start-ssh-to-clipboard (&optional arg)
  "Use a macro in Keyboard Maestro to ssh into a system in iterm screen session."
  (interactive)
  (if arg
      (kill-new (thing-at-point arg))
    )
  (shell-command "osascript -e \'tell app \"Keyboard Maestro Engine\" to do script \"screen-start-ssh-to-clipboard\"'" )
  )

  (defun bba-screen-start-ssh-to-fqdn-at-point()
    "run ssh to fqdn in screen session. fallback to clipboard."
    (interactive)
    (bba-screen-start-ssh-to-clipboard 'fqdn)
    )

#+END_SRC

* start ssm in screen session
[2020-02-25 Tue 12:20]

#+BEGIN_SRC emacs-lisp
  (defun bba-screen-start-ssm-to-clipboard (&optional arg)
  "Use a macro in Keyboard Maestro to ssh into a system in iterm screen session."
  (interactive)
  (if arg
      (kill-new (thing-at-point arg))
    )
  (shell-command "osascript -e \'tell app \"Keyboard Maestro Engine\" to do script \"screen-start-ssm-to-clipboard\"'" )
  )

  (defun bba-screen-start-ssm-to-fqdn-at-point()
    "run ssm to fqdn in screen session. fallback to clipboard."
    (interactive)
    (bba-screen-start-ssm-to-clipboard 'fqdn)
    )

#+END_SRC



* aws

Use aws command line tool via Emacs.

#+BEGIN_SRC emacs-lisp
  (defun bba-aws-desc-instances ( profile name)
    "query aws to get informations for running instances."
    (interactive "sProfile: \nsName: ")
    (switch-to-buffer (concat "*aws-" profile "-" name "*"))
    (org-mode)
    (message "querying aws for %s in profile %s" name profile)
    (insert (shell-command-to-string (concat "aws ec2 describe-instances --profile " profile " --filters \"Name=tag-key,Values=Name,Name=tag-value,Values=" name "*\" --query \"Reservations[].Instances[?State.Name=='running'].[InstanceId, PublicDnsName]\" --output table")))
    (message "done.")
  )

#+END_SRC

Check a AWS Cloudformation template with [[https://github.com/stelligent/cfn_nag][cfn_nag]]:

#+BEGIN_SRC emacs-lisp
  (defun bba-aws-cfn-nag-scan()
    "Check buffer with cfn_nag_scan."
    (interactive)
    (shell-command (concat "cfn_nag_scan --input-path " buffer-file-name)))
  (require 'json-mode)
  (define-key json-mode-map (kbd "C-c C-n") 'bba-aws-cfn-nag-scan)
  (require 'yaml-mode)
  (define-key yaml-mode-map (kbd "C-c C-n") 'bba-aws-cfn-nag-scan)
#+END_SRC

Check a AWS Cloudformation template with [[https://github.com/awslabs/cfn-python-lint][cfn-lint]]:

#+BEGIN_SRC emacs-lisp
  (defun bba-aws-cfn-lint()
    "Check buffer with cfn_lint."
    (interactive)
    (if (file-exists-p "~/.cfn-lint-override.json")
        (shell-command (concat "cfn-lint --override-spec ~/.cfn-lint-override.json " buffer-file-name))
    (shell-command (concat "cfn-lint " buffer-file-name))))
  (define-key json-mode-map (kbd "C-c C-l") 'bba-aws-cfn-lint)
  (define-key yaml-mode-map (kbd "C-c C-l") 'bba-aws-cfn-lint)
#+END_SRC

* terraform
[2016-09-02 Fri 14:57]

#+BEGIN_SRC emacs-lisp
  (add-hook 'terraform-mode-hook #'terraform-format-on-save-mode)
#+END_SRC
* thing-at-point-fqdn
[2016-02-12 Fri 14:13]

#+BEGIN_SRC emacs-lisp
  (defun fqdn-bounds-of-fqdn-at-point ()
       "Return the start and end points of an fqdn at the current point.
     The result is a paired list of character positions for an fqdn
     located at the current point in the current buffer."
       (save-excursion
         (skip-chars-backward "-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
         (if (looking-at "[-.0-9a-zA-Z]+")
             (cons (point) (match-end 0)) ; bounds of fqdn
           nil))) ; no fqdn at point

  (put 'fqdn 'bounds-of-thing-at-point
         'fqdn-bounds-of-fqdn-at-point)
#+END_SRC

* thing-at-point-instanceID
[2016-02-12 Fri 14:13]

Amazon instance ID at point.

#+BEGIN_SRC emacs-lisp
  (defun instanceid-bounds-of-instanceid-at-point ()
       "Return the start and end points of an Amazon instance ID at the current point.
     The result is a paired list of character positions for an fqdn
     located at the current point in the current buffer."
       (save-excursion
         (skip-chars-backward "-.0123456789abcdefi")
         (if (looking-at "i-[-.0-9abcdef]+")
             (cons (point) (match-end 0)) ; bounds of fqdn
           nil))) ; no fqdn at point

  (put 'instanceid 'bounds-of-thing-at-point
         'instanceid-bounds-of-instanceid-at-point)
#+END_SRC

* bba-emacs-keyboard-map
[2016-03-15 Tue 09:49]

#+BEGIN_SRC emacs-lisp
  (defun bba-emacs-keyboard-map ()
    "create a keyboard map in a buffer."
    (interactive)
    (switch-to-buffer "*keyboard-map*")
    (erase-buffer)
    (org-mode)
    (insert "|1|2|3|4|5|6|7|8|9|0|-|=|back|")
    (newline)
    (insert "|q|w|e|r|t|y|u|i|o|p|[|]|")
    ;; (org-table-align)
    (newline)
    (insert "|")
    (insert "M-q " )(insert (format "%s" (lookup-key global-map (kbd "M-q"))) "|")
    (insert "M-w " )(insert (format "%s" (lookup-key global-map (kbd "M-w"))) "|")
    (insert "M-e " )(insert (format "%s" (lookup-key global-map (kbd "M-e"))) "|")
    (insert "M-r " )(insert (format "%s" (lookup-key global-map (kbd "M-r"))) "|")
    (insert "M-t " )(insert (format "%s" (lookup-key global-map (kbd "M-t"))) "|")
    (insert "M-y " )(insert (format "%s" (lookup-key global-map (kbd "M-y"))) "|")
    (insert "M-u " )(insert (format "%s" (lookup-key global-map (kbd "M-u"))) "|")
    (insert "M-i " )(insert (format "%s" (lookup-key global-map (kbd "M-i"))) "|")
    (insert "M-o " )(insert (format "%s" (lookup-key global-map (kbd "M-o"))) "|")
    (insert "M-p " )(insert (format "%s" (lookup-key global-map (kbd "M-p"))) "|")
    (insert "M-[ " )(insert (format "%s" (lookup-key global-map (kbd "M-["))) "|")
    (insert "M-] " )(insert (format "%s" (lookup-key global-map (kbd "M-]"))) "|")
    (newline)
    (insert "|a|s|d|f|g|h|j|k|l|;|'|")
    (newline)
    (insert "|")
    (insert "M-a " )(insert (format "%s" (lookup-key global-map (kbd "M-a"))) "|")
    (insert "M-s " )(insert "key-chord key" "|")
    (insert "M-d " )(insert (format "%s" (lookup-key global-map (kbd "M-d"))) "|")
    (insert "M-f " )(insert (format "%s" (lookup-key global-map (kbd "M-f"))) "|")
    (insert "M-g " )(insert "key-chord key" "|")
    (insert "M-h " )(insert (format "%s" (lookup-key global-map (kbd "M-h"))) "|")
    (insert "M-j " )(insert (format "%s" (lookup-key global-map (kbd "M-j"))) "|")
    (insert "M-k " )(insert (format "%s" (lookup-key global-map (kbd "M-k"))) "|")
    (insert "M-l " )(insert (format "%s" (lookup-key global-map (kbd "M-l"))) "|")
    (insert "M-; " )(insert (format "%s" (lookup-key global-map (kbd "M-;"))) "|")
    (insert "M-\' " )(insert (format "%s" (lookup-key global-map (kbd "M-'"))) "|")
    (newline)
    (insert "|z|x|c|v|b|n|m|,|.|/|")
    (newline)
    (insert "|")
    (insert "M-z " )(insert (format "%s" (lookup-key global-map (kbd "M-z"))) "|")
    (insert "M-x " )(insert (format "%s" (lookup-key global-map (kbd "M-x"))) "|")
    (insert "M-c " )(insert (format "%s" (lookup-key global-map (kbd "M-c"))) "|")
    (insert "M-v " )(insert (format "%s" (lookup-key global-map (kbd "M-v"))) "|")
    (insert "M-b " )(insert (format "%s" (lookup-key global-map (kbd "M-b"))) "|")
    (insert "M-n " )(insert (format "%s" (lookup-key global-map (kbd "M-n"))) "|")
    (insert "M-m " )(insert (format "%s" (lookup-key global-map (kbd "M-m"))) "|")
    (insert "M-, " )(insert (format "%s" (lookup-key global-map (kbd "M-,"))) "|")
    (insert "M-. " )(insert (format "%s" (lookup-key global-map (kbd "M-."))) "|")
    (insert "M-/ " )(insert (format "%s" (lookup-key global-map (kbd "M-/"))) "|")

    (newline)
    )

#+END_SRC


* Load the Rest
[2022-12-09 Fri 18:09]

#+begin_src emacs-lisp
  (require 'f)
  (defvar bba-emacs-files (flatten-list
			   `("bba-shell.org"
			     "bba-orgmode.org"
			   "bba-programming.org"))
    "List of org files that complete my configuration.")

  (defun bba-emacs-load (file)
    "load or reload an org-mode FILE containing lterate Emacs configuration code."
    (interactive (list (completing-read "Org file: " 'bba-emacs-files)))
    (let ((full-file (f-join "~/.emacs.d/" file)))
      (when (f-exists? full-file)
	(org-babel-load-file full-file))))

  (defun bba-emacs-reload-all ()
    "Reload our entire ecosystem of configuration files."
    (interactive)
    (dolist (file bba-emacs-files)
      (unless (equal file "bba.org"))
      (bba-emacs-load file)))

#+end_src

And do it:
#+begin_src emacs-lisp
  (bba-emacs-reload-all)
#+end_src

* post
  [2015-10-02 Fri 13:26]

Some private settings outside this repository are loaded after this configuration.

#+BEGIN_SRC emacs-lisp
  (if (file-exists-p "~/.emacs_post.el")
  (load-file "~/.emacs_post.el"))
#+END_SRC

* done
[2014-08-27 Wed 11:02]
Display greetings:

#+BEGIN_SRC emacs-lisp
  (totd)
  (switch-to-buffer "*Tip of the day*")
  (delete-other-windows)
  (message "All done, %s!" (user-login-name) )
#+END_SRC

Split and show workhours:

#+begin_src emacs-lisp
  (if (equal "work" (getenv "SYSENV"))
      (progn (org-agenda-list)
             (split-window-right)
             (other-window 1)
             (find-file "~/org/workhours.org")
             (goto-char (point-min))
             (org-shifttab 3)
             (if (re-search-forward (concat "^\*\* "(format-time-string "%Y-%m")) nil t)
                 (progn
                   (org-beginning-of-line)
                   (if (invisible-p (point-at-eol)) (org-cycle))
                   (org-cycle))
               (progn
                 (goto-char (point-min))
                 (org-next-visible-heading '1)
                 (org-meta-return)
                 (insert (format-time-string "%Y-%m"))
                 (newline)
                 (insert ":LOGBOOK:")
                 (newline)
                 (insert ":END:")))
             ))
#+end_src

* old config

#+BEGIN_SRC emacs-lisp :eval no :tangle no





    (setq org-html-head "<style type=\"text/css\">
body {
    background-color: #bbbbbb;
}     </style>")


  body {
      background-color: #bbbbbb;
      color: #000000;
      margin: 0px;
      padding: 0px;
      height: 100%;
  }'



    ;;; * Big Brother Database

    ;; (require 'bbdb)
    ;; (bbdb-initialize)

    ;;; * auto-completion

    ;;(move-overlay hl-line-overlay
    ;;            (line-beginning-position) (1+ (line-end-position))
    ;;            (current-buffer))

    ;; (set-face-background-pixmap 'default "~/.emacs.d/xemacs-bg.xpm")
    (set-foreground-color "green")
    (set-background-color "black")

    ;; pos1: goto start of line, start of screen, start of buffer
    ;; end: goto end of line, end of screen, end of buffer

    (global-set-key '[(home)] 'chb-home)
    (global-set-key '[(end)] 'chb-end)
    ;;
    (defun chb-home ()
    (interactive)
    (setq zmacs-region-stays t)
    (if (not (bolp))
    (beginning-of-line)
    (if (eq this-command last-command)
    (cond
     ((not (= (point) (window-start)))
      (move-to-window-line 0)
      (beginning-of-line))
     (t
      (goto-char (point-min)))))))

    (defun chb-end ()
    (interactive)
    (setq zmacs-region-stays t)
    (if (not (eolp))
    (end-of-line)
    (if (eq this-command last-command)
    (cond
     ((not (= (point) (save-excursion
                        (move-to-window-line -1)
                                (end-of-line)
                                (point))))
              (move-to-window-line -1)
              (end-of-line))
             (t
              (goto-char (point-max)))))))




    ;; safe files with #! in first line as user executable

    (add-hook `after-safe-hook
              #'(lambda ()
                 (and (save-excursion
                        (save-restriction
                          (widen)
                          (goto-char (point-min))
                          (save-match-data
                            (looking-at "^#!"))))
                      (not (file-executable-p buffer-file-name))
                      (shell-command (concat "chmod u+x " buffer-file-name))
                      (message
                       (concat "Saved as script: " buffer-file-name)))))

    ;;
    ;; list of recently opened files
    ;;

    ;; (load "recent-files")
    ;; (setq recent-files-dont-include
    ;;      '("~$" "tmp/." "INBOX" ".bbdb" ".newsrc." ))

    ;; (setq recent-files-non-permanent-submenu t)
    ;; (setq recent-files-commands-submenu t)
    ;; (setq recent-files-number-of-entries 30)
    ;; (recent-files-initialize)

    ;;  Make the <ctrl> c F12 key toggle Whitespace mode on and off.  Whitespace mode causes
    ;; all hard tabs to be highlighted.  You can also configure it to highlight space characters
    ;; in a different color.  There is also an untabify function to convert hard tabs to the
    ;; appropriate number of spaces, and a tabify function to convert groups of spaces to
    ;; hard tabs.
    (global-set-key (kbd "C-c <f12>") 'whitespace-mode)


    ;; (add-hook 'find-file-hooks 'fume-setup-buffer)
    ;; (add-hook 'Manual-mode-hook 'turn-on-fume-mode)

    ;; (function-menu USE-MENUBAR RETURN-ONLY MENU-ITEM-FUNCTION)

    ;;====================================================================
    ;;The Following Code Will Enable Me To Use The "Fume" Package Which
    ;;Creates, On The Menubar, A "Functions" Menu Containing The List Of
    ;;All The Functions In The Buffer Being Currently Displayed.
    ;;====================================================================
    ;;
    ;;Setq-Default Set The Default Value Of A Var.  This Def. Val. Is Seen
    ;;In Buffers That *Don'T* Have Their Own Values For The Variable.

    ;(require function-menu)
    ;(Define-Key Global-Map 'F8 'Function-Menu)
    ;(Add-Hook 'Find-File-Hooks 'Fume-Add-Menubar-Entry)
    ;(Define-Key Global-Map "\C-Cl" 'Fume-List-Functions)
    ;(Define-Key Global-Map "\C-Cg" 'Fume-Prompt-Function-Goto)
    ;(Define-Key Global-Map '(Shift Button3) 'Mouse-Function-Menu)
    ;(Define-Key Global-Map '(Meta  Button1) 'Fume-Mouse-Function-Goto)

    ;(Add-Hook
    ; 'Find-File-Hooks
    ; (Function
    ;  (Lambda()
    ;    (If (And (String-Match "Xemacs" Emacs-Version)
    ;             (Boundp 'Emacs-Major-Version)
    ;            (Or (= Emacs-Major-Version 20)
    ;                 (And
    ;                  (= Emacs-Major-Version 19)
    ;                 (>= Emacs-Minor-Version 13)))
    ;             (Not (Eq Major-Mode 'Latex-Mode)))
    ;        (Fume-Add-Menubar-Entry))
    ;    )))


    (define-key global-map "\C-ct" 'visit-tags-table)
    (define-key global-map "\C-cf" 'tags-search)

    (define-key global-map "\C-c\C-t" 'insert-timestamp)

    (define-key global-map "\C-cf" 'load-git-cfengine)

    (define-key global-map "\C-c\C-w" 'fixup-whitespace)


    (define-key global-map "\M-g\M-d" 'magit-diff-unstaged)
    (define-key global-map "\M-g\M-b" 'magit-branch-manager)
    (define-key global-map "\M-gb" 'magit-blame-mode)
    (define-key global-map "\C-cm" 'magit-status)

    (define-key global-map "\C-cw" (lambda ()
                                     (interactive)
                                     (let ((woman-use-topic-at-point t))
                                       (woman))))
    (define-key global-map "\C-c\M-d" 'diff-buffer-with-file)

    ;;; ** Use C-+ and C-- to adjust font size

    (define-key global-map (kbd "C-+") 'text-scale-increase)
    (define-key global-map (kbd "C--") 'text-scale-decrease)

    ;; NUMBERIC KEYPAD. nice number pad conveniences as extra function keys

    ;; (global-set-key (kbd "<kp-subtract>") 'ergoemacs-close-current-buffer)
    ;; (global-set-key (kbd "<kp-divide>") 'ergoemacs-previous-user-buffer)
    ;; (global-set-key (kbd "<kp-multiply>") 'ergoemacs-next-user-buffer)

    ;; (global-set-key (kbd "<C-kp-divide>") 'ergoemacs-previous-emacs-buffer)
    ;; (global-set-key (kbd "<C-kp-multiply>") 'ergoemacs-next-emacs-buffer)

    ;; (global-set-key (kbd "<kp-decimal>") 'other-window)
    ;; (global-set-key (kbd "<kp-0>") 'delete-window)
    ;; (global-set-key (kbd "<kp-1>") 'delete-other-windows)
    ;; (global-set-key (kbd "<kp-2>") 'split-window-vertically)
    ;; (global-set-key (kbd "<kp-3>") 'xah-open-file-at-cursor)

    ;; (global-set-key (kbd "<kp-9>") 'isearch-forward)

    (setq custom-file
          (expand-file-name "custom.el"
                            (expand-file-name ".emacs.d" "~")))
    (load-file user-init-file)
    (load-file custom-file)
#+END_SRC