" .vimrc (vim auto-parse file) -- commands that vim runs at startup
" v2.0

"# version 4.0          " avoid warning for wrong version

" *** Mappings ***
" == Fixes ==
" don't make it easy to quit without checking for changes
nmap ZQ <nop>


" == Random ==
map Q gq
imap <C-Z> <C-O><C-Z>
imap <C-L> <C-O><C-L>
nmap <silent> g/ :nohlsearch<CR>
xmap <silent> g/ :<C-U>nohlsearch<CR>gv
" not useful
"# nmap <silent> g<C-L> :redrawstatus<CR>

" Make the Do key bring up the ex command prompt:
nmap <F10> :
xmap <F10> :
imap <F10> <C-O>:

nmap <Esc><C-Z> <C-Z>
vmap <Esc><C-Z> <C-Z>


" == Command shortcut keys ==
" (note: <C-F1> doesn't work in gnome-terminal!)
" <C-F1> through to <C-F4> (and <S-F1> through to <S-F4>)
" don't work in vim.  This was tried but doesn't work:
"# cmap <Esc>O1;2S <S-F4>

" -- list all buffers --
" <C-F2>
imap <Esc>O1;5Q <C-O>:ls<CR>
nmap <Esc>O1;5Q :ls<CR>
xmap <Esc>O1;5Q :<C-U>ls<CR>gv
imap <Esc>[1;5Q <C-O>:ls<CR>
nmap <Esc>[1;5Q :ls<CR>
xmap <Esc>[1;5Q :<C-U>ls<CR>gv

" -- previous buffer --
nmap <silent> [b :bprevious<CR>
xmap <silent> [b :<C-U>bprevious<CR>
imap <silent> <F1> <C-O>:bprevious<CR>
nmap <silent> <F1> :bprevious<CR>
xmap <silent> <F1> :<C-U>bprevious<CR>
" <S-F1> splits the window
if $TERM == 'linux'
  imap <silent> <Esc>[25~ <C-O>:sbprevious<CR>
  nmap <silent> <Esc>[25~ :sbprevious<CR>
  xmap <silent> <Esc>[25~ :<C-U>sbprevious<CR>
elseif $TERM == 'putty'
  imap <silent> <Esc>[23~ <C-O>:sbprevious<CR>
  nmap <silent> <Esc>[23~ :sbprevious<CR>
  xmap <silent> <Esc>[23~ :<C-U>sbprevious<CR>
else
  imap <silent> <Esc>O1;2P <C-O>:sbprevious<CR>
  nmap <silent> <Esc>O1;2P :sbprevious<CR>
  xmap <silent> <Esc>O1;2P :<C-U>sbprevious<CR>
  imap <silent> <Esc>[1;2P <C-O>:sbprevious<CR>
  nmap <silent> <Esc>[1;2P :sbprevious<CR>
  xmap <silent> <Esc>[1;2P :<C-U>sbprevious<CR>
endif
" -- next buffer --
nmap <silent> ]b :bnext<CR>
xmap <silent> ]b :<C-U>bnext<CR>
imap <silent> <F2> <C-O>:bnext<CR>
nmap <silent> <F2> :bnext<CR>
xmap <silent> <F2> :<C-U>bnext<CR>
" <S-F2> splits the window
if $TERM == 'linux'
  imap <silent> <Esc>[26~ <C-O>:sbnext<CR>
  nmap <silent> <Esc>[26~ :sbnext<CR>
  xmap <silent> <Esc>[26~ :<C-U>sbnext<CR>
elseif $TERM == 'putty'
  imap <silent> <Esc>[24~ <C-O>:sbnext<CR>
  nmap <silent> <Esc>[24~ :sbnext<CR>
  xmap <silent> <Esc>[24~ :<C-U>sbnext<CR>
else
  imap <silent> <Esc>O1;2Q <C-O>:sbnext<CR>
  nmap <silent> <Esc>O1;2Q :sbnext<CR>
  xmap <silent> <Esc>O1;2Q :<C-U>sbnext<CR>
  imap <silent> <Esc>[1;2Q <C-O>:sbnext<CR>
  nmap <silent> <Esc>[1;2Q :sbnext<CR>
  xmap <silent> <Esc>[1;2Q :<C-U>sbnext<CR>
endif
" -- this buffer --
" <C-S-F1> splits the window
nmap <silent> <Esc>O1;6P :split<CR>
xmap <silent> <Esc>O1;6P :<C-U>split<CR>gv
imap <silent> <Esc>O1;6P <C-O>:split<CR>
nmap <silent> <Esc>[1;6P :split<CR>
xmap <silent> <Esc>[1;6P :<C-U>split<CR>gv
imap <silent> <Esc>[1;6P <C-O>:split<CR>
nmap <silent> <C-S-F1> :split<CR>
xmap <silent> <C-S-F1> :<C-U>split<CR>gv
imap <silent> <C-S-F1> <C-O>:split<CR>

" -- window switching --
imap <F3> <C-O><C-W>k
nmap <F3> <C-W>k
xmap <F3> <C-W>k
imap <F4> <C-O><C-W>j
nmap <F4> <C-W>j
xmap <F4> <C-W>j

" -- window resizing --
" <S-F3>
if $TERM == 'linux'
  imap <Esc>[28~ <C-O><C-W>-
  nmap <Esc>[28~ <C-W>-
  xmap <Esc>[28~ <C-W>-
elseif $TERM == 'putty'
  imap <Esc>[25~ <C-O><C-W>-
  nmap <Esc>[25~ <C-W>-
  xmap <Esc>[25~ <C-W>-
else
  imap <Esc>O1;2R <C-O><C-W>-
  nmap <Esc>O1;2R <C-W>-
  xmap <Esc>O1;2R <C-W>-
  imap <Esc>[1;2R <C-O><C-W>-
  nmap <Esc>[1;2R <C-W>-
  xmap <Esc>[1;2R <C-W>-
endif

" <S-F4>
if $TERM == 'linux'
  imap <Esc>[29~ <C-O><C-W>+
  nmap <Esc>[29~ <C-W>+
  xmap <Esc>[29~ <C-W>+
elseif $TERM == 'putty'
  imap <Esc>[26~ <C-O><C-W>+
  nmap <Esc>[26~ <C-W>+
  xmap <Esc>[26~ <C-W>+
else
  imap <Esc>O1;2S <C-O><C-W>+
  nmap <Esc>O1;2S <C-W>+
  xmap <Esc>O1;2S <C-W>+
  imap <Esc>[1;2S <C-O><C-W>+
  nmap <Esc>[1;2S <C-W>+
  xmap <Esc>[1;2S <C-W>+
endif

" -- window closing --
" <C-F3> -- close all other windows
imap <C-F3> <C-O><C-W>o
nmap <C-F3> <C-W>o
xmap <C-F3> <C-W>ogv
imap <Esc>O1;5R <C-O><C-W>o
nmap <Esc>O1;5R <C-W>o
xmap <Esc>O1;5R <C-W>ogv
imap <Esc>[1;5R <C-O><C-W>o
nmap <Esc>[1;5R <C-W>o
xmap <Esc>[1;5R <C-W>ogv
" (PuTTY has no key code)

" <C-F4> -- close this window
imap <C-F4> <C-O><C-W>c
nmap <C-F4> <C-W>c
xmap <C-F4> <C-W>c
imap <Esc>O1;5S <C-O><C-W>c
nmap <Esc>O1;5S <C-W>c
xmap <Esc>O1;5S <C-W>c
imap <Esc>[1;5S <C-O><C-W>c
nmap <Esc>[1;5S <C-W>c
xmap <Esc>[1;5S <C-W>c
" (PuTTY has no key code)

" <C-S-F4>
imap <Esc>O1;6S <C-O>:bunload<CR>
nmap <Esc>O1;6S :bunload<CR>
xmap <Esc>O1;6S :<C-U>bunload<CR>gv
imap <Esc>[1;6S <C-O>:bunload<CR>
nmap <Esc>[1;6S :bunload<CR>
xmap <Esc>[1;6S :<C-U>bunload<CR>gv

" -- file operations --
nmap <silent> ZE :edit<CR>
nmap <silent> ZW :write<CR>
nmap ZN :wnext<CR>

" -- QuickFix commands (mostly error-jumps) --
nmap [e :cprevious<CR>
xmap [e :<C-U>cprevious<CR>gv
nmap <F6> :cprevious<CR>
xmap <F6> :<C-U>cprevious<CR>gv
imap <F6> <C-O>:cprevious<CR>
nmap [E :cpfile<CR>
nmap <C-S-F6> :cpfile<CR>

nmap ]e :cnext<CR>
xmap ]e :<C-U>cnext<CR>gv
nmap <F7> :cnext<CR>
xmap <F7> :<C-U>cnext<CR>gv
imap <F7> <C-O>:cnext<CR>
nmap ]E :cnfile<CR>
nmap <C-S-F7> :cnfile<CR>

" normal-mode shortcuts for various build-related commands
nmap ZM :make<CR>
nmap <F9> :make<CR>
nmap <C-F9> :clist<CR>
cmap <C-F9> :clist<CR>
imap <C-F9> <C-O>:clist<CR>
nmap <S-F9> :setlocal makeprg=
imap <S-F9> <C-O>:setlocal makeprg=
nmap <C-S-F9> :colder<CR>
imap <C-S-F9> <C-O>:colder<CR>

" -- tab switching --
nmap <M-PageUp>   gT
xmap <M-PageUp>   gT
imap <M-PageUp>   <C-O>gT
nmap <S-Tab> gT
xmap <S-Tab> gT
nmap <M-PageDown> gt
xmap <M-PageDown> gt
imap <M-PageDown> <C-O>gt

nmap <Esc>1 1gt
nmap <Esc>2 2gt
nmap <Esc>3 3gt
nmap <Esc>4 4gt
nmap <Esc>5 5gt
nmap <Esc>6 6gt
nmap <Esc>7 7gt
nmap <Esc>8 8gt
nmap <Esc>9 9gt
nmap <Esc>0 10gt
nmap <M-Home> :tabfirst<CR>
xmap <M-Home> :<C-U>tabfirst<CR>
imap <M-Home> <C-O>:tabfirst<CR>
nmap <M-End> :tablast<CR>
xmap <M-End> :<C-U>tablast<CR>
imap <M-End> <C-O>:tablast<CR>

if exists('*function')
  " can't use <expr> because that can't handle a count
  " have to use the <C-U> to avoid passing the count to :call
  nmap <silent> g<Tab> :<C-U>call JumpBetweenTabs(v:count)<CR>
  xmap <silent> g<Tab> :<C-U>call JumpBetweenTabs(v:count)<CR>

  let g:previous_tab = 1
  " When no count is supplied, switch to the previous tab where this function
  " was called.  When a count is supplied, act like "gt".
  " (Note that "gt" effectively forgets the current tab, so afterwards, this
  " function without a count will go back to the previous-previous tab.)
  function! JumpBetweenTabs(count)
    if a:count > 0
      let g:previous_tab = tabpagenr()
      exe ":tabn" a:count
    else
      " have to figure things out first, because :exe must happen last
      let l:new_tab = g:previous_tab
      let g:previous_tab = tabpagenr()
      exe ":tabn" l:new_tab
    endif
  endfunction
endif

" -- toggles --
imap <silent> <F8> <C-O>:silent set wrap!<CR>
nmap <silent> <F8> :silent set wrap!<CR>
xmap <silent> <F8> :<C-U>silent set wrap!<CR>gv

if $TERM == 'linux'
  imap <Esc>[34~ <C-O>:setlocal spell! spell?<CR>
  nmap <Esc>[34~ :setlocal spell! spell?<CR>
  xmap <Esc>[34~ :<C-U>setlocal spell! spell?<CR>gv
else
  imap <S-F8> <C-O>:setlocal spell! spell?<CR>
  nmap <S-F8> :setlocal spell! spell?<CR>
  xmap <S-F8> :<C-U>setlocal spell! spell?<CR>gv
endif

imap <C-F8> <C-O>:set ignorecase! ignorecase?<CR>
nmap <C-F8> :set ignorecase! ignorecase?<CR>
xmap <C-F8> :<C-U>set ignorecase! ignorecase?<CR>gv
imap <C-S-F8> <C-O>:set hlsearch! hlsearch?<CR>
nmap <C-S-F8> :set hlsearch! hlsearch?<CR>
xmap <C-S-F8> :<C-U>set hlsearch! hlsearch?<CR>gv

imap <silent> <S-F10> <C-O>:set number!<CR>
nmap <silent> <S-F10> :set number!<CR>

imap <silent> <C-F10> <C-O>:if &diff \| :diffoff \| :else \| :diffthis \| :endif<CR>
nmap <silent> <C-F10> :if &diff \| :diffoff \| :else \| :diffthis \| :endif<CR>

imap <silent> <C-S-F10> <C-O>:set list!<CR>
nmap <silent> <C-S-F10> :set list!<CR>
xmap <silent> <C-S-F10> :<C-U>set list!<CR>

" -- other --


" == customisations ==
if exists('*function')
  " Jump to the start of the line if not already there, otherwise jump to the
  " first non-blank character.
  imap <silent> <C-B>  <C-O>:call LineBeg()<CR>
  function! LineBeg()
    if getcurpos()[4] == 1
       normal ^
     else
       normal 0
     endif
   endfunction
else
  imap <C-B> <C-O>0
endif
imap <C-E> <C-O>$
imap <C-D> <Del>
" Replacement for original binding of <C-D>, namely deindent (orthogonal to <C-T>)
inoremap <S-Tab> <C-D>
" Alt-d deletes next word:
imap <M-d> <Space><Right><S-Right><C-W><BS>

" Ctrl-Left (Alt-b) & Ctrl-Right (Alt-f) go to previous/next word respectively:
inoremap <M-b> <S-Left>
inoremap <M-f> <S-Right>
cnoremap <M-b> <S-Left>
cnoremap <M-f> <S-Right>
map  <M-b> B
map  <M-f> W

" Operator-pending and Visual mode, but not Select mode
nmap  <Space> <PageDown>
omap  <Space> <PageDown>
xmap  <Space> <PageDown>


" == Editing ==
" -- Special deletion/insertion --
" Capitalise word (cursor at start) -- see also g@ and 'operatorfunc' below
nmap <Leader>w gUllguww
" Delete current line and send it to the "blackhole" register instead of a numbered register
nmap <Leader>d "_dd
" Delete all lines of the visual selection and send it to the "blackhole"
" register instead of a numbered register
xmap <Leader>d "_d

" -- Parenthesise --
nmap <Leader>pw  ciw(<C-r><C-o>")<ESC>
nmap <Leader>ps  cis(<C-r><C-o>")<ESC>
nmap <Leader>pb  cab(<C-r><C-o>")<ESC>
nmap <Leader>pB  caB(<C-r><C-o>")<ESC>
xmap <Leader>p c(<C-r><C-o>")<ESC>


" == Strings ==
" Insert basename of current buffer's file
" (Note that this makes a delay before the regular Ctrl-X options show up)
"# imap <C-X>% <C-R>=expand("%:t")<CR>
inoremap <expr> <C-X>% expand("%:t")
" Wait for a register name, then insert the contents converted to lowercase
" (c_CTRL-R_CTRL-L is taken)
noremap! <expr> <C-R><C-D> tolower(getreg(nr2char(getchar())))
" Wait for a register name, then insert the contents converted to uppercase
noremap! <expr> <C-R><C-U> toupper(getreg(nr2char(getchar())))

" Timestamp with attribution
" (E.g. "2021-09-14 15:25 by Alastair Irvine <alastair@warpspace.net>")
nmap <silent> <Leader>t :r!date "+\%Y-\%m-\%d \%H:\%M by ${REPLYTO-`getent passwd $LOGNAME <bar> awk -F : '{ pos = index($5, ","); if (pos > 0) print substr($5, 1, pos-1); else print $5 }'`}"<CR>:normal -J<CR>

" List items (Uses :put to get around auto-indent for subsequent line items.
" Doesn't work with i_^O .)
nmap <Leader>il :put ='  + '<CR>A
nmap <Leader>iL :put ='      - '<CR>A
nmap <Leader>in :put ='  1. '<CR>A
nmap <Leader>iN :put ='      1. '<CR>A

" -- At EOF --
nmap <silent> <Leader>it G:put =\"\n\n# vim: set noexpandtab :\n# Local Variables:\n# indent-tabs-mode: t\n# end:\"<CR>
nmap <silent> <Leader>i2 G:put =\"\n\n# vim: set tabstop=2 shiftwidth=2 :\n# Local Variables:\n# tab-width: 2\n# end:\"<CR>
nmap <silent> <Leader>i4 G:put =\"\n\n# vim: set tabstop=4 shiftwidth=4 :\n# Local Variables:\n# tab-width: 4\n# end:\"<CR>
nmap <silent> <Leader>ia G:put =\"\n\n# vim: set filetype=apache :\n# Local Variables:\n# mode: apache\n# end:\"<CR>


" == other ==
" Yank function name and parens into 'a
nmap <Leader>f lb"ayf(;%"Ayl
" Append a comma plus the text from the next movement onto 'b
nnoremap <silent> <Leader>, :let @b = @b . ','<CR>"By
vnoremap <silent> <Leader>, :let @b = @b . ','<CR>"By
" Yank file name into '0
" (@" represents the unnamed register and '0)
nmap <silent> <Leader>y     :let @" = bufname()<CR>

" -- Useful searching commands --
map  <F5> /
imap <F5> <C-O>/
if $TERM == 'linux'
  nmap <Esc>[31~ ?
  imap <Esc>[31~ <C-O>?
else
  nmap <S-F5> ?
  imap <S-F5> <C-O>?
endif
nmap <C-F5> n
imap <C-F5> <C-O>n
nmap <C-S-F5> N
imap <C-S-F5> <C-O>N

" -- Search for Martians --
" search for non-printing characters [Ctrl-/ (or ^_, i.e. Ctrl-shift--)]
nmap <silent> <C-_> :call search('[^][{};:''",.<>/?a-zA-Z!@#$%^&*()_+\|0-9\\\-=`~ <Tab>]')<CR>
" search for whitespace at EOL [Ctrl-space (or ^@, i.e. Ctrl-shift-2)]
nmap <silent> <Nul> :call search('[[:space:]]$')<CR>
xmap <silent> <Nul> :<C-U>call search('[[:space:]]$')<CR>gv

nmap <silent> <Leader>mn :call search('[[:space:]]$')<CR>
xmap <silent> <Leader>mn :<C-U>call search('[[:space:]]$')<CR>gv
nmap <silent> <Leader>mN :%s/[[:space:]]\+$//<CR>
" This will apply to the selection
xmap <silent> <Leader>mN :s/[[:space:]]\+$//<CR>
nmap <silent> <Leader>mt :call search('\t')<CR>
xmap <silent> <Leader>mt :<C-U>call search('\t')<CR>gv


" == UI commands ==
" open a tab with a new buffer
nmap g<C-N> :tabedit<CR>
" open a new window vertically with a new buffer
nmap g<C-V> :vnew<CR>
" open a tab with the current buffer
nmap g<C-T> :tab split<CR>
" C-S-F2: list tabs & buffers
nmap <Esc>O1;6Q :tabs<CR>
xmap <Esc>O1;6Q :<C-U>tabs<CR>gv
imap <Esc>O1;6Q <C-O>:tabs<CR>
nmap <Esc>[1;6Q :tabs<CR>
xmap <Esc>[1;6Q :<C-U>tabs<CR>gv
imap <Esc>[1;6Q <C-O>:tabs<CR>
nmap <C-S-F2> :tabs<CR>
xmap <C-S-F2> :<C-U>tabs<CR>gv
imap <C-S-F2> <C-O>:tabs<CR>

nmap <Leader>a  :ls!<CR>
xmap <Leader>a  :<C-U>:ls!<CR>gv

nmap <Leader>b  :echo BufInfo()<CR>
xmap <Leader>b  :<C-U>echo BufInfo()\|:silent sleep 2.5<CR>gv

nmap <Leader>g  :digraphs<CR>
xmap <Leader>g  :<C-U>:digraphs<CR>gv

nmap <Leader>r  :registers<CR>
xmap <Leader>r  :<C-U>:registers<CR>gv
nnoremap <Leader>R :echo "Type the name of a register: "<Bar> :exe ":registers" nr2char(getchar())<CR>

" -- information --
nmap <Leader>va  :set autoindent?<CR>
xmap <Leader>va  :<C-U>set autoindent?\|:silent sleep 2<CR>gv
nmap <Leader>vb  :set tabstop?<CR>
xmap <Leader>vb  :<C-U>set tabstop?\|:silent sleep 2<CR>gv
nmap <Leader>vc  :set smartcase?<CR>
xmap <Leader>vc  :<C-U>set smartcase?\|:silent sleep 2<CR>gv
nmap <Leader>ve  :set expandtab?<CR>
xmap <Leader>ve  :<C-U>set expandtab?\|:silent sleep 2<CR>gv
nmap <Leader>vf  :set fileformat?<CR>
xmap <Leader>vf  :<C-U>set fileformat?\|:silent sleep 2<CR>gv
nmap <Leader>vh  :set hlsearch?<CR>
xmap <Leader>vh  :<C-U>set hlsearch?\|:silent sleep 2<CR>gv
nmap <Leader>vi  :set ignorecase?<CR>
xmap <Leader>vi  :<C-U>set ignorecase?\|:silent sleep 2<CR>gv
nmap <Leader>vl  :set endofline?<CR>
xmap <Leader>vl  :<C-U>set endofline?\|:silent sleep 2<CR>gv
nmap <Leader>vm  :set makeprg?<CR>
xmap <Leader>vm  :<C-U>set makeprg?\|:silent sleep 2<CR>gv
nmap <Leader>vn  :set fileencoding?<CR>
xmap <Leader>vn  :<C-U>set fileencoding?\|:silent sleep 2<CR>gv
nmap <Leader>vo  :set foldmethod?<CR>
xmap <Leader>vo  :<C-U>set foldmethod?\|:silent sleep 2<CR>gv
nmap <Leader>vp  :set paste?<CR>
xmap <Leader>vp  :<C-U>set paste?\|:silent sleep 2<CR>gv
nmap <Leader>vq  :set textwidth?<CR>
xmap <Leader>vq  :<C-U>set textwidth?\|:silent sleep 2<CR>gv
nmap <Leader>vr  :set runtimepath?<CR>
xmap <Leader>vr  :<C-U>set runtimepath?\|:silent sleep 2<CR>gv
nmap <Leader>vs  :set shiftwidth?<CR>
xmap <Leader>vs  :<C-U>set shiftwidth?\|:silent sleep 2<CR>gv
nmap <Leader>vt  :set filetype?<CR>
xmap <Leader>vt  :<C-U>set filetype?\|:silent sleep 2<CR>gv
nmap <Leader>vv  :set viminfofile?<CR>
xmap <Leader>vv  :<C-U>set viminfofile?\|:silent sleep 2<CR>gv
nmap <Leader>vw  :set wrap?<CR>
xmap <Leader>vw  :<C-U>set wrap?\|:silent sleep 2<CR>gv
nmap <Leader>vA  :abbr<CR>
xmap <Leader>vA  :<C-U>:abbr<CR>
nmap <Leader>vM  :map <LT>buffer><CR>
xmap <Leader>vM  :<C-U>:map <LT>buffer><CR>

" -- Misc UI stuff --
" Clear the popup and the message pane
" (or set g:netrw_use_errorwindow=1)
nmap <Leader><Leader> :call popup_clear() \| :echo<CR>


" == ex command prompt ==
cmap <F6> <S-Tab>
cmap <F7> <Tab>


" == terminal window running a shell ==
if has('terminal')
  map g<C-S> :tab terminal<CR>
  map gS :terminal<CR>

  " -- :term mappings --
  "# tmap <M-PageUp> <C-W>NgT
  "# tmap <M-PageDown> <C-W>Ngt
  tmap <Esc>[5;3~ <C-W>NgT
  tmap <Esc>[6;3~ <C-W>Ngt
  "# tmap <M-Home> <C-W>:tabfirst<CR>
  "# tmap <M-End>  <C-W>:tablast<CR>
  tmap <Esc>[1;3H <C-W>:tabfirst<CR>
  tmap <Esc>[1;3F <C-W>:tablast<CR>
  " For some reason, C-Up/Down are sent as regular Up/Down by default
  tnoremap <C-Up> <Esc>[1;5A
  tnoremap <C-Down> <Esc>[1;5B
endif


" == Settings toggles, etc. ==
" <C-F11> doesn't exist due to 'pastetoggle'
" <S-F9> and above don't exist when $TERM == 'linux'
nmap <S-F11> :set textwidth=
xmap <S-F11> :<C-U>set textwidth=
imap <S-F11> <C-O>:set textwidth=
nmap <C-S-F11> :set textwidth=0<CR>
xmap <C-S-F11> :<C-U>set textwidth=0<CR>gv
imap <C-S-F11> <C-O>:set textwidth=0<CR>
imap <F12> <C-O>:set expandtab! expandtab?<CR>
nmap <F12> :set expandtab! expandtab?<CR>
xmap <F12> :<C-U>set expandtab! expandtab?<CR>gv
imap <C-F12> <C-O>:set autoindent! autoindent?<CR>
nmap <C-F12> :set autoindent! autoindent?<CR>
xmap <C-F12> :<C-U>set autoindent! autoindent?<CR>gv
imap <silent> <S-F12> <C-O>:silent set readonly!<CR>
nmap <silent> <S-F12> :silent set readonly!<CR>
xmap <silent> <S-F12> :<C-U>silent set readonly!<CR>gv
if exists('*function')
  nmap <silent> <C-S-F12> :call Mousetoggle()<CR>
  xmap <silent> <C-S-F12> :<C-U>call Mousetoggle()<CR>gv
  imap <silent> <C-S-F12> <C-O>:call Mousetoggle()<CR>
  function! Mousetoggle()
    if &mouse == '' || &mouse == 'hr'
      let s:old_mouse = &mouse
      set mouse=a
    else
      let &mouse = s:old_mouse
    endif
  endfunction
endif

" -- Other options --
nmap <Leader>zfm  :setlocal foldmethod=marker<CR>
nmap <Leader>zfe  :setlocal foldmethod=expr<CR>
nmap <Leader>zfs  :setlocal foldmethod=syntax<CR>
" See also .vim/after/ftplugin/xml.vim

" -- Tweaks --
nmap <Leader>zn   :set nocursorline<CR>
nmap <Leader>zc   :colorscheme mine<CR>
nmap <Leader>zs   :set selection=exclusive<CR>


" == File operations ==
nmap <Leader>x  :!chmod +x "%"<CR>
nmap <Leader>n  :!mkdir "%:h"<CR>
nmap <Leader>h  :pwd<CR>
xmap <Leader>h  :<C-U>pwd\|:silent sleep 2.5<CR>gv
nmap <Leader>c  :!md5sum "%"<CR>

" -- Source control --
" \sd opens a diff window
nmap <Leader>sa         :!smooth add "%"<CR>
nmap <Leader>sc         :!smooth commit<CR>
nmap <Leader>sC         :!smooth commit .<CR>
nmap <Leader>sd         <C-W>n:set ft=diff \| .!smooth diff<CR>:set nomodified<CR>
nmap <Leader>sD         <C-W>n:set ft=diff \| .!smooth diff -s<CR>:set nomodified<CR>
nmap <Leader>ss         :!smooth status "%"<CR>
nmap <Leader>sS         <C-W>n:set ft=git  \| .!smooth status<CR>:set nomodified<CR>
nmap <Leader>sl         <C-W>n:set ft=git  \| .!git log --oneline --graph<CR>:set nomodified<CR>
nmap <Leader>sL         <C-W>n:set ft=git  \| .!git log --stat<CR>:set nomodified<CR>
nmap <Leader>s<C-L>     <C-W>n:set ft=git  \| .!git log --patch<CR>:set nomodified<CR>


" *** Features ***
if has('syntax')
  " -- settings --
  set background=dark

  if exists(':filetype')
    filetype plugin indent on
    let g:filetype_i = "c"
    let g:filetype_inc = "php"
  endif

  " -- activation --
  syntax enable

  " -- customisation --
  "# let mysyntaxfile = "~/.vim/mysyntax.vim"   " my customised syntax highlights
  " See .vim/colors/mine.vim
  colorscheme mine
endif

if has('spell')
  set spelllang=en_au
endif

" Provides :Man <page>
runtime ftplugin/man.vim


" == diff ==
nmap <C-F6> [c
xmap <C-F6> [c
imap <C-F6> <C-O>[c
nmap <C-F7> ]c
xmap <C-F7> ]c
imap <C-F7> <C-O>]c


" == spell ==
if $TERM == 'linux'
  imap <Esc>[32~ <C-O>[s
  nmap <Esc>[32~ [s
  xmap <Esc>[32~ [s
  imap <Esc>[33~ <C-O>]s
  nmap <Esc>[33~ ]s
  xmap <Esc>[33~ ]s
else
  imap <S-F6> <C-O>[s
  nmap <S-F6> [s
  xmap <S-F6> [s
  imap <S-F7> <C-O>]s
  nmap <S-F7> ]s
  xmap <S-F7> ]s
endif


" == netrw ("Explore") ==
let g:netrw_sort_sequence='[\/]$,\<core\%(\.\d\+\)\=\>,README,\.h$,\.c$,\.cpp$,*,\.o$,\.obj$,\.info$,\.sw.$,\.bak$,\~$'
"# let g:netrw_use_errorwindow=1

nmap <silent> <C-W>e :Sexplore<CR>
nmap <silent> <C-W>V :Vexplore<CR>
nmap <silent> <C-W>E :Texplore<CR>
nmap <silent> g<C-O> :if exists('w:netrw_rexdir') <CR>:Rexplore <CR>:else <CR>:Explore <CR>:endif<CR>

nmap <Leader>e<C-E> :Explore ~<CR>
nmap <Leader>ee     :Explore<CR>
nmap <Leader>eE     :exe ":Explore" getcwd()<CR>

nmap <Leader>e<C-S> :Sexplore ~<CR>
nmap <Leader>es     :Sexplore<CR>
nmap <Leader>eS     :exe ":Sexplore" getcwd()<CR>

nmap <Leader>e<C-V> :Vexplore ~<CR>
nmap <Leader>ev     :Vexplore<CR>
nmap <Leader>eV     :exe ":Vexplore" getcwd()<CR>

nmap <Leader>e<C-T> :Texplore ~<CR>
nmap <Leader>et     :Texplore<CR>
nmap <Leader>eT     :exe ":Texplore" getcwd()<CR>

nmap <Leader>e<C-L> :Lexplore ~<CR>
nmap <Leader>el     :Lexplore<CR>
nmap <Leader>eL     :exe ":Lexplore" getcwd()<CR>

nmap <Leader>e<C-R> :Lexplore! ~<CR>
nmap <Leader>er     :Lexplore!<CR>
nmap <Leader>eR     :exe ":Lexplore!" getcwd()<CR>

nmap <Leader>en :Nexplore<CR>
nmap <Leader>ep :Pexplore<CR>


" == Packages ==
if has('packages')
  packadd! matchit
else
  runtime! macros/matchit.vim
  " TO-DO: package equivlents for taglist, etc.
endif


" *** Functions ***
if exists('*function')
  " :Rename
  runtime include/rename4.vim
  " :BDE
  runtime include/bde.vim


  " Eat one character matching the given regex from the input stream, e.g. at
  " the end of an abbr expansion.
  " E.g. `:iabbr <silent> if if ()<Left><C-R>=Eatchar('\s')<CR>`
  function! Eatchar(pat)
    let c = nr2char(getchar(0))
    return (c =~ a:pat) ? '' : c
  endfunction


  " A block is a set of hunks applying to a given file
  function! DiffBlock(extra_flags)
    "# call search('^\*\*\* [^0-9]', 's' . a:extra_flags)
    " diff -c, svn diff, git diff respectively
    " (Can't do diff -u because that only uses --- / +++ which is ambiguous with
    " the others)
    if search('^\*\*\* [^0-9]\|^Index: \|^diff ', 's' . a:extra_flags) == 0
      " This doesn't work
      let v:warningmsg = "No more diff blocks"
    endif
  endfunction


  function! BufInfo()
    let flags1 = getbufvar('%', '&modifiable') ?
                   \ (getbufvar('%', '&readonly') ? '=' : ' ') : '-'
    let flags2 = getbufvar('%', '&mod') ? '+' : ' '
    if exists('*bufwinid')
      let id = bufwinid('%')
    else
      let id = -1
    endif
    let name = bufname('%')
    if name == ''
      let name = '[No Name]'
    endif
    return printf("%d (%d, %d [%d])\t%s  \"%s\"",
           \      bufnr("%"), id, bufwinnr("%"), tabpagenr(), flags1 . flags2, name)
  endfunction
endif


" *** Commands ***
if exists('*function')
  " Do a word-diff of two files
  command! -nargs=+ -complete=file Wdiff :call Wdiff("<args>")
  function! Wdiff(args)
    new
    set ft=wdiff
    exe '.!wdiff ' . a:args
    set nomodified
  endfunction


  " Diffs a file in source control with its working copy
  command! -nargs=1 -complete=file Diff :call Diff("<args>")
  function! Diff(args)
    new
    set ft=diff
    exe '.!smooth diff "' . a:args . '"'
    set nomodified
  endfunction


  " Convenient command to see the difference between the current buffer and the
  " file it was loaded from, thus the changes you made.
  " Only define it when not defined already.
  " Revert with: ":delcommand DiffOrig".
  " (From /usr/share/vim/vim82/defaults.vim)
  if !exists(":DiffOrig")
    command DiffOrig vert new | set bt=nofile | r ++edit # | 0d_ | diffthis
        \ | wincmd p | diffthis
  endif
endif


" *** Settings ***
set formatprg=
set nobackup         " don't keep a backup file
set viminfo='100,<900,s10,h

set nowrap sidescroll=1
set scrolloff=0
set ruler hidden laststatus=2 showcmd
"# set confirm   " unknown in Vim 5.0
set foldclose=             " Automatic foldclosing is irritating too

" Default is shortmess=filnxtToOS
set shortmess=filtoOrmw

set selection=exclusive   " unknown in Vim 5.0; used to work in ???; back in 6.x

set nohlsearch
set noincsearch
set smartcase    " Override the 'ignorecase' option if the search pattern contains upper case characters

" Help buffers and hit-enter and more-prompt prompts only
"# set mouse=a
set mouse=hr
set mousemodel=popup_setpos
set mousetime=180

" Selection (<S-Left> etc. starts type-to-replace selection mode)
set selectmode=key
set keymodel=startsel   " Don't use "stopsel" because that breaks Visual mode

" Disable default: autoselect,exclude:cons\|linux
set clipboard=

" -- windows --
set splitbelow

" -- editing --
set bs=indent,eol,start       " allow backspacing over everything in insert mode
set autoindent

set textwidth=0

set expandtab
"# set tabstop=2
set shiftwidth=1
set shiftround                " > and < round indent to multiple of 'shiftwidth'
set showfulltag
"# set smartindent

set pastetoggle=<F11>
let maplocalleader = '_'

" For g@
if exists('*function')
  set operatorfunc=Capitalise
  " Delete whatever was typed and replace it with the sentence-case version
  function! Capitalise(context)
    " If in Visual mode, '[ and '] are set to '< and '> before this function
    " is called, however '] is one char behind when &selection == 'exclusive'

    " Delete the text so the unnamed register can be modified and re-inserted later
    if a:context == 'block'
      throw "Capitalise() doesn't work in Visual block mode"
    elseif a:context == 'line'
      normal! '[d']
    else
      " '] is at the end of the movement not beyond it, so d'] doesn't work
      " properly (inconsistent with gu etc.); it will always be one character
      " short and not work at all for a single-character motion.  Use Visual
      " mode to fake the inclusive motion.
      let l:visual_start_save = getpos("'<")
      let l:visual_end_save = getpos("'>")
      let l:sel_save = &selection
      let &selection = "inclusive"

      normal! `[v`]d

      call setpos("'<", l:visual_start_save)
      call setpos("'>", l:visual_end_save)
      let &selection = l:sel_save
    endif

    " @@ represents the unnamed register
    let @@ = substitute(tolower(@@), '\<\(.\)', '\=toupper(submatch(1))', 'g')
    normal! P
  endfunction
endif

" -- contextual --
set iskeyword=-,@,48-57,_,192-255
" remove "=" from the list of filename characters
set isfname-==

" -- file --
" See 'fo-table'
set formatoptions-=o formatoptions+=n
if v:version >= 801
  set formatoptions+=p
endif
set modeline

set fileformats=unix,dos,mac

" -- other --
set titleold=Terminal


" == Bram Moolenaar's preferences ==
" /usr/share/vim/vim82/defaults.vim (overridden by /etc/vim/vimrc or /etc/vimrc)
set wildmenu            " display completion matches in a status line

" Do not recognize octal numbers for Ctrl-A and Ctrl-X, most users find it
" confusing.
set nrformats-=octal

" CTRL-U in insert mode deletes a lot.  Use CTRL-G u to first break undo,
" so that you can undo CTRL-U after inserting a line break.
" Revert with ":iunmap <C-U>".
inoremap <C-U> <C-G>u<C-U>


" == Turn off defaults ==
" -- Bram's vimStartup group --
" (When editing a file, always jump to the last known cursor position.)
augroup vimStartup
  autocmd!
augroup END

" -- RedHat defaults --
" See /etc/vimrc
augroup redhat
  autocmd!
augroup END


" *** Buffer auto commands ***
augroup mine
  " -- From /etc/vimrc on RedHat --
  " don't write swapfile on most commonly used directories for NFS mounts or USB sticks
  autocmd BufNewFile,BufReadPre /media/*,/run/media/* set directory=~/tmp,/var/tmp,/tmp
  " start with spec file template
  autocmd BufNewFile *.spec 0r $HOME/.vim/templates/template.spec
augroup END


" *** Misc ***
runtime include/abbrevs.vim

" -- digraphs --
if has('digraphs')
  digraphs a` 224
endif

" -- Git support --
match ErrorMsg '^\(<\|=\|>\)\{7\}\([^=].\+\)\?$'


" *** Fixups ***
" == Terminal ==


" *** Extensibility ***
if exists('*filereadable') && exists('$ZONE')
  " source the zone-specific rc file, if it exists
  let s:zone_rc_file = $HOME . "/.init/Zones/" . $ZONE . "/vimrc"
  if filereadable(s:zone_rc_file)
    execute "source" s:zone_rc_file
  endif
endif