misc minor fixes

[dot-emacs] / my-init.org

#+title: My Personal Init Customization
#+OPTIONS: toc:nil num:nil ^:nil
* copyright
# Copyright (C) 2017 Ian Kelling

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

* things that should be at the beginning
#+begin_src emacs-lisp
;; todo, evaluating this manually disables debug on error instead of toggling it
;;(toggle-debug-on-error) ;uncomment to help debug and catch errors

#+end_src


packages installed from package manager: i pretty much prioritize repos this way: gnu, then melpa, then marmalade.

package-activated-list:
ac-dabbrev ac-haskell-process ack-and-a-half alect-themes auctex bash-completion bbdb csv-mode cyberpunk-theme dot-mode expand-region f find-file-in-project flycheck foreign-regexp ggtags ghc gnuplot-mode goto-chg haskell-mode heroku-theme highlight-indentation highlight-symbol htmlize inf-ruby info+ inkpot-theme jedi auto-complete jedi-core epc ctable concurrent key-chord leuven-theme logstash-conf magit git-commit magit-popup misc-fns mouse+ naquadah-theme nginx-mode occidental-theme org paredit pcsv php-mode pkg-info epl popup py-autopep8 python-environment deferred python-info python-mode rainbow-mode rust-mode rw-hunspell s smartparens smex smooth-scroll sr-speedbar strings swiper ivy tabulated-list tangotango-theme thingatpt+ undo-tree vimrc-mode volatile-highlights web-mode with-editor dash async ws-butler yasnippet

alternate keyboards
#+begin_src emacs-lisp
;; todo, figure out an easy way to disable this when using external keyboard
(if (display-graphic-p)
    (setq
     enter-key (kbd "<return>")
     s-enter-key (kbd "<S-return>")
     c-m-enter-key (kbd "<C-M-return>")
     m-enter (kbd "<M-return>")
     c-enter (kbd "<C-return>"))
  (setq
   enter-key (kbd "C-m")
    s-enter-key (kbd "C-8")
    c-m-enter-key (kbd "C-M-8")
    m-enter (kbd "M-m")
    c-enter (kbd "C-8")))

(setq tp (string= (system-name) "tp"))
(setq x200 (string= (system-name) "x2"))
(setq laptop-keyboard (or tp x200))
#+end_src

- Ubiquitous Packages which should be loaded on startup rather than
  autoloaded on demand since they are likely to be used in every
  session.
  #+name: starter-kit-load-on-startup
  #+begin_src emacs-lisp
    (require 'saveplace)
    (require 'ffap)
    (require 'uniquify)
    (require 'ansi-color)
    (require 'recentf)

  #+end_src


- Better to have a list of packages in here vs installed manually.
  However, I install manually because sometimes there are two
  versions and it is not necessarily easy to reconcile that.
  #+begin_src emacs-lisp
 ;; based on marmalage website front page.
(require 'package)

;; little kit to help remove a down server
;; (setq package-archives nil)

;;(add-to-list 'package-archives
;;             '("marmalade" .
;;               "http://marmalade-repo.org/packages/"))

(add-to-list 'package-archives
             '("melpa" . "http://melpa.milkbox.net/packages/") t)
(add-to-list 'package-archives '("org" . "http://orgmode.org/elpa/") t)

  #+end_src


 keep our init.el clean, by moving customization elisp to it's own file
#+name: m-x-customize-customizations
#+begin_src emacs-lisp
(setq custom-file "~/.emacs.d/custom.el")
(load custom-file 'noerror)
#+end_src

undo tree stuff
#+begin_src emacs-lisp
;; more resilient undo-tree-history if we have their locations set up front.
(setq undo-tree-history-directory-alist '(("." . "~/.undo-tree-history")))
;; Undo in region just happens accidentally, and throws me off, and it's been buggy in the past
(setq undo-tree-enable-undo-in-region nil)
#+end_src

* Stuff that I do not recommend that others use without reading,
understanding, and customizing themselves are

all mouse stuff disabled till i have time to figure it out again.
#+begin_src emacs-lisp :tangle no
(defun xterm-mouse-translate-1 (&optional extension)
  (save-excursion
    (let* ((event (xterm-mouse-event extension))
           (ev-command (nth 0 event))
           (ev-data    (nth 1 event))
           (ev-where   (nth 1 ev-data))
           (vec (vector event))
           (is-down (string-match "down-" (symbol-name ev-command))))

      (cond
       ((null event) nil)               ;Unknown/bogus byte sequence!
       (is-down
        (setf (terminal-parameter nil 'xterm-mouse-last-down) event)
        vec)
       (t
        (let* ((down (terminal-parameter nil 'xterm-mouse-last-down))
               (down-data (nth 1 down))
               (down-where (nth 1 down-data)))
          (setf (terminal-parameter nil 'xterm-mouse-last-down) nil)
          (cond
           ((null down)
            ;; This is an "up-only" event.  Pretend there was an up-event
            ;; right before and keep the up-event for later.
            (push event unread-command-events)
            (vector (cons (intern (replace-regexp-in-string
                                   "\\`\\([ACMHSs]-\\)*" "\\&down-"
                                   (symbol-name ev-command) t))
                          (cdr event))))
           ((equal ev-where down-where) vec)
           (t
            (let ((drag (if (symbolp ev-where)
                            0           ;FIXME: Why?!?
                          (list (intern (replace-regexp-in-string
                                         "\\`\\([ACMHSs]-\\)*" "\\&drag-"
                                         (symbol-name ev-command) t))
                                down-data ev-data))))
              (if (null track-mouse)
                  (vector drag)
                (push drag unread-command-events)
                (vector (list 'mouse-movement ev-data))))))))))))

#+end_src
* how to find auto-saved files that need recovering
find a recently dated file in ~/.emacs.d/auto-save-list/, and see the files listed in it.
#file# is an auto-save file. It may or may not be different than the file is corresponds to.
If it is different, emacs will give a message about recovering it when you open it.


* TODO try out which key mode
* TODO make installed emacs package declarative
* TODO see if there are more cool functions in sh-script
like sh-cd-here, and bind that to a key
* TODO assign a key to append-next-kill
* TODO keybinds to remember

keys worth memorizing

c-2
c-m-3

s-return

in isearch, C-o
isearch-occur

org, C-c / t
make just todo items visible

C-mouse-1
buffer list menu

C-up/down
move up/down fast

M-right-scroll
forward/back sexp

C-M-right-scroll
scroll

C-S-scroll
change text size

how to control+left scroll on kinesis
right shift = control

C-left-scroll
forward/backward word

C-M-d
swap buffers across windows

shell-cd-to-file
M-2

* TODO add simpler keybind for make-frame-command
current one is C-x 5 2.

* TODO learn some more ivy mode stuff
* TODO declarative package installations,
with documentation.
* TODO shell mode reverse search hides 2nd+ line of multi-line result
* TODO figure out browsing files with broken nfs mount
causes emacs to freeze until I kill -9 it.
* TODO make a keybind to print var under cursor
and actually, putting the start of it in th emodeline might be cool
* TODO make recent files save periodically,
normally it just saves on exit, but half the time I don't exit cleanly
so they don't get saved, because I leave emacs running until it crashes
* TODO fix undo tree outside visible buffer bug
* TODO c-<delete> in shell mode should send over
previous line if current line is empty
* TODO make c-m-s be just a control key for easier use
* TODO try out avy mode for laptop
i used to have ace jump mode, but google says avy is better.
* TODO bind a in group mode of gnus to c-u a,
also, make a default for number of articles
* TODO make auto-complete be on by default in sql-mode
* TODO make an easy bind for open previous buffer
* TODO i think my autosave for sudo-edit might be too fast
it sometimes leaves #_asdfjasdf files littered
* TODO readline-compleste doesn't work when you cat a file without a newline,
and so the prompt is messed up. not sure exactly what needs to be in end, or if its anything
* TODO figure out how to paste a path into find file
probably have to use the old kind of find file
* TODO readline-complete doesn't escape special chars in filenames
* TODO readline-complete dev



** misc fixes

bad code, the comment this relates to was removed, but not the comment
              /* If waiting for this channel, arrange to return as
                 soon as no more input to be processed.  No more
                 waiting.  */


(status_notify): New arg WAIT_PROC. this is unused, this is a bug.
The change in status_notify's return is just passing more information
from what it did already. No changes at all inside this function.

* TODO consider whether to bind indent-for-tab-command
I removed it from m-tab for terminal compatibility.
It's the default tab command, which yasnippet replaces.
* TODO readline-complete: remove the hardcoded rlc-no-readline-hook
* TODO isearch doesn't automatically wrap in info
* TODO look into fixing shell mode reverse search
and why auto-complete dies
caveat is that it doesn't work well with certain unusual prompts, for example if $/# is not used at the end
see if we can load history, or reverse search with history commands
* TODO keybinds for s-delete/tab etc
* TODO fix bbdb info packaging in melpa
* TODO figure out why my emacs startup script doesn't work from dmenu
* TODO post idea to make customize group show function var names so we can read doc strings
* TODO report/fix bug that kill-whole-line doesn't work right with append kill
* TODO make bash keybind for copy paste interoperate with x windows
* TODO fix org stderr redirection
make this produce output of "ok"
#+begin_src sh
echo ok >&2

#+end_src
* TODO make ido keybinds better
* TODO fix indenting in org

  (defun my-org-indent-region (start end)
    "Indent region."
    (interactive "r")
    (save-excursion
      (let ((line-end (org-current-line end)))
        (goto-char start)
        (while (< (org-current-line) line-end)
          (cond ((org-in-src-block-p) (org-babel-do-in-edit-buffer (indent-according-to-mode)))
                (t (call-interactively 'org-indent-line)))
          (move-beginning-of-line 2)))))



org-indent-region is broken for source blocks
the above function works, but has several problems.
first: it should not have separate logic from org-indent-line
second: it runs way too slow, mainly the command
 (org-babel-do-in-edit-buffer (indent-according-to-mode)))


* TODO figure out newline in prompt shell issue
setting this before readline-complete is loaded allows completion to work,
but auto-completion still fails. Need to debug readline-complete to figure this out.
(setq shell-prompt-pattern "^[^#$%>]*[#$]\n")
* TODO setup bind for find tag / lisp function at point

* TODO org-delete-char should also work for the delete/backspace keys!
  fix and send patch

* TODO checkout projectile / graphene's project settings

* TODO check up on recent changes to 3rd party default configs
- last checked apr 24
  https://github.com/eschulte/emacs24-starter-kit/commits/master

last checked mayish
https://github.com/bbatsov/prelude
- redefined mouse functions from this file

* TODO figure out how to setup emacs to format text nicely like thunderbird
* TODO it appears impossible make C-[ not be the same as escape
* TODO movement within info buffer after opening a link doesn't cancel isearch
leads to many frustrations
* TODO fix org resolve clock message. it is innacurate
  i is not the same, becuase it does not make org realize there is an active clock

* TODO add apropos commands to help prefix, from
  http://stackoverflow.com/questions/3124844/what-are-your-favorite-global-key-bindings-in-emacs
* TODO my autosave goes into an endless prompting loop
when running save buffer, and the buffer has been changed
outside of emacs
* TODO smart peren does not see ?\\) as a valid paren

* TODO why does org-end-of-line not go all the way to the end on a closed headline?
* TODO org makes random ... things, and delete right before them does ctrl-i
* TODO try mark word, which might be a useful keybind
* TODO fix org-cycle: it assumes which key it is bound to for its last alternative
* TODO checkout lisp-complete-symbol to augment auto-complete
* TODO emacs keylogger to optimize key binds
* TODO remap/investigate find tag, find tag at point
* TODO set key to cycle buffers by mode, example below

(defun cycle-buffer-by-mode (p-mode)
  "Cycle buffers by mode name"
  (interactive)
  (dolist (buffer (buffer-list))
    (with-current-buffer buffer
      (when (buffer-live-p buffer)
        (if (string-match p-mode mode-name) ;(regexp-quote p-mode)
            (setq switch2buffer buffer)))))
  (when (boundp 'switch2buffer)
    (switch-to-buffer switch2buffer)))

And I have bound this to my F9 key

(global-set-key [f9]             '(lambda () (interactive) (cycle-buffer-by-mode "Shell$")))

* TODO test out usefulness of forward/back sexp in different languages

* TODO major mode settings to check out in future
** emacs24 starter kit
- Nxhtml -- utilities for web development
[[http://ourcomments.org/Emacs/nXhtml/doc/nxhtml.html][Nxhtml]] is a large package of utilities for web development and for
embedding multiple major modes in a single buffer.

Nxhtml is not installed in this version of the starter-kit by default,
for information on installing nxhtml see [[http://www.emacswiki.org/emacs/NxhtmlMode][EmacsWiki-Nxhtml]].

web-mode is competing package and actively developed, so i'm using that instead


  (dolist (package '(yaml-mode js2-mode))
    (unless (package-installed-p package)

- Associate modes with file extensions

(add-to-list 'auto-mode-alist '("COMMIT_EDITMSG$" . diff-mode))
(add-to-list 'auto-mode-alist '("\\.css$" . css-mode))
(require 'yaml-mode)
(add-to-list 'auto-mode-alist '("\\.ya?ml$" . yaml-mode))
(add-to-list 'auto-mode-alist '("\\.rb$" . ruby-mode))
(add-to-list 'auto-mode-alist '("Rakefile$" . ruby-mode))
(add-to-list 'auto-mode-alist '("\\.js\\(on\\)?$" . js2-mode))
;; (add-to-list 'auto-mode-alist '("\\.xml$" . nxml-mode))

- clojure in starter-kit-lisp.org

- others = gnus, js, publish, perl, python, perl, ruby
   they each have their own starter kit file.

- snippets for various modes other than org-mode

* TODO update yasnippet documentation
  yas expand key customization is rediculously hard to figure out
  and completely undocumented
* TODO fix org source indenting, send patch
* TODO check out bundling aka compiling yasnippet
* TODO try xml/html mode url func

(defun view-url ()
  "Open a new buffer containing the contents of URL."
  (interactive)
  (let* ((default (thing-at-point-url-at-point))
         (url (read-from-minibfer "URL: " default)))
    (switch-to-buffer (url-retrieve-synchronously url))
    (rename-buffer url t)
    ;; TODO: switch to nxml/nxhtml mode
    (cond ((search-forward "<?xml" nil t) (xml-mode))
          ((search-forward "<html" nil t) (html-mode)))))

* TODO flyspell-buffer automatically

* TODO respond to ediff thread
* TODO fix horizontal mouse resizing
  resizing a window horizontally with the mouse should be allowed in more places

* TODO try using / making abbreviations

* abbreviations
#+begin_src emacs-lisp

  ;; turn on abbrev mode globally
  (setq-default abbrev-mode t)

#+end_src
default abbreviation mode file is .emacs.d/abbrev_defs.
add-global-abbrev, add-mode-abbrev for expansion at point
if all else fails, edit the abbrev file

* auto-complete

#+begin_src emacs-lisp
;; auto-completion in minibuffer
;; disabled while I look for another alternative
;;(icomplete-mode)

(require 'auto-complete-config)
(ac-config-default)


;; complete after 1 char instead of default 2
(setq ac-auto-start 1)
(setq ac-delay 0.001)

(add-to-list 'ac-modes 'org-mode 'sql-mode)

(defun ac-common-setup ()
  (add-to-list 'ac-sources 'ac-source-yasnippet))

;; for org mode completion source taken from wiki.
;; it did not work. no idea why. todo, investigate
;; the ac-sources code is at http://www.emacswiki.org/emacs/AutoCompleteSources
;; i've deleted it here so as to save space and not spam this file
;;(defun my-ac-org-mode ()
;;  (setq ac-sources (append ac-sources '(ac-source-org))))


;; this makes the org-self-insert command not do a flyspell spell check.
;; low priority thing to look into sometime
(ac-flyspell-workaround)


(define-key ac-completing-map (kbd "<up>") nil)
(define-key ac-completing-map (kbd "<down>") nil)
(define-key ac-completing-map (kbd "<S-return>") 'ac-expand)
(define-key ac-completing-map "\t" 'ac-complete)
(define-key ac-completing-map (kbd "<tab>") 'ac-complete)



#+end_src
* auto-complete readline-complete
#+begin_src emacs-lisp

(require 'readline-complete)
;; not sure how I made these, but I deleted, and
;; it would be nice to make them again sometime
;;(require 'src-loaddefs)

;; disabled cuz broken
;; redefining function in readline-complete so ac-complete only uses readline as a source
(defun ac-rlc-setup-sources ()
  "Add me to shell-mode-hook!"
  (setq ac-sources '(ac-source-shell)))
(add-hook 'shell-mode-hook 'ac-rlc-setup-sources)

;; generally unnecessary, but why not
(setq explicit-shell-file-name "bash")

;; readline-complete says to add this line.
;; however, it  up my procfs directory tracking hook
;; because get-process doesn't notice the child shell.
;; instead, I've removed export EMACS=t from
;;  comint-exec-1 (the function which initially sets it)
;; by finding it in emacs sources and redefinind it here
;; and done stty echo in my bashrc
;;(setq explicit-bash-args '("-c" "export EMACS=; stty echo; bash"))

(setenv "EMACS" "")
(setq explicit-bash-args nil)
(setq comint-process-echoes t)
;; default of 30 is way too slow. todo, consider pushing this upstream
(setq rlc-attempts 5)

(add-to-list 'ac-modes 'shell-mode)

;; readline-complete recommends this (i assume this format),
;; but greping finds no reference in emacs or my .emacs.d
;; so I'm assuming it is for an older emacs
;;(setq explicit-ssh-args '("-t"))

(add-hook 'shell-mode-hook
          (lambda ()
            (define-key shell-mode-map (kbd "<tab>") 'auto-complete)))


#+end_src
#+RESULTS:
: comint-exec-1

** readline complete fix

I need this function here, where INSIDE_EMACS is replaced with RLC_INSIDE_EMACS.
#+begin_src emacs-lisp
;; ian: last update 2017-1-7. update this periodically from upstream
;; like when we do a major emacs update
(defun comint-exec-1 (name buffer command switches)
  (let ((process-environment
         (nconc
          ;; If using termcap, we specify `emacs' as the terminal type
          ;; because that lets us specify a width.
          ;; If using terminfo, we specify `dumb' because that is
          ;; a defined terminal type.  `emacs' is not a defined terminal type
          ;; and there is no way for us to define it here.
          ;; Some programs that use terminfo get very confused
          ;; if TERM is not a valid terminal type.
          ;; ;; There is similar code in compile.el.
          (if (and (boundp 'system-uses-terminfo) system-uses-terminfo)
              (list "TERM=dumb" "TERMCAP="
                    (format "COLUMNS=%d" (window-width)))
            (list "TERM=emacs"
                  (format "TERMCAP=emacs:co#%d:tc=unknown:" (window-width))))
          (list (format "RLC_INSIDE_EMACS=%s,comint" emacs-version))
          process-environment))
        (default-directory
          (if (file-accessible-directory-p default-directory)
              default-directory
            "/"))
        proc decoding encoding changed)
    (let ((exec-path (if (and command (file-name-directory command))
                         ;; If the command has slashes, make sure we
                         ;; first look relative to the current directory.
                         (cons default-directory exec-path) exec-path)))
      (setq proc (apply 'start-file-process name buffer command switches)))
    ;; Some file name handler cannot start a process, fe ange-ftp.
    (unless (processp proc) (error "No process started"))
    (let ((coding-systems (process-coding-system proc)))
      (setq decoding (car coding-systems)
            encoding (cdr coding-systems)))
    ;; Even if start-file-process left the coding system for encoding data
    ;; sent from the process undecided, we had better use the same one
    ;; as what we use for decoding.  But, we should suppress EOL
    ;; conversion.
    (if (and decoding (not encoding))
        (setq encoding (coding-system-change-eol-conversion decoding 'unix)
              changed t))
    (if changed
        (set-process-coding-system proc decoding encoding))
    proc))

#+end_src

* auto save & backup
#+begin_src emacs-lisp
(setq auto-save-timeout 1) ; idle time before auto-save.

;; main hook for my auto save
(add-hook 'auto-save-hook 'my-auto-save)
;; additional hook to try to deal with emacs not auto-saving when a buffer isn't active
(add-hook 'window-configuration-change-hook 'my-auto-save-win)

;; this function from mu4e really does not like buffer saving
(advice-add 'message-send-and-exit :before 'my-as-off)
(advice-add 'message-send-and-exit :after 'my-as-on)

;; avoid window config hook saving too much, it can
;; get into loops in some random situations
(setq my-auto-save-last nil)
(defun my-auto-save-win ()
  (unless (eq (current-buffer) my-auto-save-last)
  (my-auto-save (current-buffer))))

(defun my-auto-save (&optional last)
  (when (and
         my-as
         (buffer-file-name)
         ;; mu4e has a bug right now, undo breaks when saving drafts
         (not (string= (buffer-file-name) "*draft*"))
         (buffer-modified-p)
         (not (org-src-edit-buffer-p)))
         ;; serial is incremented on each save, so let's do a bit less of them
         (not (derived-mode-p 'dns-mode))
    (setq my-auto-save-last last)
    (let (message-log-max)
      ;; a bit of a hack to partially suppress the constant saving in the echo area
      (with-temp-message ""
        (basic-save-buffer)))))

;; in the message-send-and-exit advice, got an error because it passed an arg.
;; didn't look into why, just add ignored args.
(defun my-as-off (&rest ignore)
  (interactive)
  (setq my-as nil))

(defun my-as-off-local (&rest ignore)
  (interactive)
  (setq-local my-as nil))

(defun my-as-on (&rest ignore)
  (interactive)
  (setq my-as t))

(defun my-as-on-local (&rest ignore)
  (interactive)
  (setq-local my-as on))

;; based on suggestion in the emacs docs, redefine these 2 functions
;; to avoid prompt spamming the user when we do auto-save
(defun ask-user-about-supersession-threat (fn)
  (discard-input)
  (message
   "File for %s has changed on disk outside of emacs. Auto-save is overwriting it, however
a backup is being created in case that is not what you intended." buffer-file-name)
  (setq buffer-backed-up nil))

(defadvice ask-user-about-lock (before lock-deactivate-as activate)
  (make-local-variable 'my-as)
  (setq my-as nil)
  (message "proper autosave has been turned off for this buffer because of lock file problem.
  In this buffer, do M-x my-as-on to reenable"))

;; todo, this doesn't work consistently to override the auto-save message
(defalias 'do-auto-save-original (symbol-function 'do-auto-save))
(defun do-auto-save (&optional no-message current-only)
  "This function has been modified to wrap the original so that NO-MESSAGE
is  always set to t, since we auto-save a lot, it spams otherwise.
The original doc string is as follows:

Auto-save all buffers that need it.
This is all buffers that have auto-saving enabled
and are changed since last auto-saved.
Auto-saving writes the buffer into a file
so that your editing is not lost if the system crashes.
This file is not the file you visited; that changes only when you save.
Normally we run the normal hook `auto-save-hook' before saving.


A non-nil NO-MESSAGE argument means do not print any message if successful.
A non-nil CURRENT-ONLY argument means save only current buffer."
  (interactive)
  (do-auto-save-original t current-only))

;; enable MY auto-save
(my-as-on)

#+end_src


backups, separate from auto-save

#+begin_src emacs-lisp

    ;; set backup file location
(setq backup-directory-alist '(("." . "~/.editor-backups")))
(setq auto-save-file-name-transforms
          '((".*" "~/.editor-backups/" t)))

(setq version-control t ;; Use version numbers for backups
      kept-new-versions 100
      kept-old-versions 2
      delete-old-versions t ;; delete old versions silently
      ;; assume hard linked files are done on purpose, don't screw them up
      backup-by-copying-when-linked t)

;; todo, the time needs to be an integer, not a vector type thing
(defun constant-backup ()
  "Backup conditioned on some time passing since last one.
  Hooked into 'before-save-hook."
  (cl-flet ((b-time (minutes)
                    (< last-backup-time
                       (- (current-time) (* 60 minutes)))))
    (when (or (not (boundp 'last-backup-time)) (and (< (buffer-size) 10000000) (b-time 5)) (b-time 30))
      (setq buffer-backed-up nil)
      (setq-local last-backup-time (current-time)))))

;; make a backup on auto-save, because the backup feature is not
;; utilized with my-auto-save, only normal interactive save.
;; todo, enable when fixed
;;(add-hook 'before-save-hook 'constant-backup)

(add-hook 'auto-save-hook 'auto-save-size-limit)

(defun auto-save-size-limit ()
  (when (and (not backup-inhibited) (> (buffer-size) 2000000))
    (message "Backups disabled for this buffer due to size > 2 megs")
    (make-local-variable 'backup-inhibited)
    (setq backup-inhibited t)))

#+end_src



background:
      the faq suggests to auto-save using
(setq auto-save-visited-file-name t)
        and to toggle auto-saving in the current buffer, type `M-x auto-save-mode'

        however, this is  buggy.
        it leaves around lock files, which can be disabled with
        (setq create-lockfiles nil)
        but it is also buggy on other things that appear to hook onto file saving
        so i created my own function, which originally had bugs,
        but new emacs version fixed all that, yay!.


; not using, but here for documentation,
; alternate way to enable and specify how long between autosaves.
        ; number of input events between autosave.
        ; lowest bound of functionality is actually about 15 input events
        ;(setq auto-save-interval
** todo keep an eye out for why/when and fix the fact that normal auto-save files are being made soemtimes
they are #filename#
seems they are created

* bbdb
#+begin_src emacs-lisp
;; based on bbdb manual
;; also has instructions to initialize upon launching gnus, etc
;; but I figure try this to make sure everything works all the time first
(require 'bbdb)
(bbdb-initialize 'message)

;; recommended by gnus,
;; but seems like it could be good to have set for other stuff
(setq user-full-name "Ian Kelling")
;; general email setting? recommended by mu4e
(setq message-kill-buffer-on-exit t)


;; based on emacs24-starter-kit
(setq bbdb-offer-save 'auto
      bbdb-notice-auto-save-file t
      bbdb-expand-mail-aliases t
      bbdb-canonicalize-redundant-nets-p t
      bbdb-complete-name-allow-cycling t)

;; use d instead
(add-hook 'bbdb-mode-hook
          (lambda () (define-key bbdb-mode-map (kbd "C-k") nil)))

(require 'bbdb-csv-import)

        #+end_src

* bookmark settings
#+begin_src emacs-lisp
; save bookmarks whenever they are changed instead of just when emacs quits
(setq bookmark-save-flag 1)
; increase bookmark context size for better functionality
(setq bookmark-search-size 2000)
#+end_src
* c-like settings
#+begin_src emacs-lisp
;; change last thing from gnu.
;; notably this avoids brace indent after if, and 4 space indent
(setq c-default-style '((java-mode . "java")
                        (awk-mode . "awk")
                        (other . "stroustrup")))
;; for emacs itself, use
;; (setq c-default-style '((java-mode . "java")
;;                         (awk-mode . "awk")
;;                         (other . "gnu")))
;; (setq-default c-basic-offset 2)
#+end_src
* color theme

A Theme builder is available at http://elpa.gnu.org/themes/ along with
a list of pre-built themes at http://elpa.gnu.org/themes/view.html and
themes are available through ELPA.


interesting light themes


  #+begin_src emacs-lisp
(defun override-theme (arg)
  (interactive)
  (while custom-enabled-themes
    (disable-theme (car custom-enabled-themes)))
  (load-theme arg t))
(setq color-theme-is-global t)

(defun toggle-night ()
  (interactive)
  (cond  ((equal (car custom-enabled-themes) 'naquadah)
          ;; background off white to be better on the eyes. took this
          ;; color from gitweb.
          (custom-set-faces `(default ((t (:background "#F6F6F0")))))
          (override-theme 'leuven))
         (t
          ;; revert previous background change
          (custom-set-faces `(default ((t (:background nil)))))
          (override-theme 'naquadah))))

(custom-set-faces `(default ((t (:background "#F6F6F0")))))
(override-theme 'leuven) ;; org mode features, with monitor darkened. part of org-mode i think


;; disable color thing with this:
;;(disable-theme (car custom-enabled-themes))

;; decent dark themes

;;(override-theme 'tangotango)
;;(override-theme 'deeper-blue)
;;(override-theme 'tango-dark)
;;(override-theme 'tsdh-dark)

;;(override-theme 'heroku)
;;(override-theme 'inkpot)  ;; part of inkpot-theme package
;;(override-theme 'naquadah) ; org mode features, part of  naquadah-theme package
;;(override-theme 'spolsky) ;; part of sublime-themes package
;;(override-theme 'twilight-anti-bright)  ;; from twilight-anti-bright-theme package

;; interesting but not usable colors
;;(override-theme 'cyberpunk) ; cool org mode features, from cyberpunk-theme package
;;(override-theme 'wombat) ; cursor not visible enough. from a wombat package, not sure which
;;(override-theme 'misterioso) ; cursor not visible enough



;;decent light themes
;;(override-theme 'alect-light) ; theres a -alt version, don't see a dif. could use this without dimming. from alect-something package
;;(override-theme 'occidental) ; from occidental-theme package


;;color-theme is deprecated in emacs 24.

;; theme packages i tried then removed:
;; ignored ones that didn't use the new theme engine

;;66 packages (zenburn-theme-2.1, zen-and-art-theme-1.0.1, waher-theme-20130917.7, ujelly-theme-1.0.35, twilight-theme-1.0.0, twilight-bright-theme-20130605.143, twilight-anti-bright-theme-20120713.316, tronesque-theme-1.3, tron-theme-12, toxi-theme-0.1.0, tommyh-theme-1.2, tango-2-theme-1.0.0, sunny-day-theme-20131203.1250, sublime-themes-20140117.323, subatomic-theme-20131011.1048, soothe-theme-0.3.16, soft-morning-theme-20131211.1342, soft-charcoal-theme-20130924.1206, sea-before-storm-theme-0.3, purple-haze-theme-20130929.1751, phoenix-dark-pink-theme-20130905.941, phoenix-dark-mono-theme-20130306.1215, pastels-on-dark-theme-0.3, obsidian-theme-20130920.937, nzenburn-theme-20130513, noctilux-theme-20131019.31, mustang-theme-20130920.939, monokai-theme-0.0.10, molokai-theme-20130828.0, late-night-theme-0.0, jujube-theme-0.1, ir-black-theme-20130302.2355, gruvbox-theme-20131229.1458, gruber-darker-theme-0.6, grandshell-theme-20140118.1003, github-theme-0.0.3, gandalf-theme-0.1, flatland-theme-20131204.858, django-theme-20131022.202, deep-thought-theme-0.1.1, dakrone-theme-20131212.1159, colorsarenice-theme-20131128.1106, color-theme-wombat+-0.0.2, color-theme-wombat-0.0.1, color-theme-twilight-0.1, color-theme-tango-0.0.2, color-theme-solarized-20120301, color-theme-sanityinc-solarized-2.25, color-theme-railscasts-0.0.2, color-theme-monokai-0.0.5, color-theme-molokai-0.1, color-theme-ir-black-1.0.1, color-theme-heroku-1.0.0, color-theme-github-0.0.3, color-theme-eclipse-0.0.2, color-theme-dpaste-0.0.1, color-theme-dawn-night-1.0, color-theme-colorful-obsolescence-0.0.1, color-theme-cobalt-0.0.2, color-theme-20080305.34, clues-theme-20130908.801, busybee-theme-20130920.942, bubbleberry-theme-0.1.2, mblage-theme-20130715.621, anti-zenburn-theme-20140104.1542, ample-zen-theme-0.2)



#+end_src

* yasnippet

cd ~/.emacs.d/src
git clone --recursive https://github.com/capitaomorte/yasnippet
touch snippets/.yas-make-groups

  This all makes it so I can look through the default snippets
  in the menu bar, but they don't show up elsewhere, because they are
  mostly things I don't want.

#+begin_src emacs-lisp

    (require 'yasnippet)
    ;; this needs to be before yas-global-mode
    (setq yas-snippet-dirs (list "~/.emacs.d/snippets"))
    (yas-global-mode 1)

    (setq
     yas-also-auto-indent-first-line t
     yas-choose-tables-first t
     yas-use-menu (quote full)
     ;; this sets ido-prompt as first function
     yas-prompt-functions
     '(yas-ido-prompt yas-dropdown-prompt yas-x-prompt yas-completing-prompt yas-no-prompt))

    ;; todo, explore this option for wrapping region
    ;; '(yas/wrap-around-region t))

#+end_src

#+RESULTS:
| yas-ido-prompt | yas-dropdown-prompt | yas-x-prompt | yas-completing-prompt | yas-no-prompt |

* cross session settings
  #+begin_src emacs-lisp

;; Save a list of recent files visited.
(recentf-mode 1)
(setq recentf-max-saved-items 200
      recentf-max-menu-items 15)


(setq save-place t
      save-place-version-control 'nospecial
      save-place-limit 40000
      save-place-file "~/.emacs.d/places")



;; savehist keeps track of some history
;; search entries
(setq savehist-additional-variables '(kill-ring search-ring regexp-search-ring)
      ;; save every minute
      savehist-autosave-interval 60
      ;; keep the home clean
      savehist-file "~/.emacs.d/.savehist")
(savehist-mode 1)

#+end_src

* ediff
#+begin_src emacs-lisp
;; ediff-buffers is the main command to use

;; ediff - don't start another frame for the control panel
;; unfortunately, this doesn't allow me to use 2 frames for the diff buffers
;; so disable this temporarily with the next line if you want that
;; sometime I should setup 2 functions to explicitly do each type
(setq ediff-window-setup-function 'ediff-setup-windows-plain)
;;(setq ediff-window-setup-function 'ediff-setup-windows-default)

;; do side by side diffs
(setq ediff-split-window-function 'split-window-horizontally)


#+end_src



Things I tried which didn't work, which intuitively I think should work better: I can open the second diff buffer in a new frame, and close it's window in the first frame after starting ediff, but when I hit n to go to the next diff, it restores the window in the first frame. Another thing I tried is to open 2 new frames and set them up as I want. However, if I try to open the *Ediff Control Panel* buffer in a different window from its original one, my mouse jumps to one of the diff frames, or if that isn't visible, the buffer just hangs until I select the original ediff control panel window. This seems like a bug to me. I am using a very recent development version of emacs.

* dired
#+begin_src emacs-lisp

;; dired - reuse current buffer by pressing 'a'
(put 'dired-find-alternate-file 'disabled nil)
#+end_src

* mu4e
[[info:org#External links]]
[[info:mu4e#Keybindings]]

alsot tried notmuch, it had some glitches, and it's config
has a list of folders which i'd rather not publish, so it's config is archived.

#+begin_src emacs-lisp
;;(add-to-list 'load-path "/usr/local/share/emacs/site-lisp/mu4e")
;;(add-to-list 'load-path "/usr/share/emacs/site-lisp/mu4e")
(require 'mu4e)

;; (setq mu4e-headers-results-limit 2000)

(setq
;; common to gnus. default sendmail-query-once asks us, then sets this via customize.
send-mail-function (quote sendmail-send-it)
      ;; use the standard imap folders
      mu4e-sent-folder   "/Sent"
      mu4e-drafts-folder "/Drafts"
      mu4e-trash-folder  "/Trash"
      ;; reindex new mail this often in seconds
      ;; show addresses instead of just names
      mu4e-view-show-addresses t
      mu4e-use-fancy-chars t
      mu4e-confirm-quit nil
      mu4e-headers-leave-behavior 'apply ;; dont ask, do whatever was marked
      mu4e-headers-fields (delq (assoc :mailing-list mu4e-headers-fields) mu4e-headers-fields)
      ;; default 500.
      mu4e-headers-results-limit 1000
      ;; tell exim to use from: as envelope from.
      ;; exim's default is use outgoing_msg_localpart@hostname.
      mail-specify-envelope-from t

      ;; looking up the list of maildirs when doing jo from summary
      ;; can take a few seconds if we have a ton of messages.
      ;; Only take that time for the first lookup.
      ;; if we add a new maildir, just restart mu4e for it to be in that list.
      mu4e-cache-maildir-list t
      ;; default is 8, way too small for my big monitors
      mu4e-headers-visible-lines 50
      )

;; fucks up reading unread bookmark. when that is fixed, enable it
;; (setq mu4e-update-interval 60)


;; this file includes setting up my email addresses, which are not public,
;; including
;; mu4e-user-mail-address-list
;; and a function
;; inspired by mu4e info manual, search for mu4e-compose-pre-hook.
(load "/p/c/mu4e.el")

(defun my-decrypt ()
  ;; use for decrypting in mu4e
  (interactive)
  (beginning-of-buffer)
  (when (search-forward "-----BEGIN PGP MESSAGE-----" nil t)
    (read-only-mode 0)
    (let ((start (match-beginning 0))
          (end (search-forward "-----END PGP MESSAGE-----" nil t)))
      (shell-command-on-region start end "gpg2 -dq" nil t shell-command-default-error-buffer t)
      )))
(add-hook 'mu4e-view-mode-hook 'my-decrypt)

(defun mu-set-from-name (regexes)
  "If we find an address matching regex, then set that address as the to,
and whatever was used"
  (when mu4e-compose-parent-message
    (let ((found nil))
      (while (and regexes (not found))
        (setq re (car regexes)
              regexes (cdr regexes)
              found (mu4e-message-contact-field-matches
                     mu4e-compose-parent-message :to re)))
      (when found (setq user-mail-address (cdr found)
                        user-full-name (car found)))
      found)))
(defun mu-set-from (regexes)
  "If we find an address matching regex, then set that address as the to,
and Ian Kelling as the name"
  (when mu4e-compose-parent-message
    (let ((found nil))
      (while (and regexes (not found))
        (setq re (car regexes)
              regexes (cdr regexes)
              found (cdr (mu4e-message-contact-field-matches
                          mu4e-compose-parent-message :to re))))
      (when found (setq user-mail-address found
                        user-full-name "Ian Kelling"))
      found)))


(defun my-mu4e-to-fsf ()
  "inspired by mu4e info manual, search for mu4e-compose-pre-hook."
  (cond
   ((mu-set-from '("iank@fsf.org"
                   "iank@gnu.org")))
   ((setq user-mail-address "iank@fsf.org"
          user-full-name "Ian Kelling"))))


;; on first run   mkdir -p /nocow/user/.mufsf; mu index --maildir=/nocow/user/fsfmd
(defun mu-exit-wait ()
  (interactive)
  ;; taken from the mu source
    (let* ((buf (get-buffer mu4e~proc-name))
          (proc (and (buffer-live-p buf) (get-buffer-process buf))))
    (mu4e-quit)
    ;; without sleep, we get database locked by another process error when hitting u
    ;; if another mu was running.
    (if proc (sleep-for 0 1000))))

(defun fsf-mu4e ()
  (interactive)
  (unless (equal mu4e-maildir "/nocow/user/fsfmd") (mu-exit-wait))
  (setq
   ;; fsf monitor is smaller
   mu4e-headers-visible-lines 15
   mu4e-maildir "/nocow/user/fsfmd"
   mu4e-refile-folder "/Spam"
   mu4e-index-lazy-check nil
   mu4e-get-mail-command "true"
   user-mail-address "iank@fsf.org"
   mail-signature "

-- 
Ian Kelling | Senior Systems Administrator, Free Software Foundation
GPG Key: B125 F60B 7B28 7FF6 A2B7  DF8F 170A F0E2 9542 95DF
https://fsf.org | https://gnu.org
"

   mu4e-user-mail-address-list '("iank@fsf.org"
                                 "iank@gnu.org")
   mu4e-maildir-shortcuts
   '( ("/INBOX"     . ?i)
      ("/sysadmin" . ?a)
      ("/sec"  . ?x)
      ("/rtcc"  . ?c)
      ("/Drafts"     . ?d)
      ("/Sent"     . ?s)
      )
   ) ;; end setq
  (call-process "/a/exe/lnf" nil nil nil "-T" "/nocow/user/.mufsf" (concat (getenv "HOME") "/.mu"))
  (add-hook 'mu4e-compose-pre-hook 'my-mu4e-to-fsf)
  (remove-hook 'mu4e-compose-pre-hook 'my-mu4e-to)
  (mu4e)) ;; end defun fsf-mu4e


;; it's implemented in mu4e, but not in the actions list for
;; some reason.
(add-to-list 'mu4e-view-actions
             '("browser view" . mu4e-action-view-in-browser) t)

;; normally, you would add to this, but we want to
;; modify unread messages. the first 4 are defined by default.
(setq mu4e-bookmarks
      `( ,(make-mu4e-bookmark
           :name  "Unread messages"
           ;; old less restrictive unread, for adapting in the future:
           ;; flag:unread AND NOT flag:trashed AND NOT maildir:/Junk AND NOT maildir:/fwfw AND NOT maildir:/log
           :query "flag:unread maildir:/INBOX"
           :key ?u)
         ,(make-mu4e-bookmark
           :name "Today's messages"
           :query "date:today..now"
           :key ?t)
         ,(make-mu4e-bookmark
           :name "Last 7 days"
           :query "date:7d..now"
           :key ?w)
         ,(make-mu4e-bookmark
           :name "Messages with images"
           :query "mime:image/*"
           :key ?p))
      )


(defun mu4e-action-msgs-by-this-sender (msg)
  "In header view, view messages by the sender of the message under point."
  (let ((from (mu4e-message-field msg :from)))
    (unless from
      (mu4e-error "No from header for this message"))
    ;; from is structured like: (("Anacron" . "root@x2.lan"))
    (mu4e-headers-search (concat "f:" (cdar from)))))

(add-to-list 'mu4e-headers-actions
             '("from this sender" . mu4e-action-msgs-by-this-sender) t)
(add-to-list 'mu4e-view-actions
             '("from this sender" . mu4e-action-msgs-by-this-sender) t)
#+end_src



* disabled but saved for documentation purposes
:PROPERTIES:
:header-args: :tangle no
:END:

** ido keybinds
*** C-j
ido-find-file create file
*** //]
ido goto root
*** C-k]
ido kill buffer/file
*** C-d]
ido open dired buffer
*** M-d]
ido search within all subdirectories
*** M-m]
ido create subdirectory
*** M-s]
ido search recently used directories
*** M-n/p]
ido next/previous recently used directory
*** C-s]
**** TODO implement this keybind, normally ctrl-space
ido use current pattern and start a new one


** indent settings for git's perl code
don't have a way to set this automatically or a good place to put this
#+begin_src emacs-lisp
(setq
 perl-indent-level 8
 perl-continued-statement-offset 8
 perl-continued-brace-offset -8
 perl-brace-offset 0
 perl-brace-imaginary-offset 0
 indent-tabs-mode t
 )
#+end_src
** org mode website

#+begin_src emacs-lisp
;; use org-publish-current-project with a project file open
(setq org-publish-project-alist
      '(("org"
         :base-directory "/a/h/src"
         :publishing-directory "/a/h/output"
         :base-extension "org"
         ;;:publishing-function org-org-publish-to-org
         :publishing-function org-html-publish-to-html
         :preserve-breaks t
         :html-postamble "Everything here is <a rel=\"license\"
    href=\"http://creativecommons.org/licenses/by-sa/4.0/\"><img
    alt=\"Creative Commons License\" style=\"border-width:0\"
    src=\"http://i.creativecommons.org/l/by-sa/4.0/80x15.png\" /></a>"
         :html-head "<link rel=\"stylesheet\"
                               href=\"style.css\"
                               type=\"text/css\"/>"
         :htmlized-source t)
        ("othersrc"
         :base-directory "/a/h/src"
         :base-extension "css\\|el\\|"
         :publishing-directory "/a/h/output"
         :publishing-function org-publish-attachment)
        ("other"
         :base-directory "/a/h/other"
         :base-extension ".*"
         :publishing-directory "/a/h/output"
         :publishing-function org-publish-attachment)))
;; default is xhtml-strict. don't really care, but this is more common
(setq org-html-doctype "html4-strict")

;; this is needed for worg
;; todo: for my own site, I need to define the css in a separate file
;; in order to use this setting. see the variable help for info
(setq org-export-htmlize-output-type t)


#+end_src

** bash-completion
#+begin_src emacs-lisp
;; this eventually gets set in
;; comint-dynamic-complete-functions
;; (car comint-dynamic-complete-functions)
(autoload 'bash-completion-dynamic-complete "bash-completion"
  "BASH completion hook")
(add-hook 'shell-dynamic-complete-functions
          'bash-completion-dynamic-complete)

;; this appears useless, but was in the recommended init code
(add-hook 'shell-command-complete-functions
          'bash-completion-dynamic-complete)

(defun ac-rlc-setup-sources ()
  "Add me to shell-mode-hook!"
  (setq ac-sources '(ac-source-shell)))
(add-hook 'shell-mode-hook 'ac-rlc-setup-sources)

#+end_src

** misc stuff
  It is an awesome mode for keyboard navigation.
  However, using the mouse takes less thought and works as well

  #+begin_src emacs-lisp


    ;; whitespace-mode config. minimal for bad whitespace
                                            ;(setq whitespace-line-column 80) ; for style of lines-tail, but I have it disabled
    (setq whitespace-style '(face tabs empty trailing))
                                            ;to enable whitespace mode
    (whitespace-mode +1)



    (defun org-set-mark-command (arg)
      "Do set-mark-command and then org-show-context if the point
              moves to invisible text."
      (interactive "P")
      (let ((initial-point (point)))
        (setq this-command 'set-mark-command)
        (set-mark-command (arg))
        (if (and (not (= (point) initial-point))
                 (or (outline-invisible-p) (org-invisible-p2)))
            (org-show-context 'mark-goto))))

    (defun org-exchange-point-and-mark (&optional arg)
      (interactive "P")
      (let ((initial-point (point)))
        (exchange-point-and-mark)
        (if (and (not (= (point) initial-point))
                 (or (outline-invisible-p) (org-invisible-p2)))
            (org-show-context 'mark-goto))))


    (defun toggle-mode-line ()
      "Toggle mode line on and off."
      (interactive)
      (if mode-line-format
          (progn (setq my-saved-mode-line-format mode-line-format)
                 (setq mode-line-format nil))
        (setq mode-line-format my-saved-mode-line-format))
      (force-mode-line-update))
    (toggle-mode-line)
    (global-set-key (kbd "M-m") 'toggle-mode-line)
    (add-hook 'after-change-major-mode-hook
              (lambda () (setq my-saved-mode-line-format mode-line-format)
                (setq mode-line-format nil)))


  #+end_src

** Copy mode-line to the top
  #+begin_src emacs-lisp
;; Copy mode-line to the top
(setq-default header-line-format mode-line-format
mode-line-format nil)
;; copied the mode-line theme into the header theme, else it is unreadable
;; this goes after loading the theme
(let ((class '((class color) (min-colors 89))))
(custom-theme-set-faces
   'leuven
     `(header-line ((,class (:box (:line-width 1 :color "#1A2F54") :foreground "#85CEEB" :background "#335EA8"))))))

  #+end_src

** tab bindings for when I wanted to make tab be for search
#+begin_src emacs-lisp

  (define-key emacs-lisp-mode-map (kbd "<tab>") nil)
  (define-key button-buffer-map "\t" nil)
  (define-key button-buffer-map (kbd "f") 'forward-button)
  (define-key Info-mode-map "\t" nil)
  (define-key widget-keymap "\t" nil)
  (define-key widget-keymap (kbd "<tab>") nil)

  (add-hook 'compilation-mode-hook (lambda ()
                                     (define-key compilation-mode-map (kbd "<tab>") nil)
                                     (define-key compilation-mode-map "\t" nil)))

;; unbind c-i for yas. it already separately binds <tab>
  (add-hook 'yas-minor-mode-hook (lambda ()
                                     (define-key yas-minor-mode-map "\t" nil)))

  (add-hook 'haskell-interactive-mode-hook
            (lambda ()
              (define-key haskell-interactive-mode-map "\t" nil)
              (define-key haskell-interactive-mode-map (kbd "<tab>") 'haskell-interactive-mode-tab)))

    (define-key minibuffer-local-must-match-map "\t" nil)
  (define-key minibuffer-local-must-match-map (kbd "<tab>") 'minibuffer-complete)
  (define-key minibuffer-local-completion-map (kbd "<tab>") 'minibuffer-complete)
  (define-key minibuffer-local-completion-map "\t" 'minibuffer-complete)

  (add-hook 'ido-setup-hook
            (lambda()
              (define-key ido-completion-map (kbd "<tab>") 'ido-complete)
              (define-key ido-completion-map "\t" nil)))

#+end_src

** kill buffer and window
#+begin_src emacs-lisp
 (defun kill-buffer-and-window ()
        "Close the current window and kill the buffer it's visiting."
        (interactive)
        (progn
          (kill-buffer)
          (delete-window)))
#+end_src
** sending multiple commands to a comint buffer
without waiting for commands to finish is unreliable.
seems like 1 in 100 times, an invisible command to restore prompt didn't work
#+begin_src emacs-lisp
(setq shell-unset-prompt "unset PROMPT_COMMAND; unset PS1")
  (setq shell-set-prompt "PROMPT_COMMAND=prompt_command")

(if (boundp 'shell-unset-prompt)
              (send-invisible-string proc shell-unset-prompt))
(if (boundp 'shell-set-prompt)
              (send-invisible-string proc shell-set-prompt))


  (defun send-invisible-string (proc string)
    "Like send-invisible, but non-interactive"
    (comint-snapshot-last-prompt)
    (funcall comint-input-sender proc string))

#+end_src




** org-mode auto-complete source

todo, someday take a look at this. it is broken.

;(defvar ac-source-eshell-pcomplete
;  '((candidates . (pcomplete-completions))))
;(defun ac-complete-eshell-pcomplete ()
;  (interactive)
;  (auto-complete '(ac-source-eshell-pcomplete)))

;(add-hook 'org-mode-hook (lambda () (setq ac-sources (cons 'ac-source-eshell-pcomplete ac-sources))))
;(add-to-list 'ac-modes 'eshell-mode)


** gnus nice unicode


this looks nice, but it lags gnus just a bit
#+begin_src emacs-lisp

(defun gnus-pretty-chars-setup ()
  (when window-system
    (setq gnus-sum-thread-tree-indent "  "
          gnus-sum-thread-tree-root "● "
          gnus-sum-thread-tree-false-root "◯ "
          gnus-sum-thread-tree-single-indent "◎ "
          gnus-sum-thread-tree-leaf-with-other "├─► "
          gnus-sum-thread-tree-vertical "│"
          gnus-sum-thread-tree-single-leaf "╰─► ")))
;; dunno why, but this didn't work just setting on startup
(add-hook 'gnus-startup-hook 'gnus-pretty-chars-setup)

#+end_src

** misc
#+begin_src emacs-lisp

;; this makes more ergonomic sense, since our eyes are mostly on the left,
;; but after using it a while, it's too much cognitive dissonance that
;; every other program has it on the right
;;(set-scroll-bar-mode 'left)



; todo, is this require things necessary?
;    (require 'flyspell)



  ; whenever M-tab is completion, swap it with tab
  ;(define-key emacs-lisp-mode-map (kbd "<tab>") 'completion-at-point)
  ;(define-key emacs-lisp-mode-map (kbd "C-M-i") 'indent-for-tab-command)
  ;(define-key lisp-interaction-mode-map (kbd "<tab>") 'completion-at-point)
  ;(define-key lisp-interaction-mode-map (kbd "C-M-i") 'indent-for-tab-command)
  ;the global tab keyind. for some reason this totally screws up mini-buffer tab.
  ; disabled until I actually find myself using this, and find a fix for the above problem
  ;(global-set-key (kbd "<tab>")  'complete-symbol)


  ; todo, make my custom overlays have an underline if they are
  ;  overriding a paren matching overlay
  ; make right click set the mark
  ; make search tab do completion instead of meta-tab
  ; in isearch, move C-y to C-v
  ; in isearch, move c-s to c-f

  ;  some testing to figure out the underlining when paren highlight conflicts
  ;      (let ((extra-overlays (overlays-at (1+ end-point))))
  ;       (when extra-overlays (print extra-overlays)))




  ; commented out because it messes up yank-pop.
; todo, fix it someday
  ; make yank linewise if it ends in a newline
  ;(defadvice yank (before linewise-yank-advice activate)
  ;  (let ((arg (ad-get-arg 0)))
  ;  (when (string-match "\n[ \t]*$" (current-kill (cond
  ;;                        ((listp arg) 0)
  ;;                        ((eq arg '-) -2)
  ;;                        (t (1- arg))) t))
  ;; (move-beginning-of-line nil))))



; todo, look into augmenting auto-complete with hippie expand.
; starter kit has some hippie expand settings to look into:
; (when (boundp 'hippie-expand-try-functions-list)
;    (delete 'try-expand-line hippie-expand-try-functions-list)
;    (delete 'try-expand-list hippie-expand-try-functions-list))


;; hippie expand is dabbrev expand on steroids
;(setq hippie-expand-try-functions-list '(try-expand-dabbrev
;                                         try-expand-dabbrev-all-buffers
;                                         try-expand-dabbrev-from-kill
;                                         try-complete-file-name-partially
;                                         try-complete-file-name
;                                         try-expand-all-abbrevs
;                                         try-expand-list
;                                         try-expand-line
;                                         try-complete-lisp-symbol-partially
;                                         try-complete-lisp-symbol))
;; use hippie-expand instead of dabbrev
;(global-set-key (kbd "M-/") 'hippie-expand)


; commented because i haven't had time to check it out yet
;; shorter aliases for ack-and-a-half commands
;(defalias 'ack 'ack-and-a-half)
;(defalias 'ack-same 'ack-and-a-half-same)
;(defalias 'ack-find-file 'ack-and-a-half-find-file)
;(defalias 'ack-find-file-same 'ack-and-a-half-find-file-same)




; todo. take a look at fixing this
;delete-old-versions t ; fix description in http://www.emacswiki.org/emacs/ForceBackups




;; prelude uses paredit mode.
;; paredit has some useful stuff but also annoying stuff.
;; if I ever do a ton of lisp coding, I should look into it






  ; random notes and example code


  ; usefull thing
  ;(map 'list #'list tabSwapKeys (reverse (getBinds tabSwapKeys)))

  ; example of getting keymap info
  ;(car (car (minor-mode-key-binding (kbd "C-/") t)))
  ;(cdr (car (minor-mode-key-binding (kbd "C-/") t)))
  ;(global-key-binding (kbd "C-M-i") t)
  ;(minor-mode-key-binding (kbd "<tab>") t)
  ;(local-key-binding (kbd "C-M-i") t)
  ;(current-minor-mode-maps)
  ;(cdr (assq 'undo-tree-mode minor-mode-map-alist))


  ; center on incremental search, instead of being at top or bottom of screen.
  ; i'm hoping that setting Isearch Allow Scroll is good enough to fix this annoyance
  ;from http://stackoverflow.com/questions/11052678/emacs-combine-iseach-forward-and-recenter-top-bottom

  ;example of constant definition of an overlay and propreries
  ;(defface mouse-flash-position '((t (:background "Yellow")))
  ;  "*Face used to highlight mouse position temporarily."
  ;  :group 'mouse)
  ;(defface mouse-flash-position '((t (:background "Yellow")))
  ;  "*Face used to highlight mouse position temporarily."
  ;  :group 'mouse)
  ;(defconst mouse-flash-posn-overlay
  ;    ;; Create and immediately delete, to get "overlay in no buffer".
  ;  (let ((ol  (make-overlay (point-min) (point-max))))
  ;    ;(delete-overlay ol)
  ;    ;(overlay-put ol 'face 'mouse-flash-position)
  ;    (overlay-put ol 'mouse-face 'mouse-flash-position)
  ;    (overlay-put ol 'priority 1000000)
  ;    ol)
  ;  "Overlay to highlight current mouse position.")


  ;tip, put the last interactive command as elisp on the kill ring:
  ;C-x <ESC> <ESC> C-a C-k C-g

  ; example of overlay testing
  ;(setq foo (make-overlay 2 3 nil t nil))
  ;(setq foo2 (make-overlay 3 4 nil t nil))
  ;(overlay-put foo 'face '(:background "red3" :foreground "black"))
  ;(overlay-put foo2 'face '(:background "red1" :foreground "black"))
  ;(overlay-put foo 'face 'visible-mark-face)
  ;(overlay-put foo 'face visible-mark-face2)


#+end_src


** SQL

disabled, as I haven't used it in a long time. I think it was good for learning some sql stuff.
#+begin_src emacs-lisp :tangle no
(require 'sqlup-mode)
(add-hook 'sql-mode-hook 'sqlup-mode)
(add-hook 'sql-interactive-mode-hook 'sqlup-mode)

(setq sql-product 'postgres)
#+end_src


** icomplete
#+begin_src emacs-lisp
;; without this, on partial completion return would exit the minibuffer, and i had to
;; keep typing out letters do a full completion before pressing enter.
;; super annoying. So I picked ctrl-j as a free key to put exit,
;; but in practice, I would just use ctrl-g to quit. Anyways,
;; ivy is doing all the minibuffer stuff, so removed this as it's
;; unused, so it can't cause any problems in future
(when (boundp 'icomplete-minibuffer-map)
  (define-key icomplete-minibuffer-map (kbd "C-j") 'exit-minibuffer)
  (define-key icomplete-minibuffer-map (kbd "<return>")
    'minibuffer-force-complete-and-exit))


#+end_src
* elisp settings
#+begin_src emacs-lisp
; when manually evaluating lisp, go into debugger on error
(setq eval-expression-debug-on-error t)
;reminder of useful var: debug-on-error
#+end_src





* gnus

good info http://www.emacswiki.org/emacs/GnusTutorial
good info http://www.emacs.uniyar.ac.ru/doc/em24h/emacs183.htm


After downloading mailing list archives, once you have an mbox file,
there are rather straightforward ways to get it into any mail program,
but I will cover gnus, which I use and is a bit tricky.

gnus has a native search (limited, too slow for body text searches), and external search engine integration.
gnus manual recommends converting to maildir for searching local mail, but importing lots of maildir messages to gnus
takes 10+ minutes, so scratch that option. it suggests 2 alternate options
mairix. for mbox, it doesn't integrate 100% with gnus, it copies the search results to a mbox
and tells gnus to make a group of that mbox and display it. This means the read state won't be persistent, but otherwise
works great.

local imap server which will use the mbox and provide search.
dovecot is modular, theres a dovecot-common which uses recommends to install i guess it's most used modules. Its
description is completely not useful. Anyways, I'm not sure if there is any benefit to installing this over just the
module we need.
pi dovecot-imapd

dovecot by default also makes a an inbox folder based on the normal local mail location /var/mail/<username>
those locations are adjustable and well documented via the var mail_location in
/etc/dovecot/conf.d/10-mail.conf
I forward my local mail, didn't see immediately how to turn off the inbox, but it will always be empty, so I left as
is. you could make the var be empty, which apparently has the same effect.

Originally just linked the default location ~/.mail, but I changed to altering the config since ~/.mail since it seems
other things like postfix use that location

based on http://roland.entierement.nu/blog/2010/09/08/gnus-dovecot-offlineimap-search-a-howto.html
other links that poped up contained outdated, innacurate information
http://sachachua.com/blog/2008/05/geek-how-to-use-offlineimap-and-the-dovecot-mail-server-to-read-your-gmail-in-emacs-efficiently/
http://www.emacswiki.org/emacs/JamesFerguson
http://www.sanityinc.com/articles/read-mailing-lists-in-emacs-over-imap/

Within emacs you can move messages between mbox and maildir etc, which is a nice flexibility.



doc group for mbox:
in gnus, do gnus-group-make-doc-group (G f in groups buffer) and point to the file

info about groups created within gnus is stored in ~/.newsrc.eld
also stored is a duplication of what email messages are read/unread,
what newsgroups are subsribed to and read/unread,
probably more stuff, everything that gnus saves.


searching the body of the messages, i cut off after a few minutes.
i can grep the file in just a couple seconds


random side note
we can also get mbox from gmane
http://notmuchmail.org/howto/#index7h2


gnus can't search mboxes except with its builtin search which is extremely slow. mairix can do mbox files from the command
line, but not from within gnus, but from mairix.el, which can then open the results in gnus

mbox can be converted to maildir easily, but gnus loads lots of maildir messages extremely slow. it parses all the
headers and generates a nov file for each.

nnfolder-generate-active-file

to reset things, when changing mail group. I duno all the proper way, but it works to delete
~/Mail ~/.newsrc.eld ~/.dribble (or something)


** mail sources vs select methods background
I found this very confusing when first reading through the manual.  "mail sources" is a term that does not simply mean
sources of mail, it is much narrower for gnus. sources of mail can be either "mail sources" or select methods. Mail
sources will move mail to ~/Mail (not sure what format), and split it into groups according to variables. You can use
"mail sources" for maildir / imap, but those can also be read via select methods, which do not move the mail from their
location, but use them in their native format. This is what I want to do, and I can simply ignore mail
sources. Confusing terminology is that "fetching mail" "scanning mail", lots of things mail doesn't mean all mail, it
means specifically from "mail sources". The words "articles" and "news" is used in connection with select methods, aka my actual mail.



** caching background

caching:
there is also ~/News/cache, filled with a bunch of articles, like 300 megs. can't figure out why.
Grepped for caching in the manual, found 2 main things.
cache is for 2 purposes. to cache locally, and to keep articles from expiring, called persistence
gnus-use-cache, which puts things if they are
gnus-cache-enter-articles
things go in cache when they are marked certain ways by default, ticked and dormant
and read articles are moved out of the cache
still no idea why i have a bunch in the cache, but I set a var so that my mail won't get cached
I'm gonna delete the cache, and check on it later see what exactly is going in there
And of course, I moved ~/News to my encrypted drive and symlinked it


* haskell
:LOGBOOK:
:END:

useful comint-shell mode commands. If not prefaced with *, it means it is not in the haskell custom repl
*todo: setup haskell c-t toggle arrow keys
tab completion
C-q insert prev arg
C-( history search
c-m-left/right move to next/prev prompts
*c-enter, multi-line input
*s-delete, send input across windows. (i can implement this)
*c-m-l clear screen
*haskell-process-interrupt, c-cc terminate job (i can implement this maybe)

nice bash/readline functions missing in comint:
yank-nth-arg
operate-get-next
menu-complete

usefull comint commands:
c-cl : list historic command in temp buffer
C-c C-o comint-delete-output
comint-restore-input, todo: put this on a randomish c-c key



todo:
checkout haskell repl functions:
c-cv haskell-check, hlint
C-M-q           prog-indent-sexp
c-c.  haskell-mode-format-imports
C-c M-/         haskell-doc-check-active
haskell-process-generate-tags
haskell-process-cabal-build
haskell-cabal-command.. or something
haskell-process-restart
C-h v haskell-process-log
C-h v haskell-process-show-debug-tips

various not immediately useful functions:
haskell-process-add-dependency
haskell-process-touch-buffer
haskell-process-cd
haskell-process-unignore
haskell-process-reload-devel-main


rebind
home: C-a             haskell-interactive-mode-beginning
c-return: C-j             haskell-interactive-mode-newline-indent
up/down: <C-down>        haskell-interactive-mode-history-next

todo haskell mode better binds for:
'haskell-process-load-file
'haskell-process-do-type
'haskell-process-do-info
'inferior-haskell-send-decl


commands which don't work in haskell-interactive-mode(hi) vs inferior-haskell-mode(ih, default)
functions not in hi:
inferior-haskell-find-definition, use tags instead
inferior-haskell-find-haddock, todo, test if this works

redefined ih to hi
switch-to-haskell -> 'haskell-interactive-switch
haskell-process-load-file -> inferior-haskell-load-file
haskell-process-do-type -> inferior-haskell-type
switch-to-haskell -> haskell-interactive-switch
inferior-haskell-load-file -> 'haskell-process-load-file


haskell-mode installation from source, based on its readme
in the git directory,
make all

#+begin_src emacs-lisp



;; remove default option to not link the file
(setq haskell-compile-command "ghc -Wall -ferror-spans -fforce-recomp %s")
(add-hook 'haskell-indentation-mode-hook
          (lambda ()
            (define-key haskell-indentation-mode-map [?\C-d] nil)
            (define-key haskell-indentation-mode-map
              (kbd "<deletechar>")
              'haskell-indentation-delete-char)))

;;copied from haskell-mode docs in order to use the new, better, nondefault
;;interactive mode.
(eval-after-load "haskell-mode"
  '(progn
     (define-key haskell-mode-map (kbd "C-x C-d") nil)
     (define-key haskell-mode-map (kbd "C-c C-z") 'haskell-interactive-switch)
     (define-key haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-file)
     (define-key haskell-mode-map (kbd "C-c C-b") 'haskell-interactive-switch)
     (define-key haskell-mode-map (kbd "C-c C-t") 'haskell-process-do-type)
     (define-key haskell-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
     (define-key haskell-mode-map (kbd "C-c M-.") nil)
     (define-key haskell-mode-map (kbd "C-c C-d") nil)))

;; ghc-mod install http://www.mew.org/~kazu/proj/ghc-mod/en/emacs.html
;; todo, try this out
;; (autoload 'ghc-init "ghc" nil t)
;;(add-hook 'haskell-mode-hook (lambda () (ghc-init) (flymake-mode)))



;; from the package readme for ghci-completion
(require 'ghci-completion)
(add-hook 'inferior-haskell-mode-hook 'turn-on-ghci-completion)


;; disable some rebinds. they are set to appropriate keys in the keybinds section
(eval-after-load "haskell-mode"
  '(progn
     (define-key haskell-mode-map (kbd "C-a") 'nil)
     (define-key haskell-mode-map (kbd "C-j") 'nil)))

(eval-after-load "python-mode"
  '(progn
(define-key python-mode-map (kbd "C-j") nil)))

(defun pretty-lambdas-haskell ()
  (font-lock-add-keywords
   nil `((,(concat "(?\\(" (regexp-quote "\\") "\\)")
          (0 (progn (compose-region (match-beginning 1) (match-end 1)
                                    ,(make-char 'greek-iso8859-7 107))
                    nil))))))
;; from haskell-mode manual
(add-hook 'haskell-mode-hook 'turn-on-haskell-decl-scan)
(when (window-system)
  (add-hook 'haskell-mode-hook 'pretty-lambdas-haskell))

;; added from haskell-mode website install instructions
                                        ;(load "/usr/share/emacs/site-lisp/haskell-mode/haskell-site-file")
(add-hook 'haskell-mode-hook 'turn-on-haskell-doc-mode)
;;the three indentation modules are mutually exclusive - add at most one. Trying out the "most advanced"
(add-hook 'haskell-mode-hook 'turn-on-haskell-indentation)
;;(add-hook 'haskell-mode-hook 'turn-on-haskell-indent)
;;(add-hook 'haskell-mode-hook 'turn-on-haskell-simple-indent)


;; todo, set this to some other key
;;    (local-set-key (kbd "C-e") 'my-haskell-load-and-run)

(defun my-haskell-load-and-run ()
  "Loads and runs the current Haskell file."
  (interactive)
  (let ((start-buffer (current-buffer)))
    (inferior-haskell-load-and-run inferior-haskell-run-command)
    (sleep-for 0 100)
    (end-of-buffer)
    (pop-to-buffer start-buffer)))

;; show haskell function in mode line
;; todo, this broke after updating emacs
;;(eval-after-load "which-func"
;;  '(add-to-list 'which-func-modes 'haskell-mode))



(add-hook 'interactive-haskell-mode-hook 'ac-haskell-process-setup)
(add-hook 'haskell-interactive-mode-hook 'ac-haskell-process-setup)
(eval-after-load "auto-complete"
  '(add-to-list 'ac-modes 'haskell-interactive-mode))

(add-hook 'haskell-mode-hook
          (lambda () (define-key haskell-mode-map (kbd "C-(")
                  (lambda () (interactive)
                    (basic-save-buffer)
                    (haskell-compile)
                    (run-with-timer .3 nil 'repeat-shell)))))
(add-hook 'haskell-cabal-mode-hook
          (lambda () (define-key haskell-cabal-mode-map (kbd "C-(") 'haskell-compile)))



(add-hook 'haskell-interactive-mode-hook
          (lambda ()
            (define-key haskell-interactive-mode-map "\r" nil)
            (define-key haskell-interactive-mode-map (kbd "<return>") 'haskell-interactive-mode-return)))
(add-hook 'haskell-indentation-mode-hook (lambda () (define-key haskell-indentation-mode-map "\r" nil)))



(add-hook 'haskell-interactive-mode-hook
          (lambda ()
            (define-key haskell-interactive-mode-map (kbd "<C-M-return>") 'haskell-interactive-mode-newline-indent)))

  #+end_src

#+RESULTS:
| (lambda nil (define-key haskell-interactive-mode-map (kbd <C-M-return>) (quote haskell-interactive-mode-newline-indent))) | (lambda nil (define-key haskell-interactive-mode-map \n nil) (define-key haskell-interactive-mode-map (kbd <return>) (quote haskell-interactive-mode-return))) | ac-haskell-process-setup |

* isearch
#+begin_src emacs-lisp
(setq
isearch-allow-scroll t
search-ring-update t) ;; dont start an edit when going to previous search

   (defun isearch-yank-regexp (regexp)
     "Pull REGEXP into search regexp."
     (let ((isearch-regexp nil)) ;; Dynamic binding of global.
       (isearch-yank-string regexp))
     (isearch-search-and-update))

   (defun isearch-yank-symbol (&optional partialp backward)
     "Put symbol at current point into search string.

     If PARTIALP is non-nil, find all partial matches."
     (interactive "P")

     (let (from to bound sym)
       (setq sym
   ; this block taken directly from find-tag-default
   ; we couldn't use the function because we need the internal from and to values
             (when (or (progn
                         ;; Look at text around `point'.
                         (save-excursion
                           (skip-syntax-backward "w_") (setq from (point)))
                         (save-excursion
                           (skip-syntax-forward "w_") (setq to (point)))
                         (> to from))
                       ;; Look between `line-beginning-position' and `point'.
                       (save-excursion
                         (and (setq bound (line-beginning-position))
                              (skip-syntax-backward "^w_" bound)
                              (> (setq to (point)) bound)
                              (skip-syntax-backward "w_")
                              (setq from (point))))
                       ;; Look between `point' and `line-end-position'.
                       (save-excursion
                         (and (setq bound (line-end-position))
                              (skip-syntax-forward "^w_" bound)
                              (< (setq from (point)) bound)
                              (skip-syntax-forward "w_")
                              (setq to (point)))))
               (buffer-substring-no-properties from to)))
       (cond ((null sym)
              (message "No symbol at point"))
             ((null backward)
              (goto-char (1+ from)))
             (t
              (goto-char (1- to))))
       (isearch-search)
       (if partialp
           (isearch-yank-string sym)
         (isearch-yank-regexp
          (concat "\\_<" (regexp-quote sym) "\\_>")))))

   (defun isearch-current-symbol (&optional partialp)
     "Incremental search forward with symbol under point.

     Prefixed with \\[universal-argument] will find all partial
     matches."
     (interactive "P")
     (let ((start (point)))
       (isearch-forward-regexp nil 1)
       (isearch-yank-symbol partialp)))
;; todo, make this

   (defun isearch-backward-current-symbol (&optional partialp)
     "Incremental search backward with symbol under point.

     Prefixed with \\[universal-argument] will find all partial
     matches."
     (interactive "P")
     (let ((start (point)))
       (isearch-backward-regexp nil 1)
       (isearch-yank-symbol partialp)))



   ; lets look through emacs starter kit before we throw this out.


 ;   automatically wrap to the top of the buffer when isearch fails
     (defadvice isearch-search (after isearch-no-fail activate)
       (unless isearch-success
         (ad-disable-advice 'isearch-search 'after 'isearch-no-fail)
         (ad-activate 'isearch-search)
         (isearch-repeat (if isearch-forward 'forward))
         (ad-enable-advice 'isearch-search 'after 'isearch-no-fail)
         (ad-activate 'isearch-search)))

   ;; Activate occur easily inside isearch
   (define-key isearch-mode-map (kbd "C-o")
     (lambda () (interactive)
       (let ((case-fold-search isearch-case-fold-search))
         (occur (if isearch-regexp
                    isearch-string
                  (regexp-quote isearch-string))))))


#+end_src

* lisp / elisp mode setings
#+begin_src emacs-lisp

  (add-hook 'emacs-lisp-mode-hook 'starter-kit-remove-elc-on-save)
  (defun starter-kit-remove-elc-on-save ()
    "If you're saving an elisp file, likely the .elc is no longer valid."
    (make-local-variable 'after-save-hook)
    (add-hook 'after-save-hook
              (lambda ()
                (if (file-exists-p (concat buffer-file-name "c"))
                    (delete-file (concat buffer-file-name "c"))))))


  (defun emacs-lisp-mode-defaults ()
    ;; checkdoc has an annoying feature that wants a header and footer
    ;; in every elisp buffer as if they all were packages
    ;; todo, see if there is a way
    ;; to make checkdoc usable instead of just disabling it as I do here
    (if (boundp 'flycheck-checkers)
        (setq flycheck-checkers (remove 'emacs-lisp-checkdoc flycheck-checkers)))
    (eldoc-mode 1))
  (add-hook 'emacs-lisp-mode-hook 'emacs-lisp-mode-defaults)

  (define-key lisp-mode-map (kbd "<M-up>") 'backward-up-list)
  (define-key lisp-mode-map (kbd "<M-down>") 'down-list)
  (define-key emacs-lisp-mode-map (kbd "<M-up>") 'backward-up-list)
  (define-key emacs-lisp-mode-map (kbd "<M-down>") 'down-list)
  (define-key emacs-lisp-mode-map (kbd "<M-escape>") 'find-function-at-point)

  ;; interactive modes don't need whitespace checks
  (defun interactive-lisp-coding-defaults ()
    (whitespace-mode -1))
  (setq prelude-interactive-lisp-coding-hook 'prelude-interactive-lisp-coding-defaults)


  ;; ielm is an interactive Emacs Lisp shell
  (defun ielm-mode-defaults ()
    (run-hooks 'prelude-interactive-lisp-coding-hook)
    (turn-on-eldoc-mode))
  (add-hook 'ielm-mode-hook 'ielm-mode-defaults)

#+end_src


* java eclim

based on https://github.com/senny/emacs-eclim


eclim: eclipse completion, searching, validation, etc inside emacs
install
#+begin_src sh :tangle no
cd ~/opt
git clone git://github.com/ervandew/eclim.git
cd eclim
pi ant
ant -Declipse.home=/a/opt/eclipse
#+end_src


currently makes emacs hang a bunch. dunno why. just using eclipse instead
#+begin_src emacs-lisp :tangle no
(require 'eclim)
(global-eclim-mode)

;; just do java
(setq eclim-accepted-file-regexps
 '("\\.java"))

(custom-set-variables
  '(eclim-eclipse-dirs '("/a/opt/eclipse"))
  '(eclim-executable "/a/opt/eclipse/eclim"))

(setq help-at-pt-display-when-idle t)
(setq help-at-pt-timer-delay 0.1)
(help-at-pt-set-timer)

;; dunno if this line is needed
(require 'eclimd)
(setq eclimd-default-workspace "/a/bin/eclipse-workspace")

;;add the emacs-eclim source
(require 'ac-emacs-eclim-source)
(add-hook 'java-mode-hook 'ac-emacs-eclim-java-setup)

#+end_src

#+RESULTS:
| ac-emacs-eclim-java-setup |

* mediawiki
#+begin_src emacs-lisp

(eval-after-load "mediawiki"
  '(progn
    (remove-hook 'outline-minor-mode-hook 'mediawiki-outline-magic-keys)
    (add-hook 'mediawiki-mode-hook
              (lambda () (define-key mediawiki-mode-map (kbd "C-(") 'mediawiki-save-reload)))

    ;; mediawiki mode has a bug that it will claim an edit conflict unless you reload after saving.
    ;; I also like to save with no edit summary for previewing on my local mw instance
    (defun mediawiki-save-reload ()
      (interactive)
      (and (mediawiki-save "") (mediawiki-reload)))))
#+end_src
* modes with little configuration needed
  #+begin_src emacs-lisp
;; busted:
  ;;(require 'csv-mode)
;;(add-to-list 'auto-mode-alist '("\\.[Cc][Ss][Vv]\\'" . csv-mode))

(require 'outshine)
(add-hook 'outline-minor-mode-hook 'outshine-hook-function)
(add-hook 'emacs-lisp-mode-hook 'outline-minor-mode)
(add-hook 'sh-mode-hook 'outline-minor-mode)



(setq org-caldav-url "https://cal.iankelling.org"
org-caldav-calendar-id "ian"
org-caldav-inbox "/p/cal.org")
;;(org-caldav-sync)


;;(require 'dtrt-indent)
;;(setq dtrt-indent-mode t)

(setq css-indent-offset 2)

(load-file "/a/h/iank-mod.el")

;; from when i was running my own patches
;;(add-to-list 'load-path "/a/opt/ws-butler")

(require 'ws-butler)
;; todo: I think this is broken, it keeps collapsing the last line
;; for empty messages.

;; the main problem is when it deletes the blank line at the end
;; of a message with an empty body. but I might also
;; be pasting whitespace significant things in here, so
;; just don't do anything.
;; todo: propose this upstream
(add-to-list 'ws-butler-global-exempt-modes 'message-mode)

(ws-butler-global-mode)



(require 'nginx-mode)
;;The mode should automatically activate for files called nginx.conf and files under /etc/nginx - if not, you can add something like this to your init file:
;;(add-to-list 'auto-mode-alist '("/etc/nginx/sites-available/.*" . nginx-mode))

;; todo, put this on a hook with prog mode
;;(highlight-indentation-mode 1)

(add-hook 'auto-revert-tail-mode-hook
          (lambda ()
            (when (string=
                   buffer-file-name
                   "/var/log/cloudman/development/cm-service.log")
              (setq-local prev-auto-revert-max 0)
              ;; set buffer-local hook
              (add-hook 'after-revert-hook 'tail-colorize nil t))))
(defun tail-colorize ()
  (ansi-color-apply-on-region prev-auto-revert-max (point-max))
  (setq-local prev-auto-revert-max (point-max)))


;; gnu global
(require 'ggtags)
(add-hook 'c-mode-common-hook
          (lambda () (ggtags-mode 1)
            (setq c-label-minimum-indentation 0)))

;; specific to my unusual keybind setup, you may want to
;; pick different keys
(define-key ggtags-mode-map (kbd "C-M-o") 'ggtags-find-tag-dwim)
(define-key ggtags-mode-map (kbd "C-M-m") 'ggtags-grep)

(defun gtags-update-single(filename)
  "Update Gtags database for changes in a single file"
  (interactive)
  (start-process "update-gtags" "update-gtags" "bash" "-c" (concat "cd " ggtags-project-root " ; gtags --single-update " filename )))

(defun gtags-update-current-file()
  (interactive)
  (let ((rel-filename (replace-regexp-in-string
                       ggtags-project-root "."
                       (buffer-file-name (current-buffer)))))
    (gtags-update-single rel-filename)))

(defun gtags-update-hook()
  "Update GTAGS file incrementally upon saving a file"
  (when (and ggtags-mode ggtags-project-root)
    (gtags-update-current-file)))

(add-hook 'after-save-hook 'gtags-update-hook)

;; i'd like to make some elisp which modifies a keymap to remove
;; all binds which don't match a predicate.
;; I tried setting a keymap to a new keymap,
;; but that didn't register as functional.
;; so I'd need to modify the list in place.

(require 'magit)


;; colorize hex colors: use rainbow mode


;; message mode prompted me on first message.
;; a function which describes options then sets this
;; the other options were to use smtp directly or pass to another mail client
;; here we use the standard sendmail interface, which I use postfix for
(setq send-mail-function (quote sendmail-send-it))

(require 'spray)
(global-set-key (kbd "C-M-w") 'spray-mode)
;; remember, h/l = move. f/s = faster/slower, space = pause, all others quit

;; delete active selection with self-insert commands
(delete-selection-mode t)

;; Transparently open compressed files
(auto-compression-mode t)

;; Highlight matching parenthesesq when the pointq is on them.
;; not needed since smart paren mode?
;;  (show-paren-mode 1)


;; not documented, but looking at the source, I find this
;; stops me from being asked what command on every C-c-c
;; when doing a latex document.
(setq TeX-command-force "LaTeX")

;; dot mode, repeats last action
(require 'dot-mode)
(add-hook 'find-file-hooks 'dot-mode-on)


;; clean up obsolete buffers automatically at midnight
(require 'midnight)


;; disabled because it takes 400ms on startup
;; ;; emacs regexes are too limited.
;; (require 'foreign-regexp)
;; ;; perl is most powerful, but javascript is pretty close and
;; ;; I'd rather know javascript stuff than perl
;; (custom-set-variables
;;  '(foreign-regexp/regexp-type 'javascript) ;; Choose by your preference.
;;  '(reb-re-syntax 'foreign-regexp)) ;; Tell re-builder to use foreign regexp.
;; ;; it would be nice to add documentation to do this for more commands to that package
;; ;; disabled because it's too slow. but I'd still m-x it for advanced replacements
;; ;;(define-key global-map [remap isearch-forward-regexp] 'foreign-regexp/isearch-forward)


;; saner regex syntax
(require 're-builder)
(setq reb-re-syntax 'string)


;; use shift + arrow keys to switch between visible buffers
;; todo, set these keys to something else
(require 'windmove)
(windmove-default-keybindings)


;; show the name of the current function definition in the modeline
(require 'which-func)
(setq which-func-modes t)
(which-function-mode 1)


;; enable winner-mode to manage window configurations
(winner-mode +1)

;; meaningful names for buffers with the same name
(require 'uniquify)
(setq uniquify-buffer-name-style 'forward
      uniquify-separator "/"
      ;; for sdx work. until I figure out a better way.
      ;; maybe something like projectile can do it,
      ;; or hacking around the status bar
      uniquify-min-dir-content 2
      uniquify-after-kill-buffer-p t ; rename after killing uniquified
      uniquify-ignore-buffers-re "^\\*") ; don't muck with special buffers


;; makefiles require tabs
;; todo: find a makefile indent function that works,
;; best I could find is this one which means don't indent at all
;;
(add-hook 'makefile-mode-hook
          (lambda ()
            (setq indent-tabs-mode t)
            (setq indent-line-function (lambda () 'no-indent))))


;; todo, turn on auto-fill just for txt files
;;(add-hook 'text-mode-hook 'turn-on-auto-fill)
(add-hook 'text-mode-hook 'turn-on-flyspell)


;; auto indent shell script comments
(setq sh-indent-comment t)

;; random extra highlights
(require 'volatile-highlights)
(volatile-highlights-mode t)


;; make help buffers smaller when it makes sense
(temp-buffer-resize-mode 1)


(require 'info+)
;; based on suggestions in info+.el, I also installed  misc-fns, strings, and thingatpt+
;; remove some bad keybinds from info+
(define-key Info-mode-map [mouse-4]         nil)
(define-key Info-mode-map [mouse-5]         nil)


(require 'smooth-scroll)
;; long gnus summary buffers lags too much with this,
;; but I like it enough to leave it enabled by default
;; and crank up the step size to be faster
;; and it doesn't have a way to enable it only for certain modes etc.
;; todo sometime, make it work for certain modes only
(smooth-scroll-mode t)
;; its too slow with the default of 2
(setq smooth-scroll/vscroll-step-size 7)
;; sublimity doesn't work as good going fast by default
;; smooth-scrolling.el, does not do smooth scrolling. its about cursor location


(setq sh-here-document-word "'EOF'")

(setq tramp-default-method "ssh")
  #+end_src
* misc general settings

#+begin_src emacs-lisp
;; https://www.emacswiki.org/emacs/FillParagraph
;; make list items start paragraphs.
(setq paragraph-start "\f\\|[ \t]*$\\|[ \t]*[-+*] ")

(setq sh-basic-offset 2)
(setq vc-follow-symlinks t)

;; give us a shell to start instead of scratch
;;(setq initial-buffer-choice (lambda () (new-shell)))

;; disable this nasty function, as I always use a gui
(defun suspend-frame() (interactive))

;; Seed the random-number generator
(random t)

;; easier to remember than keybinds
(defalias 'scrypt 'mml-secure-message-encrypt-pgpmime)
(defalias 'sign 'mml-secure-message-sign-pgpmime)
(defun encrypt ()
  (interactive)
  (mml-secure-message-encrypt-pgpmime 'dontsign))

;; don't highlight the region.
(set-face-background 'region nil)

;; this fixes save error for python example code
(define-coding-system-alias 'UTF-8 'utf-8)

;; i don't use frame titles, but if I ever do
;; this starter kit setting is probably good
(if window-system (setq frame-title-format '(buffer-file-name "%f" ("%b"))))


;;(prefer-coding-system 'utf-8-unix)

;; remove ugly 3d box feature
(set-face-attribute 'mode-line nil :box nil)

(add-to-list 'default-frame-alist
             '(font . "DejaVu Sans Mono-11"))
; the default will jump 2 sizes.
(setq text-scale-mode-step 1.1)
(setq font-lock-maximum-decoration t
      inhibit-startup-message t
      transient-mark-mode t
      delete-by-moving-to-trash t
      shift-select-mode nil
      truncate-partial-width-windows nil
      uniquify-buffer-name-style 'forward
      oddmuse-directory "~/.emacs.d/oddmuse"
      echo-keystrokes 0.1
      mark-ring-max 160
      sort-fold-case t  ; case insensitive line sorting
      global-mark-ring-max 1000
      ;; the visible bell seems to lag the ui
      ;;visible-bell t
      ;; turn off audible bell
      ;; https://www.emacswiki.org/emacs/AlarmBell
      ring-bell-function 'ignore
      case-replace nil
      revert-without-query '(".*")
      ;; don't pause display code on input.
      ;; smoother display performance at slight cost of input performance
      redisplay-dont-pause t
      font-lock-maximum-decoration t) ; probably default and not necesary


(setq-default indent-tabs-mode nil ;; don't use tabs to indent
              cursor-type 'box
              fill-column 72

              ;; wrap at word boundaries instead of mid-word
              word-wrap t
              imenu-auto-rescan t
              indicate-empty-lines t) ; mark end of buffer


(blink-cursor-mode '(-4))
(menu-bar-mode -1)
(tool-bar-mode -1)


;; enable various commands
(put 'narrow-to-region 'disabled nil)
(put 'narrow-to-page 'disabled nil)
(put 'narrow-to-defun 'disabled nil)
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(put 'scroll-left 'disabled nil)
;; these from graphene, haven't read about them yet
(put 'ido-complete 'disabled nil)
(put 'ido-exit-minibuffer 'disabled nil)
(put 'dired-find-alternate-file 'disabled nil)
(put 'autopair-newline 'disabled nil)



;;disable and minimize various prompts/messages
(fset 'yes-or-no-p 'y-or-n-p)
(setq confirm-nonexistent-file-or-buffer nil
      inhibit-startup-message t
      inhibit-startup-echo-area-message t
      inhibit-startup-screen t
      compilation-read-command nil ;; just don't compile with unsafe file local vars
      kill-buffer-query-functions (remq 'process-kill-buffer-query-function
                                        kill-buffer-query-functions))


;; exit without bothering me
;; http://stackoverflow.com/questions/2706527/make-emacs-stop-asking-active-processes-exist-kill-them-and-exit-anyway/2708042#2708042
(add-hook 'comint-exec-hook
      (lambda () (set-process-query-on-exit-flag (get-buffer-process (current-buffer)) nil)))
;; based on save-buffers-kill-emacs help string, don't ask about clients when exiting
;; apparently this would need to be in some later hook. dunno where is best, but this works
(defadvice save-buffers-kill-emacs (before no-client-prompt-advice activate)
  (setq kill-emacs-query-functions (delq 'server-kill-emacs-query-function kill-emacs-query-functions)))



;; (custom-set-faces
;;  ;; setting header-line-format to " " as a hack for a top margin the oly thning I could find to do a top margin
;;  '(header-line ((t (:background "default" :foreground "default" :overline nil :underline nil))))
;;  ;; don't highlight the region
;;  '(region ((t nil))))
(setq-default header-line-format " ")


(setq initial-scratch-message nil)
 #+end_src


vertical margin background.
google turned up: http://lists.gnu.org/archive/html/help-gnu-emacs/2014-03/msg00544.html
the xresource doesn't work for me, probably an xmonad thing.

figured out I needed to customize the header line face. To find the face, M-x list-faces-display or just google / search
info,
then M-x customize-face
header-line
unchecked some stuff so that it inherits from default.

* misc function definitions
#+begin_src emacs-lisp


(defun fill-buffer ()
  (interactive)
  (save-mark-and-excursion
    (beginning-of-buffer)
    (while (= (forward-line) 0)
      (fill-paragraph))))


(defun next-backup-dir ()
"In a directory listing from rsync -n,
Go to the next directory based on where the cursor is."
  (interactive)
  (let* ((start-col (current-column))
         (end-col (progn (skip-chars-forward "^/\n") (current-column)))
         (dir (progn
                (beginning-of-line 1)
                (buffer-substring-no-properties (point) (+ (point) end-col)))))
    (message dir)
    (forward-line 1)
    (while (and (not (eobp))
                (string= dir (buffer-substring-no-properties (point) (+ (point) end-col))))
      (forward-line 1))
    (forward-char-same-line start-col)))
;; copy paste this for fast keybind
;;(local-set-key (kbd "<kp-enter>"))


(defun goto-buffer-or-find-file (file-name)
  "If buffer is with FILE-NAME exists, go to it, else open the file using full path."
  (interactive)
  (let ((b (get-buffer (file-name-nondirectory file-name))))
    (if b
        (switch-to-buffer b)
      (find-file file-name))))




;; todo, i think this is broken. perhaps the last goto-char is not accounting for buffer or something
(defun unpop-global-mark ()
  "Unpop off global mark ring. Does nothing if mark ring is empty."
  (interactive)
  (when global-mark-ring
    (setq global-mark-ring (cons (copy-marker (mark-marker)) global-mark-ring))
    (let ((lm (car (last global-mark-ring))))
      (set-marker (mark-marker) (marker-position lm) (marker-buffer lm)))
    (when (null (mark t)) (ding))
    (setq global-mark-ring (nbutlast global-mark-ring))
    (goto-char (marker-position (mark-marker)))))

(defun indent-buffer ()
  "Indents the entire buffer."
  (interactive)
  (cond ((derived-mode-p 'org-mode)
         (org-indent-region (point-min) (point-max)))
        ((derived-mode-p 'python-mode)
         (py-autopep8))
        (t
         (indent-region (point-min) (point-max)))))


;; TODO doesn't work with uniquify
(defun rename-file-and-buffer ()
  "Renames current buffer and file it is visiting."
  (interactive)
  (let ((name (buffer-name))
        (filename (buffer-file-name)))
    (if (not (and filename (file-exists-p filename)))
        (message "Buffer '%s' is not visiting a file!" name)
      (let ((new-name (read-file-name "New name: " filename)))
        (cond ((get-buffer new-name)
               (message "A buffer named '%s' already exists!" new-name))
              (t
               (rename-file name new-name 1)
               (rename-buffer new-name)
               (set-visited-file-name new-name)
               (set-buffer-modified-p nil)))))))



(defun sudo-edit (&optional arg)
  (interactive "P")
  (if (or arg (not buffer-file-name))
      (find-file (concat "/sudo::" (ido-read-file-name "File: ")))
    (find-alternate-file (concat "/sudo::" buffer-file-name))))



(defun backward-symbol (arg)
  (interactive "p")
  (forward-symbol (- arg)))

#+end_src

* mode line
#+begin_src emacs-lisp
;; make window title be the buffer name
(setq frame-title-format "%b")

  ; -----------------------------
  ; fixing up the mode line
  ; modified from mastering emacs blog
  ; ----------------------------

  (defvar mode-line-cleaner-alist
    `((auto-complete-mode . "")
      (yas/minor-mode . "")
      (paredit-mode . "")
      (auto-fill-function . "")
      (eldoc-mode . "")
      (abbrev-mode . "")
      (flyspell-mode . "")
      (glasses-mode . "")
      (dot-mode . "")
      (yas-global-mode . "")
      (yas-minor-mode . "")
      (undo-tree-mode . "")
      (volatile-highlights-mode . "")
      (highlight-symbol-mode . "")
      ;; Major modes
      (lisp-interaction-mode . "λ")
      (hi-lock-mode . "")
      (python-mode . "Py")
      (emacs-lisp-mode . "EL")
      (nxhtml-mode . "nx"))
    "Alist for `clean-mode-line'.

  When you add a new element to the alist, keep in mind that you
  must pass the correct minor/major mode symbol and a string you
  want to use in the modeline *in lieu of* the original.")


  (defun clean-mode-line ()
    (interactive)
    (loop for cleaner in mode-line-cleaner-alist
          do (let* ((mode (car cleaner))
                    (mode-str (cdr cleaner))
                    (old-mode-str (cdr (assq mode minor-mode-alist))))
               (when old-mode-str
                 (setcar old-mode-str mode-str))
               ;; major mode
               (when (eq mode major-mode)
                 (setq mode-name mode-str)))))

; disabled
;  (add-hook 'after-change-major-mode-hook 'clean-mode-line)


  ;;; alias the new `flymake-report-status-slim' to
  ;;; `flymake-report-status'
  (defalias 'flymake-report-status 'flymake-report-status-slim)
  (defun flymake-report-status-slim (e-w &optional status)
    "Show \"slim\" flymake status in mode line."
    (when e-w
      (setq flymake-mode-line-e-w e-w))
    (when status
      (setq flymake-mode-line-status status))
    (let* ((mode-line " Φ"))
      (when (> (length flymake-mode-line-e-w) 0)
        (setq mode-line (concat mode-line ":" flymake-mode-line-e-w)))
      (setq mode-line (concat mode-line flymake-mode-line-status))
      (setq flymake-mode-line mode-line)
      (force-mode-line-update)))


(defun my-after-change-major-mode-hook ()
  (setq mode-line-mule-info nil
        minor-mode-alist nil
        mode-line-position nil)) ; todo, make only flymake status show up

(add-hook 'after-change-major-mode-hook 'my-after-change-major-mode-hook)
#+end_src

* mouse related
** settings
#+begin_src emacs-lisp
  (setq focus-follows-mouse t
        mouse-autoselect-window t
        xterm-mouse-mode t)
#+end_src
** move-mouse-to-point
todo, this is buggy with multiple windows open.
#+begin_src emacs-lisp
(defun move-mouse-to-point ()
  (interactive)
  (let* ((pos (posn-col-row (posn-at-point)))
         (x (+ (car pos) 2)) ; no idea why this is off by 1-2
         (y (cdr pos)))
    (set-mouse-position (selected-frame) x y)))
#+end_src
** cursor highlight
disabled until fixed
#+begin_src emacs-lisp :tangle no
    (defun mouse-follow-cursor ()
      ;(if (not (equal this-command last-command)) (print this-command))
;debug
 ;    (print this-command)
      (when (and this-command (not (string= this-command "show-pointer")))
        (let* ((pos (posn-col-row (posn-at-point)))
               (x (1+ (car pos))) ; no idea why this is off by 1
               (y (cdr pos)))
      (setq ignore-mouse-visibility t)
          (set-mouse-position (selected-frame) x y))
    ;(sleep-for 0 100)
        (frame-make-pointer-invisible)))

    ;    (when this-command
    ;      (if (string= this-command "show-pointer")
    ;    (frame-make-pointer-visible)
  ;))



    (defun show-pointer ()
      (interactive)
      (if ignore-mouse-visibility
          (setq ignore-mouse-visibility nil)
;  (print "visible")
      (frame-make-pointer-visible)))

      (setq ignore-mouse-visibility t)
; disabled
 ;   (global-set-key (kbd "<mouse-movement>") 'show-pointer)

 ;   (add-hook 'post-command-hook 'mouse-follow-cursor t)


    ; status. working, except that all scroll wheel actions send a mouse-movement command before doing their actual command, which makes the pointer flicker.
   ; this is just an artifact of xbindkeys. when i do my own mouse chip, it will fix this.

; we could set track-mouse to nil, then do the command, then set it back. i like that idea a bit better.
    ; we could do the same thing in the other case of ignore-mouse-visibility.

    ; there are also other issues, it doesn't work with changing buffers on a split screen.
   ; i think a good idea along with this would be for the cursor to follow the mouse all the time.
   ; i have done code for that in my mouse 1 function,
   ; i just need to read it again and try it out.




    ; this does not take care of scrolling,
    ; a post-command hook function below does,
    ; but it breaks when the frame is split.
    ; the bug is specifically in mouse-pixel-position
    ; todo, fix this eventually
    (defun mouse-highlight-event (event)
      (interactive "e")
      (when (or (not event) (mouse-movement-p event)
                (memq (car-safe event) '(switch-frame select-window)))
        (let ((pos (posn-point (event-end event))))
          (if (eq (overlay-buffer mouse-hi-ov) (current-buffer))
              (move-overlay mouse-hi-ov pos (1+ pos))
            (delete-overlay mouse-hi-ov)
            (setq mouse-hi-ov
                  (make-overlay pos (1+ pos)))
            (overlay-put mouse-hi-ov
                         'insert-in-front-hooks (list 'mouse-hi-modification))
            (overlay-put mouse-hi-ov 'priority 1001))
          (cond ((save-excursion (goto-char pos) (eolp))
                 (overlay-put mouse-hi-ov 'face nil)
                 (overlay-put mouse-hi-ov 'before-string
                              (propertize
                               " "
                               'cursor t
                               'face 'mouse-cursor-face)))
                (t
                 (overlay-put mouse-hi-ov 'face 'mouse-cursor-face)
                 (overlay-put mouse-hi-ov 'before-string nil))))))


    ; overlay changed hook function
    (defun mouse-hi-modification (ov timing beginning end &optional length)
      "Make an overlay of length 1 not expand when text is inserted at the front."
      (when timing
        (let ((start (overlay-start ov)))
          (move-overlay ov start (1+ start)))))




    (defun mouse-hi-command-hook ()
    ; not sure if I need to deal with case of a nil mouse position in some unforseen situation.
      (let ((x-y (cdr (mouse-pixel-position))))
        (when (wholenump (car x-y))
          (let ((pos (posn-point (posn-at-x-y (car x-y) (cdr x-y) nil t))))
            (when pos
              (if (eq (overlay-buffer mouse-hi-ov) (current-buffer))
                  (move-overlay mouse-hi-ov pos (1+ pos))
                (delete-overlay mouse-hi-ov)
                (setq mouse-hi-ov
                      (make-overlay pos (1+ pos)))

                (overlay-put mouse-hi-ov 'priority 1001))
              (cond ((save-excursion (goto-char pos) (eolp))

                     (overlay-put mouse-hi-ov 'face nil)
                     (overlay-put mouse-hi-ov 'before-string
                                  (propertize
                                   " "
                                   'cursor t
                                   'face 'mouse-cursor-face)))
                    (t
                     (overlay-put mouse-hi-ov 'face 'mouse-cursor-face)
                     (overlay-put mouse-hi-ov 'before-string nil))))))))
    ; (pcase-let ((`(,_ ,x . ,y) (mouse-pixel-position)))
    ;                   (posn-point (posn-at-x-y x y)))))
    ; equivalent of above to find pos. todo, learn about the above syntax

    (setq mouse-hi-ov (make-overlay 1 1))
    (delete-overlay mouse-hi-ov)
    ; initialized overlay
    ; temporarily set to nil instead of t because it is broken and
    ; also has a bug that makes emacs not remember the column when
    ; doing  up and down movements.
    ; it also messes up yas/insert-snippet, dunno why.
; i should test out whether it is something in the post-command hook
;    (setq track-mouse t)
    ;(add-hook 'post-command-hook 'mouse-hi-command-hook)

    ;(mouse-hi-command-hook)
    ;(setq debug-on-error nil)

  #+end_src
** mouse 1 drag func

disabled as it breaks in newer emacs versions with this error, when
clicking on info links

"and: Symbol's function definition is void: mouse--remap-link-click-p"

#+begin_src emacs-lisp :tangle no

  ; Copied from mouse.el and modified.
  ; my modifications have comments prefaced by "ian"
  (defun mouse-drag-track (start-event  &optional
                                        do-mouse-drag-region-post-process)
    "Track mouse drags by highlighting area between point and cursor.
  The region will be defined with mark and point.
  DO-MOUSE-DRAG-REGION-POST-PROCESS should only be used by
  `mouse-drag-region'."
    (mouse-minibuffer-check start-event)
    (setq mouse-selection-click-count-buffer (current-buffer))
  ; ian. removed as unneeded since I don't use TMM
  ;(deactivate-mark)
    (let* ((scroll-margin 0) ; Avoid margin scrolling (Bug#9541).
           (original-window (selected-window))
           ;; We've recorded what we needed from the current buffer and
           ;; window, now let's jump to the place of the event, where things
           ;; are happening.
           (_ (mouse-set-point start-event))
           (echo-keystrokes 0)
           (start-posn (event-start start-event))
           (start-point (posn-point start-posn))
           (start-window (posn-window start-posn))
           (start-window-start (window-start start-window))
           (start-hscroll (window-hscroll start-window))
           (bounds (window-edges start-window))
           (make-cursor-line-fully-visible nil)
           (top (nth 1 bounds))
           (bottom (if (window-minibuffer-p start-window)
                       (nth 3 bounds)
                     ;; Don't count the mode line.
                     (1- (nth 3 bounds))))
           (on-link (and mouse-1-click-follows-link
                         ;; Use start-point before the intangibility
                         ;; treatment, in case we click on a link inside
                         ;; intangible text.
                         (mouse-on-link-p start-posn)))
           (click-count (1- (event-click-count start-event)))
           (remap-double-click (and on-link
                                    (eq mouse-1-click-follows-link 'double)
                                    (= click-count 1)))
           ;; Suppress automatic hscrolling, because that is a nuisance
           ;; when setting point near the right fringe (but see below).
           (auto-hscroll-mode-saved auto-hscroll-mode)
           (auto-hscroll-mode nil)
           moved-off-start event end end-point)

      (setq mouse-selection-click-count click-count)
      ;; In case the down click is in the middle of some intangible text,
      ;; use the end of that text, and put it in START-POINT.
      (if (< (point) start-point)
          (goto-char start-point))
      (setq start-point (point))
      (if remap-double-click
          (setq click-count 0))

      ;; Activate the region, using `mouse-start-end' to determine where
      ;; to put point and mark (e.g., double-click will select a word).
      (setq transient-mark-mode
            (if (eq transient-mark-mode 'lambda)
                '(only)
              (cons 'only transient-mark-mode)))
      (delete-overlay mouse-hi-ov) ; ian, added this.

      (let ((range (mouse-start-end start-point start-point click-count)))
        (push-mark (nth 0 range) t t)
        (goto-char (nth 1 range)))

      ;; Track the mouse until we get a non-movement event.
      (track-mouse
        (while (progn
                 (setq event (read-event))
                 (or (mouse-movement-p event)
                     (memq (car-safe event) '(switch-frame select-window))))
          (unless (memq (car-safe event) '(switch-frame select-window))
            ;; Automatic hscrolling did not occur during the call to
            ;; `read-event'; but if the user subsequently drags the
            ;; mouse, go ahead and hscroll.
            (let ((auto-hscroll-mode auto-hscroll-mode-saved))
              (redisplay))
            (setq end (event-end event)
                  end-point (posn-point end))
            ;; Note whether the mouse has left the starting position.
            (unless (eq end-point start-point)
              (setq moved-off-start t))
            (if (and (eq (posn-window end) start-window)
                     (integer-or-marker-p end-point))
                (mouse--drag-set-mark-and-point start-point
                                                end-point click-count)
              (let ((mouse-row (cdr (cdr (mouse-position)))))
                (cond
                 ((null mouse-row))
                 ((< mouse-row top)
                  (mouse-scroll-subr start-window (- mouse-row top)
                                     nil start-point))
                 ((>= mouse-row bottom)
                  (mouse-scroll-subr start-window (1+ (- mouse-row bottom))
                                     nil start-point))))))
          (visible-mark-move-overlays))) ; ian, added this


      ;; Handle the terminating event if possible.
      (when (consp event)
        ;; Ensure that point is on the end of the last event.
        (when (and (setq end-point (posn-point (event-end event)))
                   (eq (posn-window end) start-window)
                   (integer-or-marker-p end-point)
                   (/= start-point end-point))
          (mouse--drag-set-mark-and-point start-point
                                          end-point click-count))

        ;; Find its binding.
        (let* ((fun (key-binding (vector (car event))))
               (do-multi-click (and (> (event-click-count event) 0)
                                    (functionp fun)
                                    (not (memq fun '(mouse-set-point
                                                     mouse-set-region))))))
          (if (and (/= (mark) (point))
                   (not do-multi-click))

              ;; If point has moved, finish the drag.
              (let* (last-command this-command)
                (and mouse-drag-copy-region
                     do-mouse-drag-region-post-process
                     (let (deactivate-mark)
                       (copy-region-as-kill (mark) (point)))))

            ;; Otherwise, run binding of terminating up-event.
            (if do-multi-click
                (goto-char start-point)
              (deactivate-mark)
              (unless moved-off-start
                ;; ian: poping the mark is a poor choice of behavior.
                ;; we should delete the mark instead.
                ;; The first way I found to delete it is to pop it first
                (pop-mark)
                (setq mark-ring (nbutlast mark-ring))))

            (when (and (functionp fun)
                       (= start-hscroll (window-hscroll start-window))
                       ;; Don't run the up-event handler if the window
                       ;; start changed in a redisplay after the
                       ;; mouse-set-point for the down-mouse event at
                       ;; the beginning of this function.  When the
                       ;; window start has changed, the up-mouse event
                       ;; contains a different position due to the new
                       ;; window contents, and point is set again.
                       (or end-point
                           (= (window-start start-window)
                              start-window-start)))

              (when (and on-link
                         (= start-point (point))
                         (mouse--remap-link-click-p start-event event))

                ;; If we rebind to mouse-2, reselect previous selected
                ;; window, so that the mouse-2 event runs in the same
                ;; situation as if user had clicked it directly.  Fixes
                ;; the bug reported by juri@jurta.org on 2005-12-27.
                (if (or (vectorp on-link) (stringp on-link))
                    (setq event (aref on-link 0))
                  (select-window original-window)
                  (setcar event 'mouse-2)
                  ;; If this mouse click has never been done by the
                  ;; user, it doesn't have the necessary property to be
                  ;; interpreted correctly.
                  (put 'mouse-2 'event-kind 'mouse-click)))
              (push event unread-command-events)))))))
#+end_src

** mouse 3
#+begin_src emacs-lisp :tangle no


  (defun mouse3-range-mark (start click click-count)
    (let* ((range (mouse-start-end start click click-count))
           (beg (nth 0 range))
           (end (nth 1 range)))
      (cond ((<= click start)
             (set-mark beg))
            (t
             (set-mark end))))
    (visible-mark-move-overlays))


  (defun mouse3-set-mark (event)
    "in development"
    (interactive "e")
    (mouse-minibuffer-check event)
    ;; Use event-end in case called from mouse-drag-region.
    ;; If EVENT is a click, event-end and event-start give same value.
    (set-mark (posn-point (event-end event)))
    (visible-mark-move-overlays))


  (defun mouse3-func (start-event)
    "in development"
    (interactive "e")

    (run-hooks 'mouse-leave-buffer-hook)

    (mouse-minibuffer-check start-event)
    (setq mouse-selection-click-count-buffer (current-buffer))
    (push-mark (posn-point (event-end start-event)))

    (let* ((scroll-margin 0) ; Avoid margin scrolling (Bug#9541).
           (original-window (selected-window))
           ;; We've recorded what we needed from the current buffer and
           ;; window, now let's jump to the place of the event, where things
           ;; are happening.
  ;(_ (mouse-set-point start-event)) ; ian: commented, replaced
           (echo-keystrokes 0)
           (start-posn (event-start start-event))
           (start-point (posn-point start-posn))
           (start-window (posn-window start-posn))
           (start-window-start (window-start start-window))
           (start-hscroll (window-hscroll start-window))
           (bounds (window-edges start-window))
           (make-cursor-line-fully-visible nil)
           (top (nth 1 bounds))
           (bottom (if (window-minibuffer-p start-window)
                       (nth 3 bounds)
                     ;; Don't count the mode line.
                     (1- (nth 3 bounds))))
           (click-count (1- (event-click-count start-event)))
           ;; Suppress automatic hscrolling, because that is a nuisance
           ;; when setting point near the right fringe (but see below).
           (auto-hscroll-mode-saved auto-hscroll-mode)
           (auto-hscroll-mode nil)
           moved-off-start event end end-point)

      (setq mouse-selection-click-count click-count)
      ;; In case the down click is in the middle of some intangible text,
      ;; use the end of that text, and put it in START-POINT.
      (if (< (mark) start-point) ; ian: change point to the mark
          (set-mark start-point)
        (visible-mark-move-overlays))
      (setq start-point (mark))

      (delete-overlay mouse-hi-ov) ; ian, added this.

      ;; Activate the region, using `mouse-start-end' to determine where
      ;; to put point and mark (e.g., double-click will select a word).
      (let ((range (mouse-start-end start-point start-point click-count)))
        (set-mark (nth 1 range)))
      (visible-mark-move-overlays)


      ;; Track the mouse until we get a non-movement event.
      (track-mouse

        (while (progn
                 (setq event (read-event))
                 (or (mouse-movement-p event)
                     (memq (car-safe event) '(switch-frame select-window))))
          (unless (memq (car-safe event) '(switch-frame select-window))

            ;; Automatic hscrolling did not occur during the call to
            ;; `read-event'; but if the user subsequently drags the
            ;; mouse, go ahead and hscroll.
            (let ((auto-hscroll-mode auto-hscroll-mode-saved))
              (redisplay))
            (setq end (event-end event)
                  end-point (posn-point end))
            ;; Note whether the mouse has left the starting position.

            (unless (eq end-point start-point)
              (setq moved-off-start t))
            (if (and (eq (posn-window end) start-window)
                     (integer-or-marker-p end-point))
                (mouse3-range-mark start-point end-point click-count); ian, set mark

  ; do scrolling if needed
              (let ((mouse-row (cdr (cdr (mouse-position)))))
                (cond
                 ((null mouse-row))
                 ((< mouse-row top)
                  (mouse-scroll-subr start-window (- mouse-row top)
                                     nil start-point))
                 ((>= mouse-row bottom)
                  (mouse-scroll-subr start-window (1+ (- mouse-row bottom))
                                     nil start-point))))))))

      ;; Handle the terminating event if possible.
      (when (consp event)
        ;; Ensure that point is on the end of the last event.
        (when (and (setq end-point (posn-point (event-end event)))
                   (eq (posn-window end) start-window)
                   (integer-or-marker-p end-point)
                   (/= start-point end-point))
  ;(mouse--drag-set-mark-and-point start-point ; ian, set mark
  ;end-point click-count))
          (mouse3-range-mark start-point end-point click-count)); ian, set mark

        ;; Find its binding.
        (let* ((fun (key-binding (vector (car event))))
               (do-multi-click (and (> (event-click-count event) 0)
                                    (functionp fun)
                                    (not (memq fun '(mouse3-set-mark))))))
          (if (and (/= end-point start-point)
                   (not do-multi-click))

              ;; If point has moved, finish the drag.
              (let* (last-command this-command)
                (and mouse-drag-copy-region
                     do-mouse-drag-region-post-process
                     (let (deactivate-mark)
                       (copy-region-as-kill (mark) (point)))))

            ;; Otherwise, run binding of terminating up-event.
            (when do-multi-click
              (set-mark start-point)) ; ian, change this. why?
            (visible-mark-move-overlays)


            (when (and (functionp fun)
                       (= start-hscroll (window-hscroll start-window))
                       ;; Don't run the up-event handler if the window
                       ;; start changed in a redisplay after the
                       ;; mouse-set-point for the down-mouse event at
                       ;; the beginning of this function.  When the
                       ;; window start has changed, the up-mouse event
                       ;; contains a different position due to the new
                       ;; window contents, and point is set again.
                       (or end-point
                           (= (window-start start-window)
                              start-window-start)))

              (push event unread-command-events)))))))

#+end_src





* org mode

#+begin_src emacs-lisp

;; todo work on org-cycle-emulate-tab

;; todo, this doesn't work for a non-standard keybind
;;(setq org-special-ctrl-k t)

;; todo, generally fix org mode keys
;; todo, org-mark-element, unbdind from M-h, bind to mark defun key

;(org-babel-do-load-languages
; 'org-babel-load-languages
; '((emacs-lisp . t)
;   (sh . t)))

;; make shell work like interactive bash shell
(setq org-babel-default-header-args:sh
      '((:results . "output") (:shebang . "#!/bin/bash -l")))

;; my patch to output stderr
(setq org-babel-use-error-buffer nil)

                                        ;
;; org-mode manual suggests these, but I haven't used them.
;;(global-set-key "\C-cl" 'org-store-link)
;;(global-set-key "\C-ca" 'org-agenda)
;; this got in the way of a haskell mode command
;;(global-set-key "\C-cb" 'org-iswitchb)



      ;; org-src-tab-acts-natively t ; broken option. using next instead, todo fix

(setq org-src-fontify-natively t ; make babel blocks nice
      org-adapt-indentation nil
      org-src-preserve-indentation t
      ;; The most basic logging is to keep track of when a TODO item was finished.
      org-log-done 'time
      ;; use a drawer to keep the logs tidy
      org-log-into-drawer t
      org-extend-today-until 0
      org-startup-truncated nil
      org-clock-persist t
      org-clock-mode-line-total 'today
      ;; global STYLE property values for completion
      org-global-properties (quote (("STYLE_ALL" . "habit")))
      org-special-ctrl-a/e t  ;; home and end work special in headlines
      org-completion-use-ido t
      org-catch-invisible-edits 'smart)

      ;; non universally recommended settings
(setq
      org-default-notes-file (concat org-directory "/a/t.org")
      org-agenda-files (quote ("/a/t.org"))
      org-mobile-directory "/p/org-mobile"
      org-mobile-inbox-for-pull "/p/from-mobile.org"
      org-directory "/p")

;; modeilne populated from (org-clock-get-clocked-time)
;; which is populated from the var org-clock-total-time
;; which is populated by a function which starts from (org-clock-get-sum-start)
;;

(org-clock-persistence-insinuate)


(defun time-to-org-day (time)
  (round (time-to-number-of-days
          (time-subtract time (list 0 (* 3600 org-extend-today-until) 0)))))


(defun my-org-confirm-babel-evaluate (lang body)
  (not (or (string= (buffer-file-name) "/a/t.org")
           (string= (buffer-file-name) "/home/iank/.emacs.d/my-init.org")
           )))
(setq org-confirm-babel-evaluate 'my-org-confirm-babel-evaluate)


(defun org-time-stamp-with-time (arg)
  (interactive "P")
  ;; '(4) is the argument passed by universal prefix
  (org-time-stamp (if arg arg '(4)) t))

(defun ian-org-work-time ()
  (interactive)
  (save-excursion
    (set-buffer "t.org")
    (goto-char (org-find-entry-with-id "ian-identifier-1"))
    (org-clock-in)))

(defun ian-org-idle-time ()
  (interactive)
  (save-excursion
    (goto-char (org-find-entry-with-id "ian-identifier-2"))
    (set-buffer "t.org")
    (org-clock-in)))



;; based on http://stackoverflow.com/questions/3758139/variable-pitch-for-org-mode-fixed-pitch-for-tables
;; keywords: proportional font, monospace

(defun variable-pitch-on ()
  (variable-pitch-mode 1))
(add-hook 'fundamental-mode-hook 'variable-pitch-on)
(add-hook 'org-mode-hook 'variable-pitch-on)
(add-hook 'text-mode-hook 'variable-pitch-on)
(defun variable-pitch-off ()
  (variable-pitch-mode 0))
(add-hook 'yaml-mode-hook 'variable-pitch-off)


(set-face-attribute 'org-table nil :family (face-attribute 'fixed-pitch :family))
(set-face-attribute 'org-code nil :family (face-attribute 'fixed-pitch :family))
(set-face-attribute 'org-formula nil :family (face-attribute 'fixed-pitch :family))
(set-face-attribute 'org-link nil :family (face-attribute 'fixed-pitch :family))
(set-face-attribute 'org-block nil :family (face-attribute 'fixed-pitch :family))
(set-face-attribute 'org-date nil :family (face-attribute 'fixed-pitch :family))


(defun remove-org-binds ()
  (define-key org-mode-map (kbd "<M-return>") nil)
  (define-key org-mode-map (kbd "C-'") nil)
  (define-key org-mode-map (kbd "C-y") nil)
  (define-key org-mode-map (kbd "<C-return>") nil)
  (define-key org-mode-map (kbd "<C-M-kp-enter>") nil)
  (define-key org-mode-map (kbd "C-,") nil)
  (define-key org-mode-map (kbd "C-M-m") nil)
  (define-key org-mode-map (kbd "C-k") nil)
  (define-key org-mode-map (kbd "C-j") nil)
  (define-key org-mode-map (kbd "C-M-i") nil)
  (define-key org-mode-map (kbd "C-M-t") nil)
  (define-key org-mode-map (kbd "M-a") 'nil)
  (define-key org-mode-map (kbd "C-a") nil)
  (define-key org-mode-map (kbd "M-e") nil)
  (define-key org-mode-map (kbd "C-e") nil)
  (define-key org-mode-map (kbd "C-3") nil)
  (define-key org-mode-map (kbd "<M-left>") nil)
  (define-key org-mode-map (kbd "<M-right>") nil)
  (define-key org-mode-map (kbd "<S-return>") nil)
  (define-key org-mode-map (kbd "<tab>") nil)
  (define-key org-mode-map (kbd "<C-S-down>") nil)
  (define-key org-mode-map (kbd "<C-S-up>") nil)
  (define-key org-mode-map (kbd "<S-down>") nil)
  (define-key org-mode-map (kbd "<S-up>") nil)
  (define-key org-mode-map "\t" nil))
(add-hook 'org-mode-hook 'remove-org-binds)

#+end_src


* org drill


#+begin_src emacs-lisp :tangle no

  (setq
   ;; account actual time, not just scheduled time
   org-drill-adjust-intervals-for-early-and-late-repetitions-p t

   ;; still show leeches, but warn
   org-drill-leech-method (quote warn)
   ;; increased from default 20
   org-drill-maximum-duration 60
   ;; especially when starting, I want to drill hard
   org-drill-maximum-items-per-session nil
   ;; don't prompt to save buffer, auto-save will do that
   org-drill-save-buffers-after-drill-sessions-p nil
;; this one deals with varying difficulty items better
;; sm2 is similar, but more simplistic
 org-drill-spaced-repetition-algorithm (quote simple8)
)
#+end_src
;; todo, make the prompting text reflect this number.
   ;; org-drill-failure-quality

* os specific settings

disabled cuz I have none yet
  #+begin_src emacs-lisp :tangle no
 (cond ((eq system-type 'darwin))
        ((eq system-type 'gnu/linux))
        ((eq system-type 'windows-nt))
        (t ))
  #+end_src


* prog-mode-defaults

#+begin_src emacs-lisp


(defun prog-mode-defaults ()
  "Default coding hook, useful with any programming language."
  ;; so that I can do completion before the dialog pops up
  (local-set-key (kbd "<tab>") 'auto-complete)
  ;; todo, this is causing error message on loading file, prolly not working
  ;;(flycheck-mode +1)
  (setq ac-sources (delq 'ac-source-dictionary ac-sources))
  (highlight-symbol-mode)
  (make-local-variable 'column-number-mode)
  ;; this says do autofilling using newcomment.el. The "only" is a misnomer.
  (set (make-local-variable 'comment-auto-fill-only-comments) t)
  (column-number-mode t)
  (turn-on-smartparens-mode)

  ;; prettify lambdas
  (font-lock-add-keywords
   nil `(("(\\(lambda\\>\\)"
          (0 (progn (compose-region (match-beginning 1) (match-end 1)
                                    ,(make-char 'greek-iso8859-7 107))
                    nil))))))
(add-hook 'prog-mode-hook 'prog-mode-defaults)

;; enable flyspell in prog mode. text mode is handled
(add-hook 'prog-mode-hook 'flyspell-prog-mode)



#+end_src

** yank auto-indent
#+begin_src emacs-lisp
;; automatically indenting yanked text if in programming-modes
(defvar yank-indent-modes
  '(LaTeX-mode TeX-mode)
  "Modes in which to indent regions that are yanked (or yank-popped).
Only modes that don't derive from `prog-mode' should be listed here.")

(defvar yank-indent-blacklisted-modes
  '(python-mode slim-mode haml-mode)
  "Modes for which auto-indenting is suppressed.")

(defvar yank-advised-indent-threshold 2000
  "Threshold (# chars) over which indentation does not automatically occur.")

(defun yank-advised-indent-function (beg end)
  "Do indentation, as long as the region isn't too large."
  (if (<= (- end beg) yank-advised-indent-threshold)
      (indent-region beg end nil)))

(defadvice yank (after yank-indent activate)
  "If current mode is one of 'yank-indent-modes,
indent yanked text (with prefix arg don't indent)."
  (if (and (not (ad-get-arg 0))
           (not (member major-mode yank-indent-blacklisted-modes))
           (or (derived-mode-p 'prog-mode)
               (member major-mode yank-indent-modes)))
      (let ((transient-mark-mode nil))
        (yank-advised-indent-function (region-beginning) (region-end)))))

(defadvice yank-pop (after yank-pop-indent activate)
  "If current mode is one of 'yank-indent-modes,
indent yanked text (with prefix arg don't indent)."
  (if (and (not (ad-get-arg 0))
           (not (member major-mode yank-indent-blacklisted-modes))
           (or (derived-mode-p 'prog-mode)
               (member major-mode yank-indent-modes)))
      (let ((transient-mark-mode nil))
        (yank-advised-indent-function (region-beginning) (region-end)))))

#+end_src


* shell mode
  #+begin_src emacs-lisp
;; avoid stupid git crap like "warning, terminal not fully functional"
(setenv "PAGER" "cat")
;; don't store successive duplicates in comint command history
(setq comint-input-ignoredups t)

(defun add-mode-line-dirtrack ()
  (add-to-list 'mode-line-buffer-identification
               '(:propertize (" " default-directory " ") face dired-directory)))
(add-hook 'shell-mode-hook 'add-mode-line-dirtrack)


;; don't fully understand it, but it works.
;; http://www.emacswiki.org/emacs/ShellDirtrackByProcfs
(defun track-shell-directory/procfs ()
  (shell-dirtrack-mode 0)
  (add-hook 'comint-preoutput-filter-functions
            (lambda (str)
              (prog1 str
                (when (string-match comint-prompt-regexp str)
                  (cd (file-symlink-p
                       (format "/proc/%s/cwd" (process-id
                                               (get-buffer-process
                                                (current-buffer)))))))))
            nil t))
(setq comint-buffer-maximum-size 100000)
(add-to-list 'comint-output-filter-functions 'comint-truncate-buffer)
(defun new-shell ()
  (interactive)
  (shell (generate-new-buffer-name "*shell*")))
;;
(defun shell-wrap (prefix)
"wrap the shell function, automatically generate a new name for a prefix arg"
  (interactive "P")
  (if prefix
      (new-shell)
    (shell)))

(add-hook 'shell-mode-hook 'track-shell-directory/procfs)
#+end_src
* smartparens
the melpa git version had a catastrophic bug I reported.
downgraded to marmalade version and everything is working fine.
#+begin_src emacs-lisp
(require 'smartparens-config)
(show-smartparens-global-mode t)


(defun gp/sp/pair-on-newline-and-indent (id action context)
  "Open a new brace or bracket expression, with relevant newlines and indent. "
  (save-excursion
    (newline)
    (indent-according-to-mode))
  (indent-according-to-mode))

;; when opening a pair, and then inserting a newline, push the closing pair to another newline
(sp-pair "{" nil :post-handlers
         '(:add ((lambda (id action context)
                   (gp/sp/pair-on-newline-and-indent id action context)) (kbd "<return>"))))
(sp-pair "[" nil :post-handlers
         '(:add ((lambda (id action context)
                   (gp/sp/pair-on-newline-and-indent id action context)) (kbd "<return>"))))


;; in my version, this is not a pairing.
;; not sure if it is in a future version since I reverted to marmalade
;; Don't need c-comments in strings -- they frustrate filename globs
;; (sp-pair "/*" nil :unless '(sp-in-string-p))

;; Don't need quotes to pair next to words
(sp-pair "\"" nil :unless '(sp-point-before-word-p sp-point-after-word-p))
(sp-pair "'" nil :unless '(sp-point-before-word-p sp-point-after-word-p))


;; todo, testout these mode specific settings from graphene.
;; Ruby-specific pairs and handlers
(require 'smartparens-ruby)

;; Markdown
(sp-local-pair '(markdown-mode gfm-mode) "*" "*"
               :unless '(sp-in-string-p)
               :actions '(insert wrap))

;; Except in HTML
(sp-local-pair 'html-mode "\"" nil :unless '(:rem sp-point-after-word-p))


  #+end_src
* smex
  todo; check out smex-show-unbound-commands shows frequently used commands that have no key bindings.
  #+begin_src emacs-lisp
; these must be before smex-initialize
    (setq
     smex-save-file "~/.emacs.d/.smex-items")

    (smex-initialize)
  #+end_src
* speedbar
(sr-speedbar-close)
(sr-speedbar-open)

** todo, disabled cuz of broken package
      #+begin_src emacs-lisp :tangle no
(require 'sr-speedbar)
  (setq speedbar-hide-button-brackets-flag t ;; didn't notice a diff
      speedbar-file-unshown-regexp "flycheck-.*"
      sr-speedbar-width 40
      sr-speedbar-width-x 40
      sr-speedbar-auto-refresh nil
      sr-speedbar-skip-other-window-p t
      sr-speedbar-right-side nil
speedbar-hide-button-brackets-flag nil)
      #+end_src
* spell correction
#+begin_src emacs-lisp
  (setq
   ispell-program-name "hunspell"
   ispell-silently-savep t) ; don't prompt to save personal dictionary

  (require 'rw-hunspell)
#+end_src
rw-hunspell sets up hunspell dictionary automagically.


Rant: Hunspell SHOULD be standard. its used by firefox and openoffice and
osx. In contrast, the first few words I added to aspell dictionary were
"emacs" "customizable" and "timestamp". Hunspell already has those,
thank god.

ispell-personal-dictionary does not document where the hunspell
dictionary goes by default, but it is ~/.hunspell_en_US for me


* tex
#+begin_src emacs-lisp
(setq-default TeX-PDF-mode t) ; use pdf

; more sensible defaults based on info manual quickstart
 (setq TeX-auto-save t)
     (setq TeX-parse-self t)


#+end_src
* undo tree
#+begin_src emacs-lisp

  ;; undo-tree checks for minor modes which override
  ;; its minor mode keymap, and sets global keybinds if
  ;; that happens. this will prevent that, but I have no
  ;; reason to do that, so it is commented.
  ;; (defun undo-tree-overridden-undo-bindings-p () nil)

;; todo, send patch undo-tree-visualize should scroll with the scroll key, instead of just pgup pgdn (aka next/prior)
  (global-undo-tree-mode)
  ;; disabled due to bug, something like unknown entry in undo tree canary
  ;; (setq undo-tree-auto-save-history t)
  (setq undo-outer-limit 100000000 ; per undo command
   undo-limit 500000000 ; undo history limit
   undo-strong-limit 600000000) ; undo history limit plus some extra


#+end_src

* visible mark mode

these colors were better for dark theme
#+begin_src emacs-lisp :tangle no



(defface visible-mark-face1
    '((((type tty) (class mono)))
      (t (:background "LimeGreen"))) "")
  (defface visible-mark-face2
    '((((type tty) (class mono)))
      (t (:background "red4"))) "")
  (defface visible-mark-forward-face1
    '((((type tty) (class mono)))
      (t (:background "dark magenta"))) "")
  (defface visible-mark-active
    '((((type tty) (class mono)))
      (t (:background "gold"))) "")
  (defface mouse-cursor-face
    '((((type tty) (class mono)))
      (t (:background "DeepPink1"))) "")

#+end_src


#+begin_src emacs-lisp


    ;; since it is not easy to change the mark overlay priority, I change this one.
    (setq show-paren-priority 999)


  (defface visible-mark-active
    '((((type tty) (class mono)))
      (t (:background "magenta"))) "")



  (defface mouse-cursor-face
    '((((type tty) (class mono)))
      (t (:background "DeepPink1"))) "")


  (require 'visible-mark)

(setq visible-mark-faces '(visible-mark-face1 visible-mark-face2))
  (setq visible-mark-forward-faces '(visible-mark-forward-face1))


  ; highlight the last 2 marks
  (setq visible-mark-max 2)
  ; highlight 1 forward mark
  (setq visible-mark-forward-max 1)
  ; globally activate visible-mark-mode
  (global-visible-mark-mode +1)


;; todo, it doesn't seem to be exposed in elisp, but it would be nice
;; if I could define overlay faces to use inverse foreground color


#+end_src

#+RESULTS:
: t


* zrc
#+begin_src emacs-lisp
(require 'znc)
(setq erc-fill-prefix "")
(defun chirp()
  (interactive)
  (setq vol 50)
  (when (string= (system-name) "tp") (setq vol 40))
  (start-process-shell-command "ignoreme" nil (format "mpv --no-terminal --vo=null --volume=%d /a/bin/data/bird.mp3" vol)))
;; from https://www.emacswiki.org/emacs/ErcSound

(defun erc-my-privmsg-sound (proc parsed)
  (let* ((tgt (car (erc-response.command-args parsed)))
         (privp (erc-current-nick-p tgt)))
    (and
     privp (chirp)
                                        ;; We must return nil. See help for `erc-server-PRIVMSG-functions'
     nil)))

(add-hook 'erc-server-PRIVMSG-functions
          'erc-my-privmsg-sound)

(defun erc-sound-if-not-server (match-type nickuserhost msg)
  (unless (string-match "Server:[0-9]+" nickuserhost)
    (chirp)))
(add-hook 'erc-text-matched-hook 'erc-sound-if-not-server)

(erc-track-mode 1)
 (setq
 ;; consider invisible frames to be unseen. seems like an obvious default
 erc-track-visibility 'visible
 ;; switch to buffer where i've been mentioned, etc instead of oldest
  erc-track-switch-direction 'importance)

#+end_src


* key binds. keep at end of file
this should come at the end because it depends on key maps being
created in earlier sections.

** emacs keys notes
commands not needed in ido mode and their replacement in ido mode
spell check fix -> use current pattern and start new one
narrow -> create subdirectory
org-cycle -> M-s search recently used directory
vert split Window -> create file instead of select match
delete-other-windows -> open dired buffer
delete current window -> delete buffer/file
find file -> search within all subdirectories

forward/back error

buffer select -> toggle find file / buffer
up/down -> next/previous history
forward/back -> ido-forward/back


right keyboard attributes:  movement, involve typing words
left keyboard attributes:  non-typing  universal  non-movement




todo
fix global unpop mark ring
setup helm
learn cedet and projectile and helm
setup key for pop-global-mark
try out C-M-\ indent region
set quoted insert to some obscure keybind
make currently overrided M-u uppercase word into something obscure
remember mode
bind shell-command to something better
investigate tags
investigate keys in isearch mode and find file mode
try out occur. M-s o
investigate programming modes. M-g n/b next/previous error. gdb?
investigate org mode keys
learn version control
learn mail
check out imenu
bind capitalize-word to something obscure
sentance/paragraph movement/marking should be swapped with sexp/paren movement based on mode
bind fill-paragraph to something obscure
setup linewise paste
install magit (git control)
magpie expansion provides a completion key for acronym expansion based on buffer text
learn ediff
universal google
figure out auto-indent
learn eshell and prelude settings for it
combine register prefix and c-x prefix
note: remember to think of mouse & foot pedals
commands to change: select other window: C-x o.
** prefix keybind changes
#+begin_src emacs-lisp


  ; prefix key binds.
  ; good info http://www.masteringemacs.org/articles/2011/02/08/mastering-key-bindings-emacs/
  ; rebinding the prefix keys are tricky. apparently, some modes ignore any redefinition of a prefix key and use it explicitly,
  ; so you have to dig into their key maps and redo things.
  ; There are 2 simpler alternatives which have their own downsides.
  ; One is cua mode, which I do not like because it smashes 2 keybinds onto 1 and limits what you can do.
  ; The other is keyboard-translate, which translates the key presses before anything else.
  ; The downside is that it translates them when you aren't using them as a prefix.
  ; Since the swaps I'm using are all very accessible, the only downside is some mental jugling when reading docs etc about these keybinds.

  ; I've seen this as an another suggestion, it was a total fail. The prefix command took over both keys.
  ; (define-key key-translation-map [f12] "\C-c")
  ; (define-key key-translation-map "\C-c" [left])


  ;idea to remove the hook later since it is only needed at startup.
  ; did not work however, and there is not a real need to fix it, so I did not investigate
  ;(defun removeSwapHook ()
  ;  (remove-hook 'buffer-list-update-hook 'myKeySwap)
  ;  (remove-hook 'change-major-mode-hook 'removeSwapHook))
  ;(add-hook 'change-major-mode-hook 'removeSwapHook)


  ; went through almost all the relevant standard hooks,
  ; this overcomes a known bug that (keyboard-translate) does not get applied when running emacs daemon
  (add-hook 'buffer-list-update-hook (lambda () (interactive)
                                       (keyboard-translate ?\C-x ?\C-s)
                                       (keyboard-translate ?\C-s ?\C-x)
                                       (keyboard-translate ?\C-c ?\C-d)
                                       (keyboard-translate ?\C-d ?\C-c)))



  ; these all don't work
  ; don't know why this doesn't error but reversing the keys does
  ;(keyboard-translate ?\t ?\M-\t)
  ;(keyboard-translate [M-tab] [tab])
  ; from what i can tell, it wants to use a keyboard-translate-table,
  ; which is a char table, which is a vector indexed by chars,
  ; and mod+tab is not a char (it has too many bits), it is an integer
  ; it actually says it can hold vectors or strings, but that it is obsolete to do so
  ;(characterp ?\M-a)
  ;(characterp ?\C-a)



#+end_src

** named commands
*** gdb
gdb-many-windows
*** tramp sudo
/ssh:host|sudo:host:
when in the same session, you can then do:
/sudo:root@host:

*** org insert table row
[org-shiftmetadown/up]
*** toggle line continuation / truncation / wrap
    toggle-truncate-lines
*** auto-save on/off
    my-as-on/my-as-off
*** toggle menu bar
menu-bar-mode
*** show abbreviations
list-abbrevs

*** rename-file-and-buffer
*** ediff-buffers
*** refill-mode
automatically balance a paragraph with newlines
*** executable-make-buffer-file-executable-if-script-p
make a script executable
*** (setq lazy-highlight-cleanup nil)
keep search highlight on after search is done
*** auto-revert-tail-mode
tail a file
*** trash-file-and-buffer
#+begin_src emacs-lisp
(defun trash-file-and-buffer ()
  "Removes file connected to current buffer and kills buffer."
  (interactive)
  (let ((filename (buffer-file-name))
        (buffer (current-buffer))
        (name (buffer-name)))
    (if (not (and filename (file-exists-p filename)))
        (error "Buffer '%s' is not visiting a file!" name)
      (delete-file filename)
      (kill-buffer buffer)
      (message "File '%s' successfully removed" filename))))

#+end_src
*** what-line
*** linum-mode
line numbers

*** sgml-pretty-print
format xml in nxml-mode
*** visual-line-mode
toggle word wrap.
** compound commands
*** C-xc
exit0
*** C-x s
save file
*** C-x e
eval last sexp
*** C-x u
[undo-tree-visualize]
*** C-j u/U
[undo-tree save/restore state via register]
*** C-c -
[org insert table horizontal line or create list]
*** C-x tab
indent/dedent region

[shift-left and shift-right are default for indenting by tab stop,
and they are only defined as lambdas so I copy them here
to use with up and down.
#+begin_src emacs-lisp
;; condition cuz emacs24 release doesn't have this yet
(when (boundp 'indent-rigidly-map)
    (define-key indent-rigidly-map (kbd "<C-left>")
      (lambda (beg end) (interactive "r")
        (let* ((current (indent-rigidly--current-indentation beg end))
               (next (indent--next-tab-stop current)))
          (indent-rigidly beg end (- next current)))))

    (define-key indent-rigidly-map (kbd "<C-right>")
      (lambda (beg end) (interactive "r")
        (let* ((current (indent-rigidly--current-indentation beg end))
               (next (indent--next-tab-stop current 'prev)))
          (indent-rigidly beg end (- next current))))))
#+end_src
*** C-x *
[calc-dispatch]
*** C-x =
[point information]
*** C-x d
[dired]
*** C-xb
[ibuffer]
#+begin_src emacs-lisp
  (global-set-key (kbd "C-x C-b") 'ibuffer)
#+end_src

*** C-x r c
rectangular clear, replace area with whitespace
** gnus
searching overview.
3 types:
ingroup searching
nnir searching with notmuch, specific group (not sure if it can do multiple)
search all groups with mairix
*** a]
compose new message
*** C-c C-c]
send message
*** s]
save newsrc file, alterations to groups.
*** g]
gnus refresh / get new
*** m]
gnus new message
*** F]
gnus quoted reply all
*** e]
gnus draft edit message
*** delete]
gnus delete draft
#+begin_src emacs-lisp
(add-hook 'gnus-startup-hook
          (lambda ()
            (define-key gnus-summary-mode-map (kbd "<delete>") 'gnus-summary-delete-article)))
#+end_src

*** b]
mairix search
#+begin_src emacs-lisp
(add-hook 'gnus-startup-hook
          (lambda ()
            (define-key gnus-group-mode-map "b" 'nnmairix-search)
            (define-key gnus-summary-mode-map "b" 'nnmairix-search)))
#+end_src
*** B m]
move message, or messages in region
*** #]
mark article, move with B m
*** B delete]
gnus delete draft
*** / plus x a / b]
search current group (or see info manual for more groups),
using the gnus native search (its slow, do a notmuch or mairix search instead)
x= extra (ie. to)
todo; send in patch to make author search to in sent folder
a = author
/ = subject
b = body
see C-h m for a full list
***  G G ]
do a nnir notmuch search, for the group on the current line
***  A T ]
jump to thread from nnir group

*** marks]
! = saved for later
E = expired
M-& apply process mark to a non-process mark command
*** S D e]
edit as new
*** T k / C-M-k
maybe rebind this to a shorter keybind, like del
gnus-summary-kill-thread
** message mode
*** C-ck]
discard message
** notmuch
*** space]
notmuch advance to next message/thread

** readline / bash / .inputrc
*** C-m
[--------]
#+begin_src emacs-lisp
(add-hook 'comint-mode-hook
          (lambda ()
            (define-key comint-mode-map "\C-m" nil)))
#+end_src
terminal crap, duplicate of enter

** isearch
*** C-w
paste word/char under cursor into isearch
*** M-n/p
next/previous isearch history
*** C-o
isearch-occur
    Activate occur easily inside isearch
    from starter-kit
#+begin_src emacs-lisp
(define-key isearch-mode-map (kbd "C-o")
  (lambda () (interactive)
    (let ((case-fold-search isearch-case-fold-search))
      (occur (if isearch-regexp
                 isearch-string
               (regexp-quote isearch-string))))))
#+end_src
*** m-r
#+begin_src emacs-lisp
(defun my-isearch-toggle-regexp ()
  (interactive)
  (isearch-toggle-regexp)
  (cond (isearch-regexp
         (global-set-key (kbd "C-r") 'isearch-backward-regexp)
         (define-key global-map (kbd "<f12>") 'isearch-forward-regexp)
         (define-key global-map (kbd "<kp-add>") 'isearch-forward-regexp))
        (t
         (global-set-key (kbd "C-r") 'isearch-backward)
         (define-key global-map (kbd "<f12>") 'isearch-forward)
         (define-key global-map (kbd "<kp-add>") 'isearch-forward))))
(define-key isearch-mode-map (kbd "M-r") 'my-isearch-toggle-regexp)
  #+end_src

** icomplete
*** C-. C-,
icomplete-forward/backward-completions

** info
*** [, ]
forward / previous node, descend/ascend tree as needed
*** x
Info-follow-nearest-node
#+begin_src emacs-lisp
(define-key Info-mode-map "x" 'Info-follow-nearest-node)
#+end_src
m, f, n, p or ^ command, depending on where you click.
** auto-complete
*** S-return
select next completion candidate
ac-expand
** agenda
*** t]
agenda cycle todo state
** org
*** C-c / t]
make just todo items visible
*** S-<tab>
org-shifttab global visibility cycle / move table cell
*** C-cs]
schedule todo item
*** C-cx p]
org set property
*** C-c -]
org insert horizontal line
*** C-cq]
    org tag
** calc
i'd like to drill these sometime when I have space in my head, or I
plan to use calc.
*** space
[enter input to the stack, or duplicate top stack item]
*** C-M-i
[cycle 3 elements on stack]
*** tab
[cycle 2 elements on stack]
*** n
[negate]
*** _
[begin negative number]
*** /
[reciprocal]
*** x
[calc named command]
*** M-delete
[delete 2nd from top of stack]
*** C-u [-]0-9
[0=whole stack, 1-9=that many, -1-9=that element]
*** delete
[remove from the top of the stack]
*** '
[algebraic mode. infix expressions are calculated when input to the stack]
*** m a
[auto algebraic mode]
*** $,$$,$$$
[top x of stack reference]
*** s s/t/r/u
[store to variable: store, top, retrieve, unstore. the quick variables 0-9 don't need s prefix]
*** U/D
[undo/redo]
*** t p/n/]/y
[trail prev/next/end/yankh]
*** `
[calc edit mode, to edit the top of stack]

** single/special keys
*** tab key
isearch
#+begin_src emacs-lisp
(define-key isearch-mode-map (kbd "<tab>") 'isearch-query-replace)
#+end_src
*** tab
isearch-forward
#+begin_src emacs-lisp
;; explained in http://stackoverflow.com/questions/7411920/how-to-bind-search-and-search-repeat-to-c-f-in-emacs
(global-set-key (kbd "<kp-add>") 'isearch-forward)
(global-set-key (kbd "<f12>") 'isearch-forward)
(define-key isearch-mode-map "\t" nil)
(define-key isearch-mode-map (kbd "<kp-add>") 'isearch-repeat-forward)
(define-key isearch-mode-map (kbd "<f12>") 'isearch-repeat-forward)
;; get rid of the standard completion binding, always use auto-complete
;; this didn't work very well
;;(global-set-key (kbd "TAB") 'auto-complete)
(define-key global-map [remap completion-at-point] 'auto-complete)

#+end_src

*** end
    move-end-of-line
#+begin_src emacs-lisp
;; taken from emacs wiki, along with home function
;; http://www.emacswiki.org/emacs/BackToIndentationOrBeginning
(defun point-in-comment ()
  "Determine if the point is inside a comment"
  (interactive)
  (let ((syn (syntax-ppss)))
    (and (nth 8 syn)
         (not (nth 3 syn)))))
(defun end-of-code-or-line (arg)
  "Move to end of line, or before start of comments depending on situation.
 Toggle back and forth positions if we are already at one.
 Comments are recognized in any mode that sets syntax-ppss
 properly."
  (interactive "P")
  (when (catch 'bol
          (let ((start (point))
                (bol (save-excursion
                       (beginning-of-line)
                       (point)))
                (eol (progn (move-end-of-line arg) (point))))
            (while (point-in-comment)
              (backward-char)
              (when (= (point) bol)
                (throw 'bol t)))
            (throw 'bol (and (not (= eol start)) (>= start (point))))))
    (move-end-of-line arg)))

(global-set-key (kbd "<end>") 'end-of-code-or-line)(add-hook 'org-mode-hook (lambda () (define-key org-mode-map (kbd "<end>") 'org-end-of-line)))
#+end_src

*** home
back-to-indentation
#+begin_src emacs-lisp
  (defun back-to-indentation-or-beginning ()
    (interactive)
    (if (= (point) (progn (back-to-indentation) (point)))
        (if (derived-mode-p 'org-mode)
            (org-beginning-of-line)
          (beginning-of-line))))
    (global-set-key (kbd "<home>") 'back-to-indentation-or-beginning)

#+end_src

*** s-tab
indent-buffer
#+begin_src emacs-lisp
(global-set-key (kbd "<S-iso-lefttab>") 'indent-buffer)
#+end_src
*** s-delete
send-shell
#+begin_src emacs-lisp

(global-set-key (kbd "<S-delete>") 'send-shell)

;; optional variables used by send-shell
(setq shell-send-yank-key nil)

(defun repeat-shell ()
  (interactive)
  "Repeat the last command in shell-mode, displaying the window if needed."
  (let ((shell-buffer (get-buffer "*shell*")))
    (if shell-buffer
        (buffer-window-show shell-buffer)
      (let ((original-buffer (current-buffer)))
        (funcall 'shell)
        (setq shell-buffer (current-buffer))
        (switch-to-buffer original-buffer)))
    (with-current-buffer shell-buffer
      (goto-char (point-max))
      (call-interactively 'comint-previous-input)
      ;; the t flag makes the buffer advance
      (comint-send-input nil t))))

(setq compilation-filenames '("Makefile" "makefile"))

(defun get-nearest-compilation-file ()
  "Search for the compilation file traversing up the directory tree."
  (interactive)
  (let ((dir default-directory)
        (parent-dir (file-name-directory (directory-file-name default-directory)))
        (nearest-compilation-file 'nil))
    (while (and (not (string= dir parent-dir))
                (not nearest-compilation-file))
      (dolist (filename compilation-filenames)
        (setq file-path (concat dir filename))
        (when (file-readable-p file-path)
          (setq nearest-compilation-file file-path)))
      (setq dir parent-dir
            parent-dir (file-name-directory (directory-file-name parent-dir))))
    nearest-compilation-file))
(defun run ()
  (interactive)
  "call run-fun if it is set, else run make if there is a makefile,
else save and repeat last shell command.
run-fun is meant to store file local variables, which show how to
do the main thing we want on this file, generally compile and
run.

example of setting it in a file:
;; Local Variables:
;; run-fun: merge-test
;; End: "
  (basic-save-buffer)
  (if (and (boundp 'run-fun) run-fun)
      (funcall run-fun)
    (let ((makefile (get-nearest-compilation-file)))
      (if (and makefile (stringp mode-name) (string= mode-name "C/l"))
          (compile (format
                    "make -f %s" (get-nearest-compilation-file)))
        (repeat-shell)))))


(defun send-shell ()
  (interactive)
  (send-shell-buffer "*shell*" 'shell (kbd "C-v")))

(defun send-python ()
  (interactive)
  (send-shell-buffer "*Python*" 'py-shell (kbd "C-v")))


(defun send-shell-buffer (buffer-name &optional init shell-send-yank-key)
  "Send current line or region to shell-mode buffer.
When in shell-mode, copy the current line to the
most recently visited visible window.

SHELL-SEND-YANK-KEY: key to use instead
of yank to paste into recent window. This allows compatibility with
modes like org-mode which have their own yank function."
  (if (string= (buffer-name) buffer-name)
;; this section is copied out of comint-send-input
      (progn
        (let ((proc (get-buffer-process (current-buffer))))
          (if (not proc) (user-error "Current buffer has no process")
            (widen)

            (let* ((pmark (process-mark proc))
                   (intxt (if (>= (point) (marker-position pmark))
                              (progn (if comint-eol-on-send (end-of-line))
                                     (buffer-substring pmark (point)))
                            (let ((copy (funcall comint-get-old-input)))
                              (goto-char pmark)
                              (insert copy)
                              copy))))

              (if (= (length intxt) 0)
                  (kill-new (comint-previous-matching-input-string "." 1))
                (kill-new intxt)))))
        (kill-append "\n" nil)
        (select-window (previous-window nil nil 'visible))
        (if (and (boundp 'shell-send-yank-key) shell-send-yank-key)
            (call-interactively (global-key-binding shell-send-yank-key))
          (yank))
        (select-window (next-window nil nil 'visible)))
    (let (start end)
      (if mark-active
          (setq start (mark)
                end (point))
        (setq start (save-excursion (beginning-of-line) (point))
              end (save-excursion (end-of-line) (point)))
        (let (line-move-visual)
          (call-interactively 'next-line)))
      (send-comint-input buffer-name start end init))))

;; supporting functions
(defun send-comint-input (buffer-name start end &optional init)
  "Input the region to BUFFER-NAME, assuming it is a comint-derived buffer.
                             Show BUFFER-NAME if it is not show.
                             Call INIT if BUFFER-NAME does not exist."
  (let ((input (filter-buffer-substring start end)))
    (send-comint-string buffer-name input init)))

(defun send-comint-string (buffer-name string &optional init)
  "Input the string to BUFFER-NAME, assuming it is a comint-derived buffer.
                             Show BUFFER-NAME if it is not show.
                             Call INIT if BUFFER-NAME does not exist."
  (let ((buffer (get-buffer buffer-name)))
    (unless buffer
      (message "nobuffer")
      ;; save-excursion etc. don't work for (shell), so I do this instead
      (if init (let ((original-buffer (current-buffer)))
                 (funcall init (and (boundp 'send-shell-buffer-name) send-shell-buffer-name))
                 (switch-to-buffer original-buffer)
                 (setq buffer (get-buffer buffer-name)))
        (error "No existing buffer found and no init function argument. ")))
    (buffer-window-show buffer)
    (with-current-buffer buffer
      (let ((proc (get-buffer-process buffer)))
        (goto-char (process-mark proc))
        (insert string)
        (comint-send-input nil t)))))

(defun buffer-window-show (&optional buffer action)
  "Like temp-buffer-window-show, but removed stuff
        relevant to it being temp or help."
  (let (window frame)
    (with-current-buffer buffer
      (when (let ((window-combination-limit
                   ;; When `window-combination-limit' equals
                   ;; `temp-buffer' or `temp-buffer-resize' and
                   ;; `temp-buffer-resize-mode' is enabled in this
                   ;; buffer bind it to t so resizing steals space
                   ;; preferably from the window that was split.
                   (if (or (eq window-combination-limit 'temp-buffer)
                           (and (eq window-combination-limit
                                    'temp-buffer-resize)
                                temp-buffer-resize-mode))
                       t
                     window-combination-limit)))
              ;; debug
              ;;(message "window-combination-limit")
              ;;(print window-combination-limit)
              (setq window (display-buffer buffer action)))
        (setq frame (window-frame window))
        (unless (eq frame (selected-frame))
          (raise-frame frame))
        (setq minibuffer-scroll-window window)
        (set-window-hscroll window 0)
        ;; Return the window.
        window))))


;; when poping help, etc, allow reusing a window in a different frame if it is visible
;; figured this out after spending quite a while reading doc string for display-buffer
;; which is the main function which uses this.
;; it will use other vars or its arg to override this,
;; but those things are often nil.
;; aha moments in reading it: ACTION = (FUNCTION-or-FUNCTIONLIST ALIST)
;; FRAME adds an association to ACTION's alist, but it's not used if ACTION arg is nil.
(setq display-buffer-fallback-action `(,(car display-buffer-fallback-action) . '(reusable-frames . visible)))
;; stop splitting windows verticallly when I open a buffer or shell
(setq split-height-threshold nil)
#+end_src

*** s-left arrow
shell
#+begin_src emacs-lisp
(global-set-key (kbd "<S-kp-equal>") 'shell-wrap)
(global-set-key (kbd "<S-left>") 'shell-wrap)
#+end_src
*** s-right arrow
previous-buffer
#+begin_src emacs-lisp
(global-set-key (kbd "<S-kp-divide>") 'previous-buffer)
#+end_src
*** esc
*** return
new line

#+begin_src emacs-lisp
;; todo, this doesn't set the keybind for the help minibuffer


(global-set-key (kbd "\r") 'indent-new-comment-line)

;; don't use enter for autocomplete, we use tab or something
(define-key ac-completing-map (kbd "<return>") nil)
(define-key ac-completing-map "\r" nil)

(add-hook 'org-mode-hook
          (lambda ()
          ;; copied from org-mode, replace org-enter with org-enter-indent
(org-defkey org-mode-map "\C-m"     'org-return-indent)))


(add-hook 'comint-mode-hook
          (lambda ()
            (define-key comint-mode-map "\r" nil)
            (define-key comint-mode-map (kbd "<return>") 'comint-send-input)))

(add-hook 'comint-mode-hook
          (lambda ()
            (define-key comint-mode-map "\C-m" nil)
            (define-key comint-mode-map "\C-d" nil)))

#+end_src

*** s-return
auto-correct-prev-word
    #+begin_src emacs-lisp
    (global-set-key (kbd "<S-return>") 'flyspell-auto-correct-previous-word)
#+end_src

*** down arrow
mark
#+begin_src emacs-lisp
  (global-set-key (kbd "<kp-enter>") 'set-mark-command)
#+end_src
*** s-down arrow
extended command
#+begin_src emacs-lisp
  (global-set-key (kbd "<S-kp-enter>") 'smex)
#+end_src
*** s-up arrow

** mouse
*** mouse-2 mode line
mouse-delete-other-windows
*** C-mouse-2 mode line
    mouse-split-window-horizontally
*** M-mouse-2 mode line
*** S-mouse-2 mode line
*** C-M-mouse-2 mode line
*** C-S-mouse2 mode line
*** mouse-3 mode line
    mouse-delete-window
*** C-mouse-3 mode line
*** M-mouse-3 mode line
*** S-mouse-3 mode line
*** C-M-mouse-3 mode line
*** C-S-mouse-3 mode line
*** mouse-1
    set cursor/mark
*** C-mouse-1
buffer list context menu
*** M-mouse-1
*** S-mouse-1
*** C-M-mouse-1
*** C-S-mouse-1
*** mouse-2
    paste
*** C-mouse-2
*** M-mouse-2
*** S-mouse-2
*** C-M-mouse-2
*** C-S-mouse-2
*** mouse-3
set-mark
#+begin_src emacs-lisp
  (define-key global-map [down-mouse-3] 'mouse3-func)
  (global-set-key [mouse-3]       'mouse3-set-mark)
  (global-set-key [drag-mouse-3]  'mouse3-set-mark)
#+end_src
*** C-mouse-3
    global menu
*** M-mouse-3
*** S-mouse-3
*** C-M-mouse-3
*** C-S-mouse-3
*** mouse-9
move-mouse-to-point
#+begin_src emacs-lisp
  (global-set-key (kbd "<mouse-6>") 'move-mouse-to-point)
#+end_src
*** C-mouse-9
*** M-mouse-9
*** S-mouse-9
*** C-M-mouse-9
*** C-S-mouse-9
*** mouse-8
*** C-mouse-8
*** M-mouse-8
*** S-mouse-8
*** C-M-mouse-8
*** C-S-mouse-8
*** 1/kp-end
*** C-1/kp-end
*** M-1/kp-end
*** S-1/kp-end
*** C-M-1/kp-end
*** C-S-1/kp-end
*** 2/kp-down
*** C-2/kp-down
*** M-2/kp-down
smex
#+begin_src emacs-lisp
;; for when we have a standard keyboard which is not remapped
(global-set-key (kbd "M-2") 'smex)

#+end_src

*** S-2/kp-down
*** C-M-2/kp-down
*** C-S-2/kp-down
*** 3/kp-next
*** C-3/kp-next
*** M-3/kp-next
*** S-3/kp-next
*** C-M-3/kp-next
*** C-S-3/kp-next
*** 4/kp-left
    indent-region
#+begin_src emacs-lisp
  (global-set-key (kbd "<kp-left>") 'indent-region)
#+end_src
*** C-4/kp-left
*** M-4/kp-left
*** S-4/kp-left
*** C-M-4/kp-left
*** C-S-4/kp-left
*** 5/kp-begin
    mark-defun
#+begin_src emacs-lisp
  (global-set-key (kbd "<kp-begin>") 'mark-defun)
#+end_src
*** C-5/kp-begin
*** M-5/kp-begin
*** S-5/kp-begin
*** C-M-5/kp-begin
*** C-S-5/kp-begin
*** 6/kp-right
    ibuffer
#+begin_src emacs-lisp
  (global-set-key (kbd "<kp-right>") 'ibuffer)
#+end_src
*** C-6/kp-right
*** M-6/kp-right
*** S-6/kp-right
*** C-M-6/kp-right
*** C-S-6/kp-right
*** 7/kp-home
*** C-7/kp-home
*** M-7/kp-home
*** S-7/kp-home
*** C-M-7/kp-home
*** C-S-7/kp-home
*** 8/kp-up
*** C-8/kp-up
*** M-8/kp-up
*** S-8/kp-up
*** C-M-8/kp-up
*** C-S-8/kp-up
*** 9/kp-prior
    delete-horizontal-space
#+begin_src emacs-lisp
  (global-set-key (kbd "<kp-prior>") 'delete-horizontal-space)
#+end_src
*** C-9/kp-prior
*** M-9/kp-prior
*** S-9/kp-prior
*** C-M-9/kp-prior
*** C-S-9/kp-prior
*** 10/kp-insert
*** C-10/kp-insert
*** M-10/kp-insert
*** S-10/kp-insert
*** C-M-10/kp-insert
*** C-S-10/kp-insert
*** 11/kp-subtract
*** C-11/kp-subtract
*** M-11/kp-subtract
*** S-11/kp-subtract
*** C-M-11/kp-subtract
*** C-S-11/kp-subtract
*** 12/kp-add
*** C-12/kp-add
*** M-12/kp-add
*** S-12/kp-add
*** C-M-12/kp-add
*** C-S-12/kp-add
*** scroll
    up/dn / scroll
on standard mouse, this scrolls,
because we have the accuracy to pick things up and
down easier, and because it is familiar.
*** C-scroll
cursor up/down fast
#+begin_src emacs-lisp
;; compiling warns that next-line should be called interactively,
;; but we would have to do something dumb, like give it a
;; vector of keys in order to supply the 8 argument
(defun down-fast ()
  (interactive)
  (next-line 8))
(defun up-fast ()
  (interactive)
  (next-line -8))

(global-set-key (kbd "<C-up>") 'up-fast)
(global-set-key (kbd "<C-down>") 'down-fast)

(add-hook 'comint-mode-hook
          (lambda ()
            (define-key comint-mode-map (kbd "<C-mouse-4>") 'comint-previous-prompt)
            (define-key comint-mode-map (kbd "<C-mouse-5>") 'comint-next-prompt)))
#+end_src

*** M-scroll
forward/back s-exp
#+begin_src emacs-lisp
  (global-set-key (kbd "<M-mouse-4>") 'backward-sexp)
  (global-set-key (kbd "<M-mouse-5>") 'forward-sexp)
#+end_src
*** S-scroll
expand/contract region
#+begin_src emacs-lisp
(global-set-key (kbd "<S-mouse-13>") 'my-contract-region)
(global-set-key (kbd "<S-mouse-14>") 'er/expand-region)
(global-set-key (kbd "<S-mouse-4>") 'my-contract-region)
(global-set-key (kbd "<S-mouse-5>") 'er/expand-region)
(global-set-key (kbd "<S-up>") 'my-contract-region)
(global-set-key (kbd "<S-down>") 'er/expand-region)

(defun my-contract-region (arg)
  (interactive "p")
  (let ((current-prefix-arg '-))
    (call-interactively 'er/expand-region)))
#+end_src
*** C-M-scroll
scroll
background: I originally tried to make c-scroll be scroll
, but this made
for better compatibility with the standard mouse
#+begin_src emacs-lisp
  (global-set-key (kbd "<C-M-mouse-4>") 'mwheel-scroll)
  (global-set-key (kbd "<C-M-mouse-5>") 'mwheel-scroll)
; (require 'smooth-scroll)
 ;   (smooth-scroll-mode nil)
 ; (global-set-key (kbd "<C-M-mouse-4>") 'scroll-up-1)
  ;(global-set-key (kbd "<C-M-mouse-5>") 'scroll-down-1)
#+end_src
*** C-S-scroll
increase / decrease text size
#+begin_src emacs-lisp
(global-set-key (kbd "<C-S-mouse-4>") 'text-scale-increase)
(global-set-key (kbd "<C-S-mouse-5>") 'text-scale-decrease)
(global-set-key (kbd "<C-S-mouse-13>") 'text-scale-increase)
(global-set-key (kbd "<C-S-mouse-14>") 'text-scale-decrease)
(global-set-key (kbd "<C-S-down>") 'text-scale-increase)
(global-set-key (kbd "<C-S-up>") 'text-scale-decrease)
#+end_src
*** left-scroll
left/right
*** C-left-scroll
back / forward word
#+begin_src emacs-lisp
  (global-set-key (kbd "<C-left>") 'backward-symbol)
  (global-set-key (kbd "<C-right>") 'forward-symbol)
  #+end_src
*** M-left-scroll
---
unreachable
*** S-left-scroll
---
unreachable
*** C-M-left-scroll
---
unreachable
*** C-S-left-scroll
---
unreachable
** left primary

*** C-2
copy-symbol
#+begin_src emacs-lisp
(global-unset-key (kbd "C-2"))
(defun copy-symbol (&optional arg)
  "Copy symbol at point into kill-ring"
  (interactive "P")
  (kill-new (thing-at-point 'symbol)))

(global-set-key (kbd "C-2") 'copy-symbol)
#+end_src
*** M-2
shell-cd-to-file
#+begin_src emacs-lisp

(defun shell-cd-to-file ()
  (interactive)
  (let ((file (buffer-file-name)))
    (if file
        (send-comint-string "*shell*"
                            (concat "c " (file-name-directory file))
                            'shell)
      (message "%s" "shell-cd-to-file: buffer has no file name"))))
(global-set-key (kbd "M-2") 'shell-cd-to-file)
#+end_src
*** C-M-2
---
#+begin_src emacs-lisp
  (global-unset-key (kbd "C-M-2"))
#+end_src
*** C-S-2
*** C-3
dot-mode-execute
#+begin_src emacs-lisp
(global-set-key (kbd "C-3") 'dot-mode-execute)
 #+end_src
*** M-3
*** C-M-3
    recenter-top-bottom
#+begin_src emacs-lisp
(global-set-key (kbd "C-M-3") 'recenter-top-bottom)
#+end_src
*** C-S-3
*** C-q
org-cycle, comint previous arg
#+begin_src emacs-lisp
(global-set-key (kbd "C-q") 'outline-cycle)
(add-hook 'org-mode-hook
          (lambda () (define-key org-mode-map (kbd "C-q") 'org-cycle)))
(define-key widget-keymap (kbd "C-q") 'widget-forward)
(add-hook 'comint-mode-hook
          (lambda () (define-key comint-mode-map (kbd "C-q") 'comint-insert-previous-argument)))
#+end_src
*** M-q
org-archive-to-archive-sibling
#+begin_src emacs-lisp
(global-set-key (kbd "M-q") 'org-archive-to-archive-sibling)
#+end_src
*** C-M-q
quoted-insert
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-q") 'quoted-insert)
#+end_src
*** C-S-q
*** C-w
goto-t.org
#+begin_src emacs-lisp
(global-set-key (kbd "C-w") (lambda () (interactive) (goto-buffer-or-find-file "/a/t.org")))
#+end_src
*** M-w
org-clock-in
#+begin_src emacs-lisp
(global-set-key (kbd "M-w") 'org-clock-in)
#+end_src
*** C-M-w
*** C-S-w
*** C-e
copy-line
#+begin_src emacs-lisp
;; todo, make repeated calls to this append the kills
(defun copy-line (&optional arg)
  "Copy lines (as many as prefix argument) in the kill ring.
        Ease of use features:
        - Move to start of next line.
        - Appends the copy on sequential calls.
        - Use newline as last char even on the last line of the buffer.
        - If region is active, copy its lines."
  (interactive "p")
  (let ((beg (line-beginning-position))
        (end (line-end-position (or arg 1))))
    (when mark-active
      (if (> (point) (mark))
          (setq beg (save-excursion (goto-char (mark)) (line-beginning-position)))
        (setq end (save-excursion (goto-char (mark)) (line-end-position)))))
    (if (eq last-command 'copy-line)
        (kill-append (buffer-substring beg end) (< end beg))
      (kill-ring-save beg end)))
  (kill-append "\n" nil)
  ;; dun need cuz I have yank-better
  ;;(beginning-of-line (or (and arg (1+ arg)) 2))
  (if (and arg (not (= 1 arg))) (message "%d lines copied" arg)))

(global-set-key (kbd "C-e") 'copy-line)
#+end_src
*** M-e
org-clock-in-last
#+begin_src emacs-lisp
(global-set-key (kbd "M-e") 'org-clock-in-last)
  #+end_src
*** C-M-e
*** C-S-e
*** C-r
isearch-backward
#+begin_src emacs-lisp
(global-set-key (kbd "C-r") 'isearch-backward)
(add-hook 'comint-mode-hook
          (lambda ()
            (define-key comint-mode-map (kbd "C-r") 'comint-history-isearch-backward-regexp)))
#+end_src
*** M-r
org-clock-out
#+begin_src emacs-lisp
(global-set-key (kbd "M-r") 'org-clock-out)
#+end_src
*** C-M-r
*** C-S-r
*** C-a
copy buffer
    #+begin_src emacs-lisp
(defun copy-all ()
    "Copy entire buffer to clipboard"
    (interactive)
    (clipboard-kill-ring-save (point-min) (point-max)))
(global-set-key (kbd "C-a") 'copy-all)
    #+end_src
*** M-a
macro record
#+begin_src emacs-lisp
(global-set-key (kbd "M-a") 'kmacro-start-macro-or-insert-counter)
#+end_src
*** C-M-a
macro end / call
#+begin_src emacs-lisp
(global-set-key (kbd "C-M-a") 'kmacro-end-or-call-macro)
(add-hook 'perl-mode-hook (lambda () (define-key perl-mode-map (kbd "C-M-a") nil)))
(add-hook 'LaTeX-mode-hook (lambda () (define-key LaTeX-mode-map (kbd "C-M-a") nil)))
(add-hook 'c++-mode-hook
          (lambda () (define-key c++-mode-map (kbd "C-M-a") nil)))
(add-hook 'c-mode-hook
          (lambda () (define-key c-mode-map (kbd "C-M-a") nil)))


#+end_src
*** C-S-a
*** C-s
c-x prefix

*** M-s
*** C-M-s
split-window-vertically
#+begin_src emacs-lisp
(global-set-key (kbd "C-M-s") 'split-window-vertically)
#+end_src
*** C-S-s
*** C-d
    C-c prefix
*** M-d
*** C-M-d
swap buffer across windows
from http://www.emacswiki.org/emacs/TransposeWindows
#+begin_src emacs-lisp
(setq swapping-buffer nil)
(setq swapping-window nil)
(defun swap-buffers-in-windows ()
  "Swap buffers between two windows"
  (interactive)
  (if (and swapping-window
           swapping-buffer)
      (let ((this-buffer (current-buffer))
            (this-window (selected-window)))
        (if (and (window-live-p swapping-window)
                 (buffer-live-p swapping-buffer))
            (progn (switch-to-buffer swapping-buffer)
                   (select-window swapping-window)
                   (switch-to-buffer this-buffer)
                   (select-window this-window)
                   (message "Swapped buffers."))
          (message "Old buffer/window killed.  Aborting."))
        (setq swapping-buffer nil)
        (setq swapping-window nil))
    (progn
      (setq swapping-buffer (current-buffer))
      (setq swapping-window (selected-window))
      (message "Buffer and window marked for swapping."))))

(global-set-key (kbd "C-M-d") 'swap-buffers-in-windows)
#+end_src
*** C-S-d
*** C-f]
kill-whole-line
#+begin_src emacs-lisp
  (global-set-key (kbd "C-f") 'kill-whole-line-wrapper)
  (defun kill-whole-line-wrapper (&optional arg)
    "If we are at the end of the file, kill backwards instead of doing nothing."
    (interactive "P")
    (if (= (point) (point-max))
        (kill-whole-line -1)
      (kill-whole-line arg)))
#+end_src
*** M-f]
print-var-at-point
#+begin_src emacs-lisp
(defun print-var-at-point ()
  (interactive)
  (let ((v (variable-at-point)))
    (if (symbolp v)
        (message "%s: %s" v (symbol-value v))
      (message "no symbol found at point"))))
(global-set-key (kbd "M-f") 'print-var-at-point)
#+end_src

*** C-M-f]
kill rest of line
#+begin_src emacs-lisp

  (add-hook 'org-mode-hook
            (lambda ()
              (define-key org-mode-map (kbd "C-M-f") 'org-kill-line)))

    (global-set-key (kbd "C-M-f") 'kill-line)
#+end_src
*** C-S-f
*** C-g]
cancel / other window
#+begin_src emacs-lisp
    (global-set-key (kbd "C-g") 'other-window)
#+end_src
*** M-g]
abort-recursive-edit
#+begin_src emacs-lisp
    (global-set-key (kbd "M-g") 'abort-recursive-edit)
#+end_src
*** C-M-g]
gnus
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-g") 'mu4e)
#+end_src
*** C-S-g
*** C-z
#+begin_src emacs-lisp
    (global-set-key (kbd "C-z") 'undo-tree-undo)
#+end_src
*** M-z
*** C-M-z]
*** C-S-z
*** C-x
kill-region
#+begin_src emacs-lisp
    (global-set-key (kbd "C-s") 'kill-region)
#+end_src
*** M-x]
smex
#+begin_src emacs-lisp
(global-set-key (kbd "M-x") 'smex)
#+end_src
*** C-M-x]
cut-to-register
#+begin_src emacs-lisp
;; same args as copy-to-register
(defun cut-to-register (register start end &optional delete-flag region)
  (interactive (list (register-read-with-preview "Cut to register: ")
                     (region-beginning)
                     (region-end)
                     current-prefix-arg
                     t))
  (copy-to-register register start end t region))

(global-set-key (kbd "C-M-x") 'cut-to-register)
#+end_src
*** C-S-x
*** C-c
copy
#+begin_src emacs-lisp
(global-set-key (kbd "C-d") 'kill-ring-save)
(add-hook 'c-mode-hook
          (lambda () (define-key c-mode-map (kbd "C-d") nil)))
(add-hook 'comint-mode-hook
          (lambda ()
            (define-key comint-mode-map (kbd "C-d") nil)))
;; the base map is shared by many c-modes, like java
(add-hook 'c-mode-hook
          (lambda ()
            (define-key c-mode-base-map "\C-d" nil)
            (define-key c-mode-base-map (kbd "<deletechar>") 'c-electric-delete-forward)))

#+end_src
*** M-c]
org-capture
#+begin_src emacs-lisp
  (define-key global-map "\M-c" 'org-capture)
#+end_src
*** C-M-c]
copy-to-register
#+begin_src emacs-lisp
  (global-set-key (kbd "C-M-c") 'copy-to-register)
#+end_src
*** C-S-c
*** C-v
yank
#+begin_src emacs-lisp
    (global-set-key (kbd "C-v") 'yank-better)



    (defun yank-better (arg)
  "Paste, linewise if our kill ends with a newline.
  I change the behavior of plain prefix. It makes it not do linewise paste,
  because sometimes you want to yank pop and a linewise paste screws that up.
  c-u with no number normally makes the point go before the yank.
  That is pointless for me, as it would be just as easier and less
  thought to pop the mark after yanking cuz it is set to before the mark."
      (interactive "*P")
      (if (and (not (equal arg '(4))) (string-suffix-p "\n" (current-kill 0 t)))
          (beginning-of-line))
      (if (and (stringp mode-name) (string= mode-name "Org"))
          (call-interactively 'org-yank)
        (setq this-command 'yank)
        (call-interactively 'yank (and (not (equal arg '(4)))))))

    (put 'yank-better 'delete-selection 'yank)
#+end_src
*** M-v]
insert-register
#+begin_src emacs-lisp
  (global-set-key (kbd "M-v") 'insert-register)
#+end_src
*** C-M-v]
yank-pop
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-v") 'yank-pop)
#+end_src
*** C-S-v
*** C-b]
delete-other-windows
#+begin_src emacs-lisp
    (global-set-key (kbd "C-b") 'delete-other-windows)
#+end_src
*** M-b]
isearch-backward-current-symbol
#+begin_src emacs-lisp
   (global-set-key (kbd "M-b") 'isearch-backward-current-symbol)
#+end_src
*** C-M-b]
isearch-current-symbol
    #+begin_src emacs-lisp
(global-set-key (kbd "C-M-b") 'isearch-current-symbol)
#+end_src
*** C-S-b
*** C-tab]
---
in terminal, it's just TAB, duplicate keybind.
*** M-tab]
---
in terminal it's duplicated of C-M-i
*** C-M-tab
*** C-S-tab
*** C-delete]
kill-symbol
#+begin_src emacs-lisp
  (global-set-key (kbd "<C-delete>") 'kill-symbol)
(defun kill-symbol (arg)
    (interactive "p")
    (kill-region (point) (save-excursion (forward-symbol arg) (point))))

#+end_src
*** M-delete
*** C-M-delete]
kill-sexp
#+begin_src emacs-lisp
    (global-set-key (kbd "<C-M-delete>") 'kill-sexp)
#+end_src
*** C-S-delete

*** C-left-arrow]
compile / comint search
#+begin_src emacs-lisp
(defun set-p (var)
  (and (bound-and-true-p var)
       (not (eq var 'unset))))
(global-set-key (kbd "C-(") 'run)

;; make compile work from the gtags root dir
(defadvice compile (before pre-compile-advice activate)
  (basic-save-buffer)
  (when (set-p ggtags-project-root)
    (setq-local compile-saved-dir default-directory)
    (setq default-directory ggtags-project-root)))
(defadvice compile (after post-compile-advice activate)
  (when (bound-and-true-p compile-saved-dir)
    (setq default-directory compile-saved-dir)))


(add-hook 'c-mode-hook (lambda () (define-key c-mode-map (kbd "C-(") 'compile)))
(add-hook 'comint-mode-hook
          (lambda ()
            (define-key isearch-mode-map (kbd "C-(") 'isearch-repeat-backward)
            (define-key comint-mode-map (kbd "C-(") 'isearch-backward)))

#+end_src
*** M-left-arrow
*** C-M-left-arrow]
org-shiftup
#+begin_src emacs-lisp
 (add-hook 'org-mode-hook
            (lambda () (define-key org-mode-map (kbd "C-M-(") 'org-shiftup)))
#+end_src
*** C-S-left-arrow
*** C-right-arrow]
keyboard-yank-primary
#+begin_src emacs-lisp
(defun keyboard-yank-primary ()
  (interactive)
  (let ((mouse-yank-at-point t))
    (mouse-yank-primary nil)))
;; paste selection
(global-set-key (kbd "C-)") 'keyboard-yank-primary) ;; kinesis binding
(global-set-key (kbd "<S-right>") 'keyboard-yank-primary)
#+end_src
*** M-right-arrow
*** C-M-right-arrow
#+begin_src emacs-lisp
 (add-hook 'org-mode-hook
            (lambda () (define-key org-mode-map (kbd "C-M-)") 'org-shiftdown)))
#+end_src
*** C-S-right-arrow
*** C-backspace]
backward-kill-symbol
#+begin_src emacs-lisp
(global-set-key (kbd "<C-backspace>") 'backward-kill-symbol)
(add-hook 'comint-mode-hook
            (lambda ()
              (define-key comint-mode-map (kbd "<C-backspace>") 'backward-kill-word)))
(defun backward-kill-symbol (arg)
    (interactive "p")
    (kill-region (point) (save-excursion (backward-symbol arg) (point))))
#+end_src
*** M-backspace
*** C-M-backspace]
backward-kill-sexp
#+begin_src emacs-lisp
    (global-set-key (kbd "<C-M-backspace>") 'backward-kill-sexp)
#+end_src
*** C-S-backspace
*** C-f7
*** M-f7
*** C-M-f7
*** C-S-f7

** right primary
*** C-*]
split-window-horizontally
#+begin_src emacs-lisp
    (global-set-key (kbd "C-*") 'split-window-horizontally)
#+end_src
*** M-*
*** C-M-*]
calc-dispatch
#+begin_src emacs-lisp
  (global-set-key (kbd "C-M-*") 'calc-dispatch)
#+end_src
*** C-S-*
*** C-9]
delete-window-or-exit
#+begin_src emacs-lisp
(global-set-key (kbd "C-9") 'delete-window-or-exit)

(defun delete-window-or-exit ()
  "Delete window or exit emacs."
  (interactive)
  (if (condition-case nil (delete-window) (error t))
      (if (or (boundp 'server-process) (> (length (frame-list)) 1))
          (progn (basic-save-buffer) (delete-frame))
        (save-buffers-kill-terminal t))))
#+end_src
*** M-9]
kill-buffer
    #+begin_src emacs-lisp
(defun kill-buffer-no-ido ()
"kill-buffer, avoid the ido remapping"
  (interactive)
  (kill-buffer))
(global-set-key (kbd "M-9") 'kill-buffer-no-ido)
    #+end_src
strangely, in simple mode, this is overridden.
I found this map to override, but it didn't work, so it seems its being bound some other way.
I did a grep of the emacs sources, but couldn't find anything.
(define-key universal-argument-map [?9] nil)

*** C-M-9]
end server edit
    ,save & kill buffer if it was opened externally via emacsclient

    #+begin_src emacs-lisp
(defun server-edit-save ()
  (interactive)
  (save-buffer)
  (server-edit))
(global-set-key (kbd "C-M-9") 'server-edit-save)
    #+end_src
*** C-S-9
*** C-u]
universal-argument
*** M-u
*** C-M-u]
search-keybind
#+begin_src emacs-lisp
  (global-set-key (kbd "C-M-u") 'search-keybind)

  (defun search-keybind (regexp &optional nlines)
    (interactive (occur-read-primary-args))
    (save-excursion
      (describe-bindings)
      (set-buffer "*Help*")
      (occur regexp)
      (delete-windows-on "*Help*")
      ))
#+end_src
*** C-S-u
*** C-i
-----
*** M-i
*** C-M-i]
query-replace-regexp
#+begin_src emacs-lisp
  (global-set-key (kbd "C-M-i") 'query-replace-regexp)
 (add-hook 'flyspell-mode-hook
            (lambda () (define-key flyspell-mode-map (kbd "C-M-i") nil)))
(add-hook 'text-mode-hook
            (lambda () (define-key text-mode-map (kbd "C-M-i") nil)))

#+end_src
*** C-S-i
*** C-o]
occur
#+begin_src emacs-lisp
    (global-set-key (kbd "C-o") 'occur)
#+end_src
*** M-o
*** C-M-o]
counsel-imenu
#+begin_src emacs-lisp
  (global-set-key (kbd "C-M-o") 'counsel-imenu)
#+end_src
*** C-S-o
*** C-p]
move-mouse-to-point
#+begin_src emacs-lisp
  (global-set-key (kbd "C-p") 'move-mouse-to-point)
#+end_src
*** M-p
*** C-M-p]
delete-horizontal-space
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-p") 'delete-horizontal-space)
#+end_src
*** C-S-p
*** C-j]
pop-to-mark
#+begin_src emacs-lisp
(defun my-pop-to-mark-command ()
  "Jump to mark, and pop a new position for mark off the ring.
                     \(Does not affect global mark ring\)."
  (interactive)
  (pop-to-mark-command)
  (if (and (derived-mode-p 'org-mode) (outline-invisible-p))
      (org-show-context 'mark-goto)))

(global-set-key (kbd "C-j") 'my-pop-to-mark-command)
(define-key ido-common-completion-map (kbd "C-j") 'ido-select-text)
(add-hook 'ido-setup-hook
          (lambda () (define-key ido-common-completion-map (kbd "C-j") 'ido-select-text)))
(add-hook 'lisp-interaction-mode-hook
          (lambda ()
            (define-key lisp-interaction-mode-map (kbd "C-j") nil)))

#+end_src
*** M-j]
previous-error
#+begin_src emacs-lisp
    (global-set-key (kbd "M-j") 'previous-error)
#+end_src
*** C-M-j]

register prefix
#+begin_src emacs-lisp
(define-key global-map (kbd "C-M-j") ctl-x-r-map)
(define-key ctl-x-r-map "m" 'kmacro-to-register)
#+end_src

*** C-S-j
*** C-k]
jump-to-register
#+begin_src emacs-lisp

    (global-set-key (kbd "C-k") 'jump-to-register)
#+end_src
*** M-k]
next-error
#+begin_src emacs-lisp
    (global-set-key (kbd "M-k") 'next-error)
#+end_src
*** C-M-k]
man
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-k") 'man)
#+end_src
*** C-S-k
*** C-l]
ivy-switch-buffer
#+begin_src emacs-lisp
    (global-set-key (kbd "C-l") 'ivy-switch-buffer)
#+end_src
*** M-l

*** C-M-l]
move cursor top bottom mid, comint clear screen
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-l") 'move-to-window-line-top-bottom)
#+end_src
*** C-S-l
*** C-;]
used in flyspell, not sure what for, otherwise unbound
*** M-;
comment-dwim
*** C-M-;]
comment-current-line-dwim
#+begin_src emacs-lisp
  (defun comment-current-line-dwim ()
    "Comment or uncomment the current line."
    (interactive)
    (save-excursion
      (push-mark (beginning-of-line) t t)
      (end-of-line)
      (comment-dwim nil))
    (move-beginning-of-line 2))
  (global-set-key (kbd "C-M-;") 'comment-current-line-dwim)
#+end_src
*** C-S-;
*** C-m]
*** M-m
*** C-M-m]
recursive grep
#+begin_src emacs-lisp
  (define-key global-map (kbd "C-M-m") 'rgrep)
#+end_src
*** C-S-m
*** C-,]
counsel-find-file
#+begin_src emacs-lisp
    (global-set-key (kbd "C-,") 'counsel-find-file)
(add-hook 'flyspell-mode-hook
            (lambda () (define-key flyspell-mode-map (kbd "C-,") nil)))
#+end_src
*** M-,
*** C-M-,]
find-file-in-project
    #+begin_src emacs-lisp
    (global-set-key (kbd "C-M-,") 'find-file-in-project)
#+end_src
*** C-S-,
*** C-.]
find recent file
Taken from starter kit.
#+begin_src emacs-lisp
  (defun recentf-ido-find-file ()
    "Find a recent file using Ido."
    (interactive)
    (let* ((file-assoc-list
            (mapcar (lambda (x)
                      (cons (file-name-nondirectory x)
                            x))
                    recentf-list))
           (filename-list
            (remove-duplicates (mapcar #'car file-assoc-list)
                               :test #'string=))
           (filename (ido-completing-read "Choose recent file: "
                                          filename-list
                                          nil
                                          t)))
      (when filename
        (find-file (cdr (assoc filename
                               file-assoc-list))))))

 (add-hook 'flyspell-mode-hook
            (lambda () (define-key flyspell-mode-map (kbd "C-.") nil)))
    (define-key dot-mode-map (kbd "C-.") nil)
    (global-set-key (kbd "C-.") 'recentf-ido-find-file)
 (add-hook 'php-mode-hook
            (lambda () (define-key php-mode-map (kbd "C-.") nil)))
#+end_src
*** M-.
*** C-M-.
-
#+begin_src emacs-lisp
  (define-key dot-mode-map (kbd "C-M-.") nil)
;;  (global-set-key (kbd "C-M-.") 'execute-extended-command)
#+end_src
*** C-S-.
*** C-/]
join lines
#+begin_src emacs-lisp
  (defun vim-style-join-line ()
    (interactive)
    (join-line '(4)))
  (global-set-key (kbd "C-/") 'vim-style-join-line)
(define-key undo-tree-map (kbd "C-/") nil)
#+end_src
*** M-/
*** C-M-/]
copy-buffer-file-name
#+begin_src emacs-lisp
;; haven't bound this atm, todo, maybe someday?
(defun copy-variable (variable)
  (interactive
   (let ((v (variable-at-point))
         (enable-recursive-minibuffers t)
         val)
     (setq val (completing-read (if (symbolp v)
                                    (format
                                     "Describe variable (default %s): " v)
                                  "Describe variable: ")
                                obarray
                                (lambda (vv)
                                  (or (get vv 'variable-documentation)
                                      (and (boundp vv) (not (keywordp vv)))))
                                t nil nil
                                (if (symbolp v) (symbol-name v))))
     (list (if (equal val "")
               v (intern val)))))
  (kill-new (symbol-value variable)))

(defun copy-buffer-file-name ()
  (interactive)
  (let ((name (cond
               ((derived-mode-p 'mu4e-view-mode) (mu4e-message-field-at-point :path))
               (t buffer-file-name))
              ))
    (kill-new name)
    (message name)))


(global-set-key (kbd "C-M-/") 'copy-buffer-file-name)


#+end_src
*** C-S-/
*** C-8]
calc-embedded-word
#+begin_src emacs-lisp
    (global-set-key (kbd "C-8") 'calc-embedded-word)
#+end_src
*** M-8
*** C-M-8
*** C-S-8
*** C-up-arrow]
org prev headline
#+begin_src emacs-lisp
  (define-key undo-tree-map "\C-_" nil)
;; disabled just because i don't want to accidentally hit it
  (define-key global-map "\C-_" nil)
    (global-set-key (kbd "<C-_>") 'beginning-of-defun)

    (add-hook 'org-mode-hook
            (lambda ()
              (define-key org-mode-map (kbd "\C-_") 'outline-previous-visible-heading)))

#+end_src


*** M-up-arrow
*** C-M-up-arrow
*** C-S-up-arrow
winner undo
#+begin_src emacs-lisp
  (global-set-key (kbd "<C-S-_>") 'winner-undo)
#+end_src
*** C-down-arrow]
org next headline
#+begin_src emacs-lisp
    (global-set-key (kbd "<C-kp-enter>") 'end-of-defun)

    (add-hook 'org-mode-hook
            (lambda ()
              (define-key org-mode-map (kbd "<C-kp-enter>") 'outline-next-visible-heading)))

#+end_src


*** M-down-arrow
*** C-M-down-arrow]
toggle-mark-activation
#+begin_src emacs-lisp
  (defun toggle-mark-activation ()
    (interactive)
    (if mark-active
        (deactivate-mark t)
      (activate-mark)))

  (global-set-key (kbd "<C-M-kp-enter>") 'toggle-mark-activation)
#+end_src
winner redo
#+begin_src emacs-lisp
  (global-set-key (kbd "<C-S-kp-enter>") 'winner-redo)
#+end_src

*** C-S-down-arrow]
m-x for major mode
    #+begin_src emacs-lisp
  (global-set-key (kbd "<C-S-kp-enter>") 'smex-major-mode-commands)
#+end_src
*** C-lbracket
----
*** M-lbracket
*** C-M-lbracket]
scroll-right
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-[") 'scroll-right)
    #+end_src
*** C-S-lbracket
*** C-rbracket]
fill-paragraph
#+begin_src emacs-lisp
  (global-set-key (kbd "C-]") 'fill-paragraph)
#+end_src
*** M-rbracket
*** C-M-rbracket]
scroll-left
    #+begin_src emacs-lisp
    (global-set-key (kbd "C-M-]") 'scroll-left)
    #+end_src
*** C-S-rbracket
*** C-return]
newline-anywhere
#+begin_src emacs-lisp
(defun newline-anywhere ()
  "Add a newline from anywhere in the line."
  (interactive)
  (end-of-line)
  (newline-and-indent))
(global-set-key (kbd "<C-return>") 'newline-anywhere)

#+end_src
*** M-return]
plain newline
#+begin_src emacs-lisp
(defun plain-newline ()
(interactive)
(insert "\n"))
(global-set-key (kbd "<M-return>") 'plain-newline)
#+end_src

*** C-M-return
#+begin_src emacs-lisp
(defun newline-anywhere-previous ()
  "Add a newline from anywhere in the line."
  (interactive)
  (forward-line -1)
  (end-of-line)
  (newline-and-indent))
(global-set-key (kbd "<C-M-return>") 'newline-anywhere-previous)
#+end_src
*** C-S-return
*** C-space]
org-edit-special
#+begin_src emacs-lisp
;; commented due to new keyboard needing ctrl-space for mark
;; (kbd "<C-space>") does not work, (kbd "C-SPC") should work
;; (add-hook 'org-mode-hook
;;           (lambda ()
;;             (define-key org-mode-map (kbd "C-SPC") 'org-edit-special)
;;             ;; org-src-mode-map is broken in git version of emacs.
;;             ;; temporarily use this for exiting edit-special mode.
;;             (global-set-key (kbd "C-M--") 'org-edit-src-exit)
;;             (define-key org-src-mode-map (kbd "C-SPC") 'org-edit-src-exit)))
#+end_src
*** M-space
*** C-M-space
    before or under cursor
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-SPC") 'ispell-word)
#+end_src
*** C-S-space
** left secondary
*** C-=
*** M-=
*** C-M-=
*** C-S-=
*** C-1
*** M-1
*** C-M-1
*** C-S-1
*** C-4
*** M-4
*** C-M-4
widen
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-4") 'widen)
#+end_src
*** C-S-4
*** C-5
*** M-5
*** C-M-5
*** C-S-5
*** C-tab-key]
query-replace
#+begin_src emacs-lisp

  (global-set-key (kbd "<C-kp-add>") 'query-replace)
#+end_src
*** M-tab-key
*** C-M-tab-key
*** C-S-tab-key
*** C-t]
org cycle todo / toggle comint motion
#+begin_src emacs-lisp
(add-hook 'org-mode-hook
          (lambda ()
            (define-key org-mode-map (kbd "C-t") 'org-todo)))

(defun my-comint-previous-input (arg)
  (interactive "*p")
  (if (comint-after-pmark-p)
      (comint-previous-input arg)
    (forward-line -1)))

(defun my-comint-next-input (arg)
  (interactive "*p")
  (if (comint-after-pmark-p)
      (comint-next-input arg)
    (forward-line)))

(add-hook 'comint-mode-hook
          (lambda ()
            (define-key comint-mode-map (kbd "C-t") 'comint-toggle-arrow-keys)
            (define-key comint-mode-map (kbd "<up>") 'my-comint-previous-input)
            (define-key comint-mode-map (kbd "<down>") 'my-comint-next-input)))


(defun comint-toggle-arrow-keys ()
  (interactive)
  (toggle-arrow-keys comint-mode-map))

(setq-default comint-arrow-movement nil)
(defun toggle-arrow-keys (map)
  (cond ((lookup-key map (kbd "<up>"))
         (setq-local comint-arrow-movement t)
         (define-key map (kbd "<up>") nil)
         (define-key map (kbd "<down>") nil))
        (t
         (setq-local comint-arrow-movement nil)
         (define-key map (kbd "<up>") 'my-comint-previous-input)
         (define-key map (kbd "<down>") 'my-comint-next-input)
         (goto-char (point-max)))))

(eval-after-load "message"
  '(define-key message-mode-map (kbd "C-t") 'mail-signature))
#+end_src
Thanks for the update. I will be enjoying it.

#+RESULTS:
: comint-toggle-arrow-keys
*** M-t
*** C-M-t]
org timestamp
#+begin_src emacs-lisp
(global-set-key (kbd "C-M-t") 'org-time-stamp-with-time)
#+end_src
*** C-S-t
*** C-home
start of buffer
*** M-home
*** C-M-home
*** C-S-home
*** C-end
end of buffer
*** M-end
*** C-M-end
*** C-S-end
*** C-f9
*** M-f9
*** C-M-f9
*** C-S-f9
** right secondary
*** C-6
save-buffers-kill-emacs
#+begin_src emacs-lisp
(global-set-key (kbd "C-6") 'save-buffers-kill-emacs)
#+end_src
*** M-6
*** C-M-6]
  insert-small-copyright
#+begin_src emacs-lisp
(defun insert-small-copyright ()
    (interactive)
    (beginning-of-line)
    (let ((beg (point)))
      (insert "Copyright (C) 2017 Ian Kelling\nThis program is under GPL v. 3 or later, see <http://www.gnu.org/licenses/>")
      (comment-region beg (point))))

  (global-set-key (kbd "C-M-6") 'insert-small-copyright)
#+end_src
*** C-S-6
*** C-7
*** M-7
*** C-M-7]
insert-full-copyright
#+begin_src emacs-lisp
(defun insert-full-copyright ()
  (interactive)
  (beginning-of-line)
  (let ((beg (point)))
    (insert "Copyright (C) 2017 Ian Kelling\n")
    (insert "\n")
    (insert "This program is free software: you can redistribute it and/or modify\n")
    (insert "it under the terms of the GNU General Public License as published by\n")
    (insert "the Free Software Foundation, either version 3 of the License, or\n")
    (insert "(at your option) any later version.\n")
    (insert "\n")
    (insert "This program is distributed in the hope that it will be useful,\n")
    (insert "but WITHOUT ANY WARRANTY; without even the implied warranty of\n")
    (insert "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n")
    (insert "GNU General Public License for more details.\n")
    (insert "\n")
    (insert "You should have received a copy of the GNU General Public License\n")
    (insert "along with this program.  If not, see <http://www.gnu.org/licenses/>.\n")
    (comment-region beg (point))))

(global-set-key (kbd "C-M-7") 'insert-full-copyright)

#+end_src
*** C-S-7
*** C-0
text-scale-reset
#+begin_src emacs-lisp
(defun text-scale-reset ()
  (interactive)
  (text-scale-set 0))
(global-set-key (kbd "C-0") 'text-scale-reset)
#+end_src
*** M-0
*** C-M-0
insert-apache
#+begin_src emacs-lisp
(defun insert-apache ()
  (interactive)
  (beginning-of-line)
  (let ((beg (point)))
    (insert "Copyright (C) 2017 Ian Kelling\n")
    (insert "\n")
    (insert "Licensed under the Apache License, Version 2.0 (the \"License\");\n")
    (insert "you may not use this file except in compliance with the License.\n")
    (insert "You may obtain a copy of the License at\n")
    (insert "\n")
    (insert "    http://www.apache.org/licenses/LICENSE-2.0\n")
    (insert "\n")
    (insert "Unless required by applicable law or agreed to in writing, software\n")
    (insert "distributed under the License is distributed on an \"AS IS\" BASIS,\n")
    (insert "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n")
    (insert "See the License for the specific language governing permissions and\n")
    (insert "limitations under the License.\n")
    (comment-region beg (point))))
(global-set-key (kbd "C-M-0") 'insert-apache)
#+end_src

*** C-S-0
*** C--
*** M--
*** C-M--
org-edit-src-exit
*** C-S--
*** C-y]
    undo-tree-redo
#+begin_src emacs-lisp
  (global-set-key (kbd "C-y") 'undo-tree-redo)
#+end_src

*** M-y
*** C-M-y
*** C-S-y
*** C-\
#+begin_src emacs-lisp
  (global-set-key (kbd "C-\\") 'sr-speedbar-toggle)
#+end_src
*** M-\
*** C-M-\]
mark-defun
#+begin_src emacs-lisp
  (global-set-key (kbd "C-M-\\") 'mark-defun)
#+end_src
*** C-S-\
*** C-h
help-prefix

*** M-h
*** C-M-h
*** C-S-h
*** C-'
eval-expression
#+begin_src emacs-lisp
(global-set-key (kbd "C-'") 'eval-expression)
#+end_src
*** M-'
*** C-M-'
*** C-S-'
*** C-n]
unpop to mark
    #+begin_src emacs-lisp
      (defun unpop-to-mark-command ()
        "Unpop off mark ring. Does nothing if mark ring is empty."
        (interactive)
        (when mark-ring
          (let ((pos (marker-position (car (last mark-ring)))))
            (if (not (= (point) pos))
                (goto-char pos)
              (setq mark-ring (cons (copy-marker (mark-marker)) mark-ring))
              (set-marker (mark-marker) pos)
              (setq mark-ring (nbutlast mark-ring))
              (goto-char (marker-position (car (last mark-ring))))))))

      (global-set-key (kbd "C-n") 'unpop-to-mark-command)
#+end_src
*** M-n
*** C-M-n]
narrow-to-region
#+begin_src emacs-lisp
    (global-set-key (kbd "C-M-n") 'narrow-to-region)
#+end_src
*** C-S-n
*** C-rshift
*** M-rshift
*** C-M-rshift
*** C-S-rshift
*** C-escape]
    find-tag
    :ID:       a6dd7e4c-1831-4493-bbfd-557dc2f9c856
    :CUSTOM_ID: 6901fa1b-c827-4525-b24b-bdb8fe5f638b








    :END:
find-tag
#+begin_src emacs-lisp
    (global-set-key (kbd "<C-escape>") 'find-tag)
#+end_src
*** M-escape
*** C-M-escape
*** C-S-escape
* keybind table src
not necessary to have at the end, but its convenient to have it next
to its output.
  #+NAME: keybind-table-generator
#+BEGIN_SRC emacs-lisp :results silent
(defun org-custom-id-get (&optional pom create prefix)
  "Get the CUSTOM_ID property of the entry at point-or-marker POM.
              If POM is nil, refer to the entry at point.
              If the entry does not have a CUSTOM_ID, the function returns nil.
              However, when CREATE is non nil, create an ID if none is present already.
              PREFIX will be passed through to `org-id-new'.
              In any case, the CUSTOM_ID of the entry is returned."
  (org-with-point-at pom
    (let ((id (org-entry-get nil "CUSTOM_ID")))
      (cond
       ((and id (stringp id) (string-match "\\S-" id))
        id)
       (create
        (setq id (org-id-new prefix))
        (org-entry-put pom "CUSTOM_ID" id)
        (org-id-add-location id (buffer-file-name (buffer-base-buffer)))
        id)))))

(defun get-title()
  (interactive)
  (let ((title (plist-get (cadr (org-element-at-point)) ':title)))
    ;; remove brackets from [title]
    ;; I was at one point using org-drill for spaces repitition,
    ;; and enclosed question and answer by 2 sets of brackets.
    (string-match "[^[ ][^]]*" title)
    (setq title (match-string 0 title))
    (print title)
    title))


(defun org-dblock-write:keybind-dblock (arg)
  (let (output)
    (save-excursion
      (goto-char (org-find-entry-with-id "beginning-of-keybind-table-data"))
      (let* ((table-level (org-current-level))
             (keybind-level (1+ table-level))
             (prefixes (list "C-M-S-" "C-M-" "C-S-" "M-S-" "M-"  "C-" "S-"))
             table-title
             previous-prefixes
             )
        (while (>= (org-current-level) table-level)
          (setq table-title (get-title))
          (outline-next-heading)
          (let (found-prefixes
                found-all-prefixes)
            ;; go through the first few elements of the table to find out what column headings aka prefixes it should have
            (save-excursion
              (while (not found-all-prefixes)
                (let ((prefixes-copy prefixes)
                      current-prefix
                      found-prefix)
                  (while (and prefixes-copy (not found-prefix))
                    (setq current-prefix (car prefixes-copy))
                    (when (and (> (length (get-title)) (length current-prefix))
                               (string= (substring (get-title) 0 (length current-prefix)) current-prefix))
                      (setq found-prefix t))
                    (setq prefixes-copy (cdr prefixes-copy)))
                  (unless found-prefix
                    (setq current-prefix ""))
                  (if (and found-prefixes (string= (car (last found-prefixes)) current-prefix))
                      (setq found-all-prefixes t)
                    (push current-prefix found-prefixes)))
                (outline-next-heading)))
            (setq found-prefixes (reverse found-prefixes))

            ;; start a new table or repeat the prefixes in the current table

            (if (or (not previous-prefixes) (equal previous-prefixes found-prefixes))
                (setq output (concat output "|-|\n| "))
              (setq output (concat output "|-|\n\n|-|\n| ")))
            (setq output (concat output table-title " | "))
            (setq previous-prefixes found-prefixes)

            ;; add the prefixes
            (dolist (prefix found-prefixes)
              (setq output (concat output prefix "|")))
            (setq output (concat output "\n|-|\n"))


            (let (subtree-end)
              (while (>= (org-current-level) keybind-level)
                (dotimes (i (length found-prefixes))
                  ;; add keybind name
                  (when (= i 0)
                    (setq output (concat output "| " (substring (get-title) (length (car found-prefixes))) " | ")))
                  ;; add keybinds by searching for regex [keybind] to the start of the next heading
                  (save-excursion
                    (outline-next-heading)
                    (setq subtree-end (point)))
                  ;; skip over scheduled line

                  ;; see comment after source block to understand this regex
                  (re-search-forward "^\\s-*\\([^*: ].*?$\\)" subtree-end t)
                  (let ((m (match-string 1)))
                    (when m
                      (setq output (concat output "[[#" (org-custom-id-get (point) 'create) "][" m "]]")))
                    (setq output (concat output " | ")))
                  ;; advance to next keybind
                  (outline-next-heading))
                (setq output (concat output "\n"))
                ))))))
    (setq output (concat output "|-|"))
    (insert output))
  (org-table-map-tables 'org-table-align 'quietly))


#+END_SRC
  after source block due to bad parsing of comments in non emacs lisp mode
      some easily forgotten regex elements. whitespace: \\s-
      non-greedy star: *?
      subexpression for close bracket char or nothing: \\(\\]\\|\\)

* keybind tables
:LOGBOOK:
CLOCK: [2016-11-28 Mon 10:59]--[2016-11-28 Mon 10:59] =>  0:00
:END:
dunno why but it takes doing ctrl-c twice to update this
  #+BEGIN: keybind-dblock
  |---------------------+------------------------|
  | single/special keys |                        |
  |---------------------+------------------------|
  | tab key             | [[#6c10a716-1d8e-4ce4-8e26-64468f19c17a][isearch]]                |
  | tab                 | [[#51ece189-1840-41a1-8ca0-19f9a0481895][isearch-forward]]        |
  | end                 | [[#00d589b7-2b8e-494c-b761-3afefebe6ec6][move-end-of-line]]       |
  | home                | [[#7800e455-c3f6-4a8f-8907-b2292449ab67][back-to-indentation]]    |
  | s-tab               | [[#3072901e-5cf3-4d6e-9ac8-3ef64a5f6ad2][indent-buffer]]          |
  | s-delete            | [[#e53728b6-054d-4443-a03e-6cf02d13724d][send-shell]]             |
  | s-left arrow        | [[#d8c473ac-5507-4a6b-9e5a-46558c17b09f][shell]]                  |
  | s-right arrow       | [[#cbae2b27-ff95-4b12-88e0-e1a0f7705db6][previous-buffer]]        |
  | esc                 |                        |
  | return              | [[#fab6adea-ed20-45ab-a0a3-776c68d5c3a5][new line]]               |
  | s-return            | [[#c433c837-24fa-45e1-8991-a4d380550ea0][auto-correct-prev-word]] |
  | down arrow          | [[#7a868484-9c63-4a73-abda-7751cb2c02be][mark]]                   |
  | s-down arrow        | [[#097b97e0-8ad8-40f7-8388-c4ace1706b38][extended command]]       |
  | s-up arrow          |                        |
  |---------------------+------------------------|

  |-------------------+----------------------------+---------------------------------+--------------------+---------------+-------------+-------------|
  | mouse             |                            | C-                              | M-                 | S-            | C-M-        | C-S-        |
  |-------------------+----------------------------+---------------------------------+--------------------+---------------+-------------+-------------|
  | mouse-2 mode line | [[#69aaa631-6fb5-4beb-b2d8-c0f3d92c0a98][mouse-delete-other-windows]] | [[#501479ab-e1e2-497e-bd86-071f8afa3378][mouse-split-window-horizontally]] |                    |               |             |             |
  | mouse-3 mode line | [[#917a1844-8c38-4f31-8616-50fc81334f2c][mouse-delete-window]]        |                                 |                    |               |             |             |
  | mouse-1           | [[#4e60e2e4-8c2f-4450-8060-2d793ede530c][set cursor/mark]]            | [[#b661f84f-57df-4095-9dc1-d1a876a53ee5][buffer list context menu]]        |                    |               |             |             |
  | mouse-2           | [[#086b0b50-054f-462d-92fa-b27852f887b0][paste]]                      |                                 |                    |               |             |             |
  | mouse-3           | [[#0481632e-9c50-4328-9365-c4b5bf967b66][set-mark]]                   | [[#9623c78f-7705-4cbe-a990-c24eb1067377][global menu]]                     |                    |               |             |             |
  | mouse-9           | [[#efaec161-b279-4129-86fd-b410430926e4][move-mouse-to-point]]        |                                 |                    |               |             |             |
  | mouse-8           |                            |                                 |                    |               |             |             |
  | 1/kp-end          |                            |                                 |                    |               |             |             |
  | 2/kp-down         |                            |                                 | [[#50db5a06-452e-491f-875b-3de936a4d04a][smex]]               |               |             |             |
  | 3/kp-next         |                            |                                 |                    |               |             |             |
  | 4/kp-left         | [[#c44d0f65-9502-4cc6-9642-96d907f6b093][indent-region]]              |                                 |                    |               |             |             |
  | 5/kp-begin        | [[#2458c6bc-7113-4d4b-bbdf-206e1cb842a7][mark-defun]]                 |                                 |                    |               |             |             |
  | 6/kp-right        | [[#3b79bc58-6067-43bd-9471-9d592744a25a][ibuffer]]                    |                                 |                    |               |             |             |
  | 7/kp-home         |                            |                                 |                    |               |             |             |
  | 8/kp-up           |                            |                                 |                    |               |             |             |
  | 9/kp-prior        | [[#a3b51adb-4405-4d9f-9b88-a8faa479fbe7][delete-horizontal-space]]    |                                 |                    |               |             |             |
  | 10/kp-insert      |                            |                                 |                    |               |             |             |
  | 11/kp-subtract    |                            |                                 |                    |               |             |             |
  | 12/kp-add         |                            |                                 |                    |               |             |             |
  | scroll            | [[#33433f0f-5b0e-46ba-8452-d2a51e54769b][up/dn / scroll]]             | [[#38c594ca-1d13-441b-833c-ad47b27e7073][cycle recent buffers]]            | [[#e1e2e253-450d-4620-af9e-78d378f49ad5][forward/back s-exp]] | [[#945cbcda-9a5a-4a9f-ad5c-4ede9a43656e][expand region]] | [[#10bc56d0-a6fe-4e2e-a287-1d280358ad1c][scroll]]      | [[#fc79fff3-259e-416a-a62a-c237b30ade28][zoom]]        |
  | left-scroll       | [[#d2d5c5c7-f0de-4e08-953b-d41d3e282ba7][left/right]]                 | [[#7bb95aa5-381e-454a-a6c6-aaeec728db08][back / forward word]]             | [[#3aeb5be7-6026-42f6-a65b-b00799e44642][winner undo redo]]   | [[#ca5cdcd4-b3da-4d7b-86ab-4c7c0ac2caf7][---]]           | [[#7f7103f5-2488-46a6-8530-6d8a558e6eff][unreachable]] | [[#7b4f1f49-6d93-4210-a30c-8278d6e63655][unreachable]] |
  |-------------------+----------------------------+---------------------------------+--------------------+---------------+-------------+-------------|

  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  | left primary    | C-                             | M-                              | C-M-                          | C-S-                     |
  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  | 2               | [[#b7db9f5c-f31d-45fb-ac70-eb3ef9369d3d][copy-symbol]]                    | [[#53ecfda2-d9f6-4882-b7a2-9b3c859e3bcb][shell-cd-to-file]]                | [[#33c4996d-92bc-4df0-b005-11553677be13][---]]                           |                          |
  | 3               | [[#401f56ff-6aba-4156-b128-f449b18c27af][dot-mode-execute]]               |                                 | [[#eb0cc3a8-b62e-4a24-9f84-cc8e854f91dd][recenter-top-bottom]]           |                          |
  | q               | [[#679fd3cd-c43b-409c-be36-4175a5f27cd3][org-cycle, comint previous arg]] | [[#9a186632-7b04-4af7-b7de-eaec87daf315][org-archive-to-archive-sibling]]  | [[#1f5e9b63-7ce0-445c-a426-b41839585d38][quoted-insert]]                 |                          |
  | w               | [[#20005b6d-9a9d-4b58-882c-7ce860c7a395][goto-t.org]]                     | [[#9531a0da-269f-4359-9124-e83fbf61a92f][org-clock-in]]                    |                               |                          |
  | e               | [[#11e8f541-f0a0-4058-883a-98bd1e7b8c4d][copy-line]]                      | [[#74d0ed51-ddb5-488e-bf55-0f033916e319][org-clock-in-last]]               |                               |                          |
  | r               | [[#5088a8b2-a772-4660-a3b6-b8cca7099da6][isearch-backward]]               | [[#8fe64424-1f11-4086-84b3-07c2af210c1c][org-clock-out]]                   |                               |                          |
  | a               | [[#d57dd0ac-2251-44af-b232-30f8a2b0b198][copy-all]]                       | [[#77987ef8-6a18-4123-8ede-77bc766aa2aa][kmacro-start-macro-or-in...]]     | [[#dd2c225e-2d18-4b95-bc30-765163a5e368][kmacro-end-or-call-macro]]      |                          |
  | s               | [[#f26dd0f5-0655-485f-8c76-e6dfc6abd947][C-x prefix]]                     |                                 | [[#290ea04a-be99-416a-a95f-458045a91c93][split-window-vertically]]       |                          |
  | d               | [[#b699614a-9994-4fe7-b2c6-f0fe81b7ad2b][C-c prefix]]                     |                                 | [[#d9f48fbe-0a32-4133-93fb-f43ff6ab0037][swap buffer]]                   |                          |
  | f               | [[#2695ed8a-e0d3-4e84-8688-98e3c50723b0][kill-whole-line]]                | [[#869f0aec-c739-4fb7-8e3a-8b55ab637765][print-var-at-point]]              | [[#e7e4dd0b-418f-48ee-b366-9e733e3bec61][kill rest of line]]             |                          |
  | g               | [[#a58a1eda-43ed-437e-b483-5c312e0754a7][other-window / cancel]]          | [[#a287d720-4419-4546-8262-1f377bb158d2][abort-recursive-edit]]            | [[#327e18af-30b7-47e5-aa53-5f678788b4c1][gnus]]                          |                          |
  | z               | [[#5c30ce7e-8bc6-45bf-b9b1-5c75334a3e27][undo-tree-undo]]                 |                                 |                               |                          |
  | x               | [[#ec1403d3-528e-41b1-a195-5563bc93e124][kill-region]]                    | [[#bb7c95d5-dd97-439d-bf1f-cdac98d11543][append-next-kill]]                | [[#47cc90e3-335f-4c44-9f39-b732e5440664][append-next-kill]]              |                          |
  | c               | [[#400f06e1-8e45-443c-8d7b-3d1bb1176aab][copy]]                           | [[#7a265014-1e9c-4639-ad1d-26b3416379a8][org-capture]]                     | [[#503e0beb-6fda-4e94-9678-d58bd3cbbc8e][copy-to-register]]              |                          |
  | v               | [[#16411f68-7fe0-49e8-9a73-212471594f9e][yank]]                           | [[#fe04fffa-6f85-483a-b329-938531109c35][insert-register]]                 | [[#c559e9ea-1218-4ccb-9c3a-74cbac4be220][yank pop]]                      |                          |
  | b               | [[#3090fb11-9a11-47e5-bc98-080ebd250d37][delete-other-windows]]           | [[#c18b9197-3d52-45a6-9d20-50d18fe1e7a7][isearch-backward-current-symbol]] | [[#e9dd549f-d031-418a-a0d5-30cf85e91c37][isearch-current-symbol]]        |                          |
  | tab             | [[#928505cb-707c-47ba-af54-5ae1df2ee07d][yas-insert-snippet]]             | [[#64f91d86-afa9-4500-8d7d-ce8b2668726b][indent line]]                     |                               |                          |
  | delete          | [[#e3d8653e-2282-4e3a-a4f5-29211ba2e647][kill-symbol]]                    |                                 | [[#d9664937-d61c-4cc8-89c6-7f2182655c20][kill-sexp]]                     |                          |
  | left-arrow      | [[#601c8172-f9b7-4e36-88ab-c66c2911b4d7][compile]]                        |                                 | [[#91ddc121-db27-4f1c-a9ec-a4d29b96a7d2][org-shiftup]]                   |                          |
  | right-arrow     | [[#5f66f60b-adcd-45dc-86b2-5d1225e2455c][paste selection]]                |                                 | [[#fc2147b4-a19a-4fde-bb53-e7ac28f0bfa1][org-shiftdown]]                 |                          |
  | backspace       | [[#96f90a00-2260-4340-ae03-f4a86bd65502][backward-kill-symbol]]           |                                 | [[#606b0991-7431-4a8a-a909-b872e104cc88][backward-kill-sexp]]            |                          |
  | f7              |                                |                                 |                               |                          |
  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  | right primary   | C-                             | M-                              | C-M-                          | C-S-                     |
  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  | *               | [[#045c374c-b03e-42cb-b274-0f30c81fe3f3][split-window-horizontally]]      |                                 | [[#05cf6230-9263-4fd4-9812-4f32009eed46][calc-dispatch]]                 |                          |
  | 9               | [[#43d14154-2722-4ba5-b547-1b78c6274ebf][delete-window-or-exit]]          | [[#ed93f5b8-2c7f-46f8-8d84-2e10d9bc8f87][kill-buffer-and-window]]          | [[#37ef629b-fdbc-4d0b-bfa0-335eb1d408ee][kill client buffer]]            |                          |
  | u               | [[#327992c0-6eba-4935-aec1-49871c2a8619][universal-argument]]             |                                 | [[#7af825b1-92d8-4d5d-aaa1-8b4b466ea2e0][search-keybind]]                |                          |
  | i               | [[#3124e200-1d6e-4ad2-9a36-0d03e1e7dc38][-----]]                          |                                 | [[#b2cc7cdd-c177-4ef2-af43-28ca7a338fda][query-replace-regexp]]          |                          |
  | o               | [[#b87a2c8a-7eb3-4661-9b28-589d14206c41][occur]]                          |                                 | [[#d30ac3cd-1963-4bd0-8052-98e12b6524b0][counsel-imenu]]                 |                          |
  | p               | [[#d84de055-e92e-478d-bb39-bc39acfa1586][move-mouse-to-point]]            |                                 | [[#08e65732-2fb1-4a78-9d18-cee87eb867a7][delete-horizontal-space]]       |                          |
  | j               | [[#ca1ce86b-dcea-45c1-9a8e-dd4f306776e8][pop-to-mark]]                    | [[#b92414e2-0d5b-4576-8fa5-5e7f1e32819a][previous-error]]                  | [[#8fe7cac2-ab1a-4b39-aced-10c5e0157e68][register prefix]]               |                          |
  | k               | [[#eb1c2360-bfd4-4d5c-b789-11b5ca5ba475][jump to register]]               | [[#9061b192-735a-4273-ae36-993e6fad9205][next-error]]                      | [[#e1d768be-6b9b-4322-931f-3e570376ae15][man]]                           |                          |
  | l               | [[#137995db-ee30-4738-90e2-54dcd5cadcf2][ivy-switch-buffer]]              |                                 | [[#56fcff3b-ffd9-4280-a226-4b58558906b8][move cursor top bottom mid]]    |                          |
  | ;               | [[#150bef9a-3faa-4c72-a176-88c3be56f612][comment-dwim]]                   | [[#211e76d9-d89a-4cc6-abce-69397d456fda][comment-dwim]]                    | [[#17035e1e-bbe6-44a6-ad54-6a39b04feac3][comment-current-line-dwim]]     |                          |
  | m               |                                |                                 | [[#9a6a1998-4ed6-485e-9b2d-c36a42d7ec1a][recursive grep]]                |                          |
  | ,               | [[#e4f617b2-d3f1-47e4-ae7f-2d64c4fd47b9][counsel-find-file]]              |                                 | [[#e0691924-11e1-48d2-abee-27945a409676][find-file-in-project]]          |                          |
  | .               | [[#6e97b7f1-c5cf-48bb-9c09-db1950dc1eae][recentf-ido-find-file]]          |                                 | [[#824d422c-67b6-4d68-af11-6a2135e528f5][-]]                             |                          |
  | /               | [[#941a7fa8-84b9-434d-89a0-1487385ec479][join lines]]                     |                                 | [[#37f67593-4f60-4d3b-9aad-6c9bc4882443][copy-variable]]                 |                          |
  | 8               | [[#45644cfa-d408-4a69-a97a-545ef46ba656][calc-embedded-word]]             |                                 |                               |                          |
  | up-arrow        | [[#2dade04a-8ac7-483c-8675-5268af6eca2b][back defun/headline]]            |                                 |                               | [[#572d6618-471a-43c7-8a50-3f5e56f45cd7][winner undo]]              |
  | down-arrow      | [[#a1f25c12-3523-45bd-9bf5-62bf3cd5ca43][forward dfun/headline]]          |                                 | [[#57a09286-94c6-4b9f-953a-7368743f95ec][toggle-mark-activation]]        | [[#9c87093b-7e30-44fb-83c9-c1b176074a5d][smex-major-mode-commands]] |
  | lbracket        | [[#9d9916dd-3280-47dd-aab1-cd28d5ebfe15][----]]                           |                                 | [[#c10b53e9-657c-48f4-8afb-cad0e709bcd6][scroll-right]]                  |                          |
  | rbracket        | [[#21b38c6b-3a46-4a08-8eca-d44abb148287][fill-paragraph]]                 |                                 | [[#095c3d97-bc49-419a-a8c0-c7a21d46d980][scroll-left]]                   |                          |
  | return          | [[#db6e4c41-c048-4bef-b0c9-e129464c056d][newline next line]]              | [[#10b2591a-5628-46ee-b395-682e91efcb83][non-indented newline]]            | [[#1fc4f025-719f-4866-a9ab-23b30e4581b1][open newline on previous line]] |                          |
  | space           | [[#b7d5a893-3045-4968-a150-cb813fddfe9e][org-edit-special]]               |                                 | [[#47b5912e-edc7-42ec-841b-f0e202b7f593][spell check word]]              |                          |
  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  | left secondary  | C-                             | M-                              | C-M-                          | C-S-                     |
  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  | =               |                                |                                 |                               |                          |
  | 1               |                                |                                 |                               |                          |
  | 4               |                                |                                 | [[#2d4de3c9-9e0c-4ab4-89e3-e41bfed3c9a7][widen]]                         |                          |
  | 5               |                                |                                 |                               |                          |
  | tab-key         | [[#2f527321-7f78-421b-b0c4-6fc810da0246][query-replace]]                  |                                 |                               |                          |
  | t               | [[#3bcdf4a3-f33c-4dad-ba94-e4fd3775eca6][org change todo state]]          |                                 | [[#47c64b9c-346d-45ad-8c38-865fe22d31a6][org insert timestamp]]          |                          |
  | home            | [[#1919659a-b466-4519-9276-8bf06a916066][start of buffer]]                |                                 |                               |                          |
  | end             | [[#0a7bd629-cbcc-4761-8fe2-cc9370b985a4][end of buffer]]                  |                                 |                               |                          |
  | f9              |                                |                                 |                               |                          |
  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  | right secondary | C-                             | M-                              | C-M-                          | C-S-                     |
  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  | 6               | [[#e44e584b-d925-4036-9ad5-a90d02e74bef][save-buffers-kill-emacs]]        |                                 | [[#da73de75-0914-4f48-81d5-9b408433b14b][insert-small-copyright]]        |                          |
  | 7               |                                |                                 | [[#a68c6b8e-9911-475e-ab35-e239771fe881][insert-full-copyright]]         |                          |
  | 0               | [[#96ae2fcc-3a0c-40c4-aef8-06aff3fd42be][text-scale-reset]]               |                                 | [[#0e7f83a5-600e-4016-af98-95904300c016][insert-apache]]                 |                          |
  | -               |                                |                                 | [[#6febc7ea-9cc7-488c-af34-538b8e69633b][org-edit-src-exit]]             |                          |
  | y               | [[#97aee7f1-3647-4602-a65a-45e8a3aa3a7c][undo-tree-redo]]                 |                                 |                               |                          |
  | \               | [[#69005926-08ab-4adc-a163-44fed609cc95][sr-speedbar-toggle]]             |                                 | [[#27045e96-59a3-45b4-b0ff-6247aa5ed47e][mark-defun]]                    |                          |
  | h               | [[#3c5f241f-fc62-459d-ab85-6b7c1fb04801][help-prefix]]                    |                                 |                               |                          |
  | '               | [[#9f252721-a2d5-46c6-b268-8ed597256229][eval-expression]]                |                                 |                               |                          |
  | n               | [[#65ac9206-1a67-48dc-8b72-26d763d7bf2b][unpop-to-mark-command]]          |                                 | [[#34fb8fbd-42dc-46b0-8c3c-c7e51edc9687][narrow-to-region]]              |                          |
  | rshift          |                                |                                 |                               |                          |
  | escape          | [[#da8bae21-a7be-45de-8027-1b26e6285e40][find-tag]]                       |                                 |                               |                          |
  |-----------------+--------------------------------+---------------------------------+-------------------------------+--------------------------|
  #+END:

* persistent registers
This needs to be at the end, because I visit a file, thus setting a
mode, and the mode hook needs to be setup before that.

I'm using persistent registers instead of bookmarks. I dun use them
much, so the added hassle of having to set it within this file is
worth the benefit of only having one concept in my mind.
#+begin_src emacs-lisp
  (dolist
      (r `(
      (?i (file . ,"~/.emacs.d/my-init.org"))
      (?t (file . ,"/a/x.txt"))
           ))
    (set-register (car r) (cadr r)))
#+end_src

* keybind notes
common keys, which would be better off doing swaps than rebinds:
c-x prefix -> c-s
c-c prefix -> c-d
yank c-y -> c-c
search c-s -> kp-add
kill line c-k -> c-f
undo c-_ -> c-z
set-mark-command c-@ -> kp-enter
quoted-insert c-q -> c-m-q
recenter-top-bottom c-l -> c-m-3
kill-region c-w -> c-x

commands to make less accessible
narrow-to-defun/subtree -> M-2 maybe
occur

command to make more accessible, ...


* misc useful functions I'd rather have in a list than burried
#+begin_src emacs-lisp :tangle no
;; these are usefull with (goto-char)
;; find named entity, other than headline
(org-find-entry-with-id "string-number-or-symbol")

(org-find-exact-headline-in-buffer "heading" nil t)

(byte-recompile-file (expand-file-name "~/.emacs.d/my-init.el") t 0)
(byte-recompile-directory (expand-file-name "~/.emacs.d") 0)
(byte-recompile-directory (expand-file-name "~/.emacs.d/src/haskell-mode") 0)

;; remove any indent level which is throughout the buffer
(org-do-remove-indentation)

#+end_src

* TESTING / DEVELOPMENT AREA

** new
#+begin_src emacs-lisp


#+end_src

** key logging
this article convinced me that trying to experiment with modal editing is a waste.
http://chrisdone.com/posts/speculations-on-exclusive-editing
I want to record my emacs commands simply to find optimiaztions, like if I often do some M-x command and should bind it
to a key.


#+begin_src emacs-lisp :tangle no

(setq keylog-list nil)
(setq keylog-mode nil)

(defun keylog-save ()

  ;; Check that the lock file does not exist
  (when (keyfreq-file-is-unlocked)
    ;; Lock the file
    (keyfreq-file-claim-lock)

    ;; Check that we have the lock
    (if (eq (keyfreq-file-owner) (emacs-pid))
(unwind-protect
(progn
;; Load values and merge them with the current keyfreq-table
(keyfreq-table-load table)

;; Write the new frequencies
(with-temp-file keyfreq-file
(prin1 (cdr (keyfreq-list table 'no-sort)) (current-buffer))))

;; Release the lock and reset the hash table.
(keyfreq-file-release-lock)
(clrhash table))
      )))

(defun my-keylogger-function ()
  (setq keylog-list (cons (list (current-time) current-prefix-arg this-command) keylog-list)))
(add-hook 'pre-command-hook 'my-keylogger-function)

#+end_src

in a lisp expression, ;  \\[ throws off forward-sexp
when not in emacs lisp mode,
even with (with-syntax-table emacs-lisp-mode-syntax-table
forward-sexp)
which is found in preceding-sexp
potentially a bug, either in with-syntax-table, or
in scan-lists, which is implemented in C




why did it go to the init file?
change EDITOR to emacsclient
xserver-xorg-core=2:1.14.3-3ubuntu2
(setq-default header-line-format nil) ; Copy mode-line
(setq-default mode-line-format nil) ;


#+RESULTS:
: set-food-completions



useless gnus group keys:
a
c


(add-to-list 'load-path "~/.emacs.d/emacs/site-lisp/org")

#+begin_src emacs-lisp
  (add-hook 'org-mode-hook
            (lambda () (define-key org-mode-map (kbd "C-y") nil)))

#+end_src




(defun comint-send-string (process string)
  "Like `process-send-string', but also does extra bookkeeping for Comint mode."
  (if process
      (with-current-buffer (if (processp process)
                               (process-buffer process)
                             (get-buffer process))
        (comint-snapshot-last-prompt))
    (comint-snapshot-last-prompt))
  (process-send-string process string))


* python
todo: get smart-operator to work
todo, checkout https://github.com/python-rope/ropemacs refactoring python,
todo, try py-autopep8, autoformatter
todo, check out some python linting stuff. pychecker is one, others are in *packages*
todo, finish reading through python-mode.el functions
;; todo, figure out multi-line input in shell mode


usefull m-x commands:
m-x py-describe-mode: doc for mode which is extensive
m-x py-sort-imports
m-x py-guess-indent-offset: setup indent for code i didn't write

possibly usefull commands:
found via looking through python-mode.el, quit like 1/4 through, cuz its tedious, last spot was at:
(defun py-comment-region (beg end &optional arg)
after finding py-describe-mode, it seemed to do a good job of documenting all the most important stuff

py-switch-to-python
python-shell-completion-complete-or-indent may be usefull to get completion working in the shell
py-insert-default-shebang
py-electric-*
py-indent-line-outmost
py-newline-and-close-block
py-indent-and-forward (indent line, move to next)
py-fill-*
py-which-function (for showing in the modeline)
py-help-at-point
py-execute-import-or-reload
py-execute-def-or-class
various pdb functions


installing jedi
#+begin_src sh :tangle no
pi python-pip
s pip install jedi virtualenv
#+end_src
then do m-x jedi:install-server



disabled because it takes 152 ms to load,
and I don't know how to do it conditioally
#+begin_src emacs-lisp :tangle no

;; change from default python3 to be compatibile with Pywikibot
(setq py-shell-name "/usr/bin/python")
(require 'python-mode)

(setq py-autopep8-options '("--max-line-length=110"))

(defun py-execute-block-or-clause-create-shell ()
  (interactive)
  (cond ((get-buffer "*Python*")
         (py--execute-prepare "block-or-clause")
         (py-execute-block-or-clause)
         (call-interactively 'next-line))
        (t
         (py-shell)
         ;; py-shell starts the shell but not display the buffer on the first run
         ;; subsequent runs, it does. I grabbed this command from inside to
         ;; do just the relevant part from the second run, as a hack.
         ;; todo: report a bug on this
         (py--shell-manage-windows py-buffer-name))))
(setq py-tab-shifts-region-p t)
(setq py-tab-indents-region-p t)

(defun py-run ()
  "default action to run the current buffer"
  (basic-save-buffer)
  (py-execute-buffer))


(add-hook 'python-mode-hook
          (lambda ()
            (setq run-fun 'py-run)
            (define-key python-mode-map (kbd "C-M-a") nil)
            (define-key python-mode-map (kbd "C-M-d") nil)
            (define-key python-mode-map (kbd "C-M-e") nil)
            (define-key python-mode-map (kbd "C-M-h") nil)
            (define-key python-mode-map (kbd "C-M-i") nil)
            (define-key python-mode-map (kbd "C-M-u") nil)
            (define-key python-mode-map (kbd "C-M-x") nil)
            (define-key python-mode-map (kbd "<tab>") 'indent-for-tab-command)
            (define-key python-mode-map (kbd "C-j") nil)
            (define-key python-mode-map (kbd "<C-backspace>") nil)
            ;;(define-key python-mode-map (kbd "C-(") (lambda () (interactive) (basic-save-buffer) (py-execute-buffer)))
            ;; fix default return bindings
            (define-key python-mode-map (kbd "C-j") nil)
            (define-key python-mode-map (kbd "RET") nil)
            (define-key python-mode-map (kbd "<return>") 'py-newline-and-indent)
            (define-key python-mode-map (kbd "<M-tab>") 'py-indent-line)
            (define-key python-mode-map (kbd "C-M-(") 'py-shift-left)
            (define-key python-mode-map (kbd "C-M-)") 'py-shift-right)
            (define-key python-mode-map (kbd "<home>") 'py-beginning-of-line)
            (define-key python-mode-map (kbd "<end>") 'py-end-of-line)
            (define-key python-mode-map (kbd "C-t") 'py-execute-block-or-clause-create-shell)
            (define-key python-mode-map (kbd "<S-delete>") 'py-ian-execute-line-or-region)
            ;; python mode adds these to this list, which is normally empty.
            ;; it makes my send-python function not reuse an existing python shell window
            ;; there are other ways to override this, but I don't know of any other value of
            ;; having this set.
            (setq same-window-buffer-names (delete "*Python*" same-window-buffer-names))
            (setq same-window-buffer-names (delete "*IPython*" same-window-buffer-names))))

;; i dunno, why, but this didn't work:
;; and we can't eval-after-load cuz it is part of the greater python mode file
(add-hook 'py-shell-hook
          (lambda ()
            (define-key py-shell-map "\r" nil)
            (define-key py-shell-map (kbd "<return>") 'comint-send-input)
            (define-key py-shell-map (kbd "C-t") 'py-shell-toggle-arrow-keys)
            (define-key py-shell-map "\C-d" nil)
            (define-key py-shell-map (kbd "<up>") 'my-comint-previous-input)
            (define-key py-shell-map (kbd "<down>") 'my-comint-next-input)))


(defun py-ian-execute-line-or-region ()
  (interactive)
  (cond ((get-buffer "*Python*")
         (if mark-active
             (py-execute-region)
           (py-execute-statement))
         (call-interactively 'next-line))
        (t (py-shell))))

;; http://tkf.github.io/emacs-jedi/latest/
(add-hook 'python-mode-hook 'jedi:setup)
(setq jedi:complete-on-dot t)

(defun py-shell-toggle-arrow-keys ()
  (interactive)
  (toggle-arrow-keys py-shell-map))

#+end_src


;; py-shell window stuff
;; it splits the window if the shell is in a different frame
;; which seems to be a bug, but it can be fixed with this option
;; (setq py-keep-windows-configuration 'force)
;; however, with py-execute-block-or-clause, if the shell is in a different frame,
;; you get errors "buffer is read only", when the point is near the beginning of a command
;; todo: test with emacs -Q and file a bug
;; if you execute py-execute-... without a python shell open,
;; it starts one, doesn't display it, and subsequent py-execute commands
;; give error "buffer is read only"
;; these functions fix / improve these problems


** initial python-mode setup

python-mode seems to be the most canonical package, based on
https://docs.python.org/devguide/emacs.html
much more feature rich than the emacs built in one.

getting it, it wants you to setup an account on launchpad by default,
there is some way to get anonymous bzr access, but google didn't answer it right away,
so fuck it, ill go the happy path.

based on error messages,
add public ssh key to https://launchpad.net/people/+me
bzr launchpad-login iank
cd  ~/.emacs.d/src/
bzr branch lp:python-mode

add lines from INSTALL to init


** background on packages
jedi appears most popular based on github stats
pysmell appears dead
ac-python appears dead
https://github.com/proofit404/anaconda-mode seems to be kicking along


** misc notes:

python-mode has a TON of functions that are just aliases or verbatim wrappers of other functions.
also has undocumented/unused vars all around. it is quite annoying.

the dedicated argument to py-shell does nothing,
and py-dedicated-shell just sets that, so it is a waste


** background on sending to python shell

using the builtin python execute shell functions, sending one line doesn't really work well.
The bulit in functions don't wait for further input if a block is not closed.
And doing a copy/paste thing gets messed up because of indents.
With some hacking, I could probably do copy/paste and remove indents, only to a
certain level if we have entered a block and are waiting to finish it.
But just doing the builtin execute block is a decent work around.


Here is the scrapped function for single line built in sending to shell.


(setq w32-enable-num-lock nil)
(global-set-key (kbd "<num_lock>") 'left-char)


(defun sqlup-find-correct-keywords ()
  "If emacs is handling the logic for syntax highlighting of SQL keywords, then we piggyback on top of that logic. If not, we use an sql-mode function to create a list of regular expressions and use that."
    (mapcar 'car (sql-add-product-keywords sql-product '())))


largest subarray sum, array of pos and neg ints.