" Vimball Archiver by Charles E. Campbell, Jr., Ph.D.
UseVimball
finish
plugin/HiCurLine.vim	[[[1
366
" HiCurLine : an attempt to highlight matching brackets as one moves
"  Author:  Charles E. Campbell, Jr.
"  Date:    May 20, 2009
"  Version: 8a	ASTRO-ONLY
"
" A Vim v6.0 plugin with menus for gvim
"
" GetLatestVimScripts: 555 1 :AutoInstall: HiCurLine.vim
" GetLatestVimScripts: 1066 1 cecutil.vim
" Usage: {{{1
"   \hcli : initialize highlighting of matching bracket
"   \hcls : stop       highlighting of matching bracket
"
"   Actually <Leader> is used, so you may set mapleader to change
"   the leading backslash to whatever you want in your <.vimrc>
"
" Method: {{{1
"	This script attempts to intercept most motion commands
"   and to to use the "match" command to highlight the current
"   line.  The HL_HiCurLine variable may be set by the user
"   to any highlighting group.  If no such variable is set,
"   then the Search highlighting group will be used.  Any
"   maps already assigned to the motion command keys will be
"   saved by \hcli and restored by \hcls.
"
"     Example: (of something that could be put into a <.vimrc>)
"       hi HL_HiCurLine ctermfg=blue ctermbg=cyan guifg=blue guibg=cyan
"		let HL_HiCurLine= "HL_HiCurLine"

" ---------------------------------------------------------------------
" Load Once: {{{1
if &cp || exists("g:loaded_HiCurLine")
 finish
endif
let s:keepcpo= &cpo
set cpo&vim
let g:loaded_HiCurLine= "v8a"
if exists("g:himtchbrkt_ut") && !exists("g:hicurline_ut")
 let g:hicurline_ut= g:himtchbrkt_ut
endif
if v:version >= 700 && exists("##CursorMoved")
 let g:loaded_matchparen= 1
endif

" ---------------------------------------------------------------------
" Public Interface: {{{1
if !hasmapto('<Plug>HCLStart')
 map <unique> <Leader>hcli	<Plug>HCLStart
endif
if !hasmapto('<Plug>HCLStop')
 map <unique> <Leader>hcls	<Plug>HCLStop
endif
if !hasmapto('<Plug>HCLToggle')
 map <unique> <Leader>hclt	<Plug>HCLToggle
endif
com! HCLstart   set lz|call <SID>HCLStart()|set nolz
com! HCLstop    set lz|call <SID>HCLStop()|set nolz
com! HCL        set lz|call <SID>HCLToggle()|set nolz

" ---------------------------------------------------------------------
" Global Maps: {{{2
nmap <silent> <unique> <script> <Plug>HCLStart  :set lz<CR>:call <SID>HCLStart()<CR>:set nolz<CR>
nmap <silent> <unique> <script> <Plug>HCLStop   :set lz<CR>:call <SID>HCLStop()<CR>:set nolz<CR>
nmap <silent> <unique> <script> <Plug>HCLToggle :set lz<bar>if exists("b:dohicurline")<bar>call <SID>HCLStop()<bar>else<bar>call <SID>HCLStart()<bar>endif<bar>set nolz<CR>

" ---------------------------------------------------------------------
" DrChip Menu Support: {{{2
if has("menu") && has("gui_running") && &go =~ 'm'
 if !exists("g:DrChipTopLvlMenu")
  let g:DrChipTopLvlMenu= "DrChip."
 endif
 exe 'menu '.g:DrChipTopLvlMenu.'HiCurLine.Start<tab>\\hcli	<Leader>hcli'
endif

" =====================================================================
" Functions: {{{1

" HCLStart: {{{2
fun! <SID>HCLStart()
"  call Dfunc("HCLStart()")
  if exists("b:dohicurline")
"   call Dret("HCLStart : b:dohicurline already exists!")
   return
  endif

  " set up highlighting group for current line
  call s:HCLHighlight()
  augroup HCL_AUGROUP
    au!
    au FocusGained	*	silent call <SID>HCLHighlight()
  augroup END

  if !exists("g:hicurline_nocursorhold") && (!exists("g:hicurline_ut") || g:hicurline_ut != 0)
"   call Decho("set up HCL_AUGROUP (CursorHold,FocusGained) events")
   augroup HCLTimer
    au!
    au CursorHold *	silent call s:HCLHighlight()
    au CursorHold * silent call s:HiCurLine()
   augroup END
  endif

  if exists("b:dohicurline") && b:dohicurline == 1
    " already in HiCurLine mode
    echo "[HiCurLine]"
"    call Dret("HCLStart : already in HiCurLine mode")
    return
  endif
  let b:dohicurline= 1
 
  " Save Maps (if any)
  call SaveUserMaps("n","","<c-b>","HiCurLine")
  call SaveUserMaps("n","","<c-d>","HiCurLine")
  call SaveUserMaps("n","","<c-f>","HiCurLine")
  call SaveUserMaps("n","","<c-u>","HiCurLine")
  call SaveUserMaps("n","","<down>","HiCurLine")
  call SaveUserMaps("n","","<end>","HiCurLine")
  call SaveUserMaps("n","","<home>","HiCurLine")
  call SaveUserMaps("n","","<left>","HiCurLine")
  call SaveUserMaps("n","","<right>","HiCurLine")
  call SaveUserMaps("n","","<up>","HiCurLine")
  call SaveUserMaps("n","","webHMLEBjklh-+G","HiCurLine")
  call SaveUserMaps("i","","<down>","HiCurLine")
  call SaveUserMaps("i","","<end>","HiCurLine")
  call SaveUserMaps("i","","<home>","HiCurLine")
  call SaveUserMaps("i","","<left>","HiCurLine")
  call SaveUserMaps("i","","<right>","HiCurLine")
  call SaveUserMaps("i","","<up>","HiCurLine")
  if has("gui_running") && has("menu")
   call SaveUserMaps("n","","<leftmouse>","HiCurLine")
   call SaveUserMaps("i","","<leftmouse>","HiCurLine")
   call SaveUserMaps("i","","<CR>","HiCurLine")
  endif
 
  " keep and set options
  let b:hicurline_vbkeep      = &vb
  let b:hicurline_t_vbkeep    = &t_vb
  let b:hicurline_utkeep      = &ut
  set vb t_vb=
  if exists ("g:hicurline_ut")
   let &ut= g:hicurline_ut
  else
   " I'd like to set ut even faster, but unfortunately that clears
   " status-line messages before people have a chance to read them
   set ut=2000
  endif
 
  " indicate in HiCurLine mode
  echo "[HiCurLine]"
 
  " Install HiCurLine maps
  if has("gui_running")
   call HCLMapper("<down>" , "<down>" , "<down>")
   call HCLMapper("<up>"   , "<up>"   , "<up>")
   call HCLMapper("<right>", "<right>", "<right>")
   call HCLMapper("<left>" , "<left>" , "<left>")
   call HCLMapper("<home>" , "<home>" , "<home>")
   call HCLMapper("<end>"  , "<end>"  , "<end>")
   call HCLMapper("<space>", "<space>", "")
   call HCLMapper("<cr>"   , "<cr>"   , "<cr>")
  else
   call HCLMapper("<down>"    , "j"    , "<c-o>j"    )
   call HCLMapper("<up>"      , "k"    , "<c-o>k"    )
   call HCLMapper("<right>"   , "l"    , "<c-o>l"    )
   call HCLMapper("<left>"    , "h"    , "<c-o>h"    )
   call HCLMapper("<home>"    , "0"    , "<c-o>0"    )
   call HCLMapper("<end>"     , "$"    , "<c-o>$"    )
   call HCLMapper("<space>"   , "l"    , ""          )
   call HCLMapper("<PageUp>"  , "<c-b>", "<c-o><c-b>")
   call HCLMapper("<PageDown>", "<c-f>", "<c-o><c-f>")
  endif
  if has("gui_running") && has ("mouse")
   call HCLMapper("<leftmouse>","<leftmouse>","<leftmouse>")
  endif
  call HCLMapper("gg", "gg", "")
  call HCLMapper("G" , "G" , "")
  call HCLMapper("w","w","")
  call HCLMapper("b","b","")
  call HCLMapper("B","B","")
  call HCLMapper("e","e","")
  call HCLMapper("E","E","")
  call HCLMapper("H","H","")
  call HCLMapper("M","M","")
  call HCLMapper("L","L","")
  call HCLMapper("j","j","")
  call HCLMapper("k","k","")
  call HCLMapper("l","l","")
  call HCLMapper("h","h","")
  call HCLMapper("%","%","")
  call HCLMapper("-","-","")
  call HCLMapper("+","+","")
  call HCLMapper("<c-f>","<c-f>","")
  call HCLMapper("<c-b>","<c-b>","")
  call HCLMapper("<c-d>","<c-d>","")
  call HCLMapper("<c-u>","<c-u>","")
 
  " Insert stop  HiCurLine into menu
  " Delete start HiCurLine from menu
  if has("gui_running") && has("menu")
   exe 'unmenu '.g:DrChipTopLvlMenu.'HiCurLine.Start'
   exe 'menu '.g:DrChipTopLvlMenu.'HiCurLine.Stop<tab>\\hcls	<Leader>hcls'
  endif
 
  " highlight the current line
  silent call s:HiCurLine()

"  call Dret("HCLStart")
endfun

" ---------------------------------------------------------------------
" HCLStop: {{{2
fun! <SID>HCLStop()
"  call Dfunc("HCLStop()")

  if !exists("b:dohicurline")
"   call Dret("HCLStop : b:dohicurline doesn't exist")
   return
  endif


  " delete the dohicurline variable
  " remove any match
  " remove CursorHold autocmd event
  match none
  augroup HCLTimer
   au!
  augroup END
  silent! augroup! HCLTimer
  augroup HCL_AUGROUP
    au!
  augroup END
  silent! augroup! HCL_AUGROUP

  if !exists("b:dohicurline")
   echo "[HiCurLine off]"
"   call Dfunc("HCLStop : already off")
   return
  else
  unlet b:dohicurline
  endif

  echo "[HiCurLine off]"

  " restore user map(s), if any
  call RestoreUserMaps("HiCurLine")

  " restore user options
  let &vb   = b:hicurline_vbkeep
  let &t_vb = b:hicurline_t_vbkeep
  let &ut   = b:hicurline_utkeep
  unlet b:hicurline_vbkeep
  unlet b:hicurline_t_vbkeep
  unlet b:hicurline_utkeep

  " Insert start HiCurLine into menu
  " Delete stop  HiCurLine from menu
  if has("gui_running") && has("menu")
   exe 'unmenu '.g:DrChipTopLvlMenu.'HiCurLine.Stop'
   exe 'menu '.g:DrChipTopLvlMenu.'HiCurLine.Start<tab>\\hcli	<Leader>hcli'
  endif
"  call Dfunc("HCLStop")
endfun

" ---------------------------------------------------------------------
" HCLMapper: handles mapping the left-hand-side string to {{{2
"  the normal-mode right-hand-side (nrhs) and
"  the insert-mode right-hand-side (irhs).
"  Retains any previously existing maps to these sequences.
fun! HCLMapper(lhs,nrhs,irhs)
"  call Dfunc("HCLMapper(.lhs<".a:lhs."> nrhs<".a:nrhs."> irhs<".a:irhs.">)")

  " overload normal mode mapping
  let rhs= maparg(a:lhs,"n")
"  call Decho("rhs<".rhs.">")
  if rhs == "" | let rhs= a:nrhs | endif
  exe "nno <silent> ".a:lhs." ".rhs.":silent call <SID>HiCurLine()<CR>"
"  call Decho("exe nno <silent> ".a:lhs." ".rhs.":silent call <SID>HiCurLine()<CR>")

  if a:irhs != ""
  " overload insert mode mapping
   let rhs= maparg(a:lhs,"i")
"   call Decho("rhs<".rhs.">")
   if rhs == "" | let rhs= a:irhs | endif
   exe "ino <silent> ".a:lhs." ".rhs."<c-o>:silent call <SID>HiCurLine()<CR>"
"   call Decho("exe ino <silent> ".a:lhs." ".rhs."<c-o>:silent call <SID>HiCurLine()<CR>")
  endif
"  call Dret("HCLMapper")
endfun

" ---------------------------------------------------------------------
" HiCurLine: {{{2
fun! <SID>HiCurLine()
  if exists("b:dohicurline")
   " just making sure that a match isn't activated by a CursorHold
   " after HiCurLine has been "turned off"
   let curline   = line('.')
"   call Dfunc("HiCurLine() curline#".curline)
   exe 'match '.g:HL_HiCurLine.' /\%'.curline.'l/'
"   call Dret("HiCurLine")
  endif
endfun

" ---------------------------------------------------------------------
" HCLHighlight: sets up HL_HiCurLine highlighting {{{2
fun! s:HCLHighlight()
"  call Dfunc("HCLHighlight()")

  if !exists("g:HL_HiCurLine")
   let g:HL_HiCurLine= "HL_HiCurLine"
  endif
  if g:HL_HiCurLine == "HL_HiCurLine" && !s:HLTest("HL_HiCurLine")
   if &bg == "dark"
    hi HL_HiCurLine ctermfg=blue ctermbg=cyan guifg=cyan guibg=blue
   else
    hi HL_HiCurLine ctermbg=blue ctermfg=cyan guibg=cyan guifg=blue
   endif
  endif

"  call Dret("HCLHighlight : g:HL_HiCurLine<".g:HL_HiCurLine.">")
endfun

" ---------------------------------------------------------------------
" HLTest: tests if a highlighting group has been set up {{{2
fun! s:HLTest(hlname)
"  call Dfunc("HLTest(hlname<".a:hlname.">)")

  let id_hlname= hlID(a:hlname)
"  call Decho("hlID(".a:hlname.")=".id_hlname)
  if id_hlname == 0
"   call Dret("HLTest 0")
   return 0
  endif

  let id_trans = synIDtrans(id_hlname)
"  call Decho("id_trans=".id_trans)
  if id_trans == 0
"   call Dret("HLTest 0")
   return 0
  endif

  let fg_hlname= synIDattr(id_trans,"fg")
  let bg_hlname= synIDattr(id_trans,"bg")
"  call Decho("fg_hlname<".fg_hlname."> bg_hlname<".bg_hlname.">")

  if fg_hlname == "" && bg_hlname == ""
"   call Dret("HLTest 0")
   return 0
  endif
"  call Dret("HLTest 1")
  return 1
endfun

" ---------------------------------------------------------------------
"  Auto Startup With HiCurLineOn: {{{1
if exists("g:HiCurLineOn") && g:HiCurLineOn != 0
 if !exists("*SaveUserMaps")
  " due to loading order, <plugin/cecutil.vim> may not have loaded yet.
  " attempt to force a load now.  Ditto for matchit!
  silent! runtime plugin/cecutil.vim
 endif
 silent! runtime plugin/matchit.vim
 silent HCLstart
endif

let &cpo= s:keepcpo
" ---------------------------------------------------------------------
"  vim: fdm=marker
plugin/cecutil.vim	[[[1
510
" cecutil.vim : save/restore window position
"               save/restore mark position
"               save/restore selected user maps
"  Author:	Charles E. Campbell, Jr.
"  Version:	18c	ASTRO-ONLY
"  Date:	May 20, 2009
"
"  Saving Restoring Destroying Marks: {{{1
"       call SaveMark(markname)       let savemark= SaveMark(markname)
"       call RestoreMark(markname)    call RestoreMark(savemark)
"       call DestroyMark(markname)
"       commands: SM RM DM
"
"  Saving Restoring Destroying Window Position: {{{1
"       call SaveWinPosn()        let winposn= SaveWinPosn()
"       call RestoreWinPosn()     call RestoreWinPosn(winposn)
"		\swp : save current window/buffer's position
"		\rwp : restore current window/buffer's previous position
"       commands: SWP RWP
"
"  Saving And Restoring User Maps: {{{1
"       call SaveUserMaps(mapmode,maplead,mapchx,suffix)
"       call RestoreUserMaps(suffix)
"
" GetLatestVimScripts: 1066 1 :AutoInstall: cecutil.vim
"
" You believe that God is one. You do well. The demons also {{{1
" believe, and shudder. But do you want to know, vain man, that
" faith apart from works is dead?  (James 2:19,20 WEB)

" ---------------------------------------------------------------------
" Load Once: {{{1
if &cp || exists("g:loaded_cecutil")
 finish
endif
let g:loaded_cecutil = "v18c"
let s:keepcpo        = &cpo
set cpo&vim
"DechoTabOn

" =======================
"  Public Interface: {{{1
" =======================

" ---------------------------------------------------------------------
"  Map Interface: {{{2
if !hasmapto('<Plug>SaveWinPosn')
 map <unique> <Leader>swp <Plug>SaveWinPosn
endif
if !hasmapto('<Plug>RestoreWinPosn')
 map <unique> <Leader>rwp <Plug>RestoreWinPosn
endif
nmap <silent> <Plug>SaveWinPosn		:call SaveWinPosn()<CR>
nmap <silent> <Plug>RestoreWinPosn	:call RestoreWinPosn()<CR>

" ---------------------------------------------------------------------
" Command Interface: {{{2
com! -bar -nargs=0 SWP	call SaveWinPosn()
com! -bar -nargs=0 RWP	call RestoreWinPosn()
com! -bar -nargs=1 SM	call SaveMark(<q-args>)
com! -bar -nargs=1 RM	call RestoreMark(<q-args>)
com! -bar -nargs=1 DM	call DestroyMark(<q-args>)

if v:version < 630
 let s:modifier= "sil "
else
 let s:modifier= "sil keepj "
endif

" ===============
" Functions: {{{1
" ===============

" ---------------------------------------------------------------------
" SaveWinPosn: {{{2
"    let winposn= SaveWinPosn()  will save window position in winposn variable
"    call SaveWinPosn()          will save window position in b:cecutil_winposn{b:cecutil_iwinposn}
"    let winposn= SaveWinPosn(0) will *only* save window position in winposn variable (no stacking done)
fun! SaveWinPosn(...)
"  call Dfunc("SaveWinPosn() a:0=".a:0)
  if line(".") == 1 && getline(1) == ""
"   call Dfunc("SaveWinPosn : empty buffer")
   return ""
  endif
  let so_keep   = &l:so
  let siso_keep = &siso
  let ss_keep   = &l:ss
  setlocal so=0 siso=0 ss=0

  let swline    = line(".")
  let swcol     = col(".")
  let swwline   = winline() - 1
  let swwcol    = virtcol(".") - wincol()
  let savedposn = "call GoWinbufnr(".winbufnr(0).")|silent ".swline
  let savedposn = savedposn."|".s:modifier."norm! 0z\<cr>"
  if swwline > 0
   let savedposn= savedposn.":".s:modifier."norm! ".swwline."\<c-y>\<cr>"
  endif
  if swwcol > 0
   let savedposn= savedposn.":".s:modifier."norm! 0".swwcol."zl\<cr>"
  endif
  let savedposn = savedposn.":".s:modifier."call cursor(".swline.",".swcol.")\<cr>"

  " save window position in
  " b:cecutil_winposn_{iwinposn} (stack)
  " only when SaveWinPosn() is used
  if a:0 == 0
   if !exists("b:cecutil_iwinposn")
   	let b:cecutil_iwinposn= 1
   else
   	let b:cecutil_iwinposn= b:cecutil_iwinposn + 1
   endif
"   call Decho("saving posn to SWP stack")
   let b:cecutil_winposn{b:cecutil_iwinposn}= savedposn
  endif

  let &l:so = so_keep
  let &siso = siso_keep
  let &l:ss = ss_keep

"  if exists("b:cecutil_iwinposn")	 " Decho
"   call Decho("b:cecutil_winpos{".b:cecutil_iwinposn."}[".b:cecutil_winposn{b:cecutil_iwinposn}."]")
"  else                      " Decho
"   call Decho("b:cecutil_iwinposn doesn't exist")
"  endif                     " Decho
"  call Dret("SaveWinPosn [".savedposn."]")
  return savedposn
endfun

" ---------------------------------------------------------------------
" RestoreWinPosn: {{{2
"      call RestoreWinPosn()
"      call RestoreWinPosn(winposn)
fun! RestoreWinPosn(...)
"  call Dfunc("RestoreWinPosn() a:0=".a:0)
"  call Decho("getline(1)<".getline(1).">")
"  call Decho("line(.)=".line("."))
  if line(".") == 1 && getline(1) == ""
"   call Dfunc("RestoreWinPosn : empty buffer")
   return ""
  endif
  let so_keep   = &l:so
  let siso_keep = &l:siso
  let ss_keep   = &l:ss
  setlocal so=0 siso=0 ss=0

  if a:0 == 0 || a:1 == ""
   " use saved window position in b:cecutil_winposn{b:cecutil_iwinposn} if it exists
   if exists("b:cecutil_iwinposn") && exists("b:cecutil_winposn{b:cecutil_iwinposn}")
"   	call Decho("using stack b:cecutil_winposn{".b:cecutil_iwinposn."}<".b:cecutil_winposn{b:cecutil_iwinposn}.">")
	try
     exe "silent! ".b:cecutil_winposn{b:cecutil_iwinposn}
	catch /^Vim\%((\a\+)\)\=:E749/
	 " ignore empty buffer error messages
	endtry
    " normally drop top-of-stack by one
    " but while new top-of-stack doesn't exist
    " drop top-of-stack index by one again
	if b:cecutil_iwinposn >= 1
	 unlet b:cecutil_winposn{b:cecutil_iwinposn}
	 let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
	 while b:cecutil_iwinposn >= 1 && !exists("b:cecutil_winposn{b:cecutil_iwinposn}")
	  let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
	 endwhile
	 if b:cecutil_iwinposn < 1
	  unlet b:cecutil_iwinposn
	 endif
	endif
   else
   	echohl WarningMsg
	echomsg "***warning*** need to SaveWinPosn first!"
	echohl None
   endif

  else	 " handle input argument
"   call Decho("using input a:1<".a:1.">")
   " use window position passed to this function
   exe "silent ".a:1
   " remove a:1 pattern from b:cecutil_winposn{b:cecutil_iwinposn} stack
   if exists("b:cecutil_iwinposn")
    let jwinposn= b:cecutil_iwinposn
    while jwinposn >= 1                     " search for a:1 in iwinposn..1
        if exists("b:cecutil_winposn{jwinposn}")    " if it exists
         if a:1 == b:cecutil_winposn{jwinposn}      " and the pattern matches
       unlet b:cecutil_winposn{jwinposn}            " unlet it
       if jwinposn == b:cecutil_iwinposn            " if at top-of-stack
        let b:cecutil_iwinposn= b:cecutil_iwinposn - 1      " drop stacktop by one
       endif
      endif
     endif
     let jwinposn= jwinposn - 1
    endwhile
   endif
  endif

  " Seems to be something odd: vertical motions after RWP
  " cause jump to first column.  The following fixes that.
  " Note: was using wincol()>1, but with signs, a cursor
  " at column 1 yields wincol()==3.  Beeping ensued.
  if virtcol('.') > 1
   silent norm! hl
  elseif virtcol(".") < virtcol("$")
   silent norm! lh
  endif

  let &l:so   = so_keep
  let &l:siso = siso_keep
  let &l:ss   = ss_keep

"  call Dret("RestoreWinPosn")
endfun

" ---------------------------------------------------------------------
" GoWinbufnr: go to window holding given buffer (by number) {{{2
"   Prefers current window; if its buffer number doesn't match,
"   then will try from topleft to bottom right
fun! GoWinbufnr(bufnum)
"  call Dfunc("GoWinbufnr(".a:bufnum.")")
  if winbufnr(0) == a:bufnum
"   call Dret("GoWinbufnr : winbufnr(0)==a:bufnum")
   return
  endif
  winc t
  let first=1
  while winbufnr(0) != a:bufnum && (first || winnr() != 1)
  	winc w
	let first= 0
   endwhile
"  call Dret("GoWinbufnr")
endfun

" ---------------------------------------------------------------------
" SaveMark: sets up a string saving a mark position. {{{2
"           For example, SaveMark("a")
"           Also sets up a global variable, g:savemark_{markname}
fun! SaveMark(markname)
"  call Dfunc("SaveMark(markname<".a:markname.">)")
  let markname= a:markname
  if strpart(markname,0,1) !~ '\a'
   let markname= strpart(markname,1,1)
  endif
"  call Decho("markname=".markname)

  let lzkeep  = &lz
  set lz

  if 1 <= line("'".markname) && line("'".markname) <= line("$")
   let winposn               = SaveWinPosn(0)
   exe s:modifier."norm! `".markname
   let savemark              = SaveWinPosn(0)
   let g:savemark_{markname} = savemark
   let savemark              = markname.savemark
   call RestoreWinPosn(winposn)
  else
   let g:savemark_{markname} = ""
   let savemark              = ""
  endif

  let &lz= lzkeep

"  call Dret("SaveMark : savemark<".savemark.">")
  return savemark
endfun

" ---------------------------------------------------------------------
" RestoreMark: {{{2
"   call RestoreMark("a")  -or- call RestoreMark(savemark)
fun! RestoreMark(markname)
"  call Dfunc("RestoreMark(markname<".a:markname.">)")

  if strlen(a:markname) <= 0
"   call Dret("RestoreMark : no such mark")
   return
  endif
  let markname= strpart(a:markname,0,1)
  if markname !~ '\a'
   " handles 'a -> a styles
   let markname= strpart(a:markname,1,1)
  endif
"  call Decho("markname=".markname." strlen(a:markname)=".strlen(a:markname))

  let lzkeep  = &lz
  set lz
  let winposn = SaveWinPosn(0)

  if strlen(a:markname) <= 2
   if exists("g:savemark_{markname}") && strlen(g:savemark_{markname}) != 0
	" use global variable g:savemark_{markname}
"	call Decho("use savemark list")
	call RestoreWinPosn(g:savemark_{markname})
	exe "norm! m".markname
   endif
  else
   " markname is a savemark command (string)
"	call Decho("use savemark command")
   let markcmd= strpart(a:markname,1)
   call RestoreWinPosn(markcmd)
   exe "norm! m".markname
  endif

  call RestoreWinPosn(winposn)
  let &lz       = lzkeep

"  call Dret("RestoreMark")
endfun

" ---------------------------------------------------------------------
" DestroyMark: {{{2
"   call DestroyMark("a")  -- destroys mark
fun! DestroyMark(markname)
"  call Dfunc("DestroyMark(markname<".a:markname.">)")

  " save options and set to standard values
  let reportkeep= &report
  let lzkeep    = &lz
  set lz report=10000

  let markname= strpart(a:markname,0,1)
  if markname !~ '\a'
   " handles 'a -> a styles
   let markname= strpart(a:markname,1,1)
  endif
"  call Decho("markname=".markname)

  let curmod  = &mod
  let winposn = SaveWinPosn(0)
  1
  let lineone = getline(".")
  exe "k".markname
  d
  put! =lineone
  let &mod    = curmod
  call RestoreWinPosn(winposn)

  " restore options to user settings
  let &report = reportkeep
  let &lz     = lzkeep

"  call Dret("DestroyMark")
endfun

" ---------------------------------------------------------------------
" QArgSplitter: to avoid \ processing by <f-args>, <q-args> is needed. {{{2
" However, <q-args> doesn't split at all, so this one returns a list
" with splits at all whitespace (only!), plus a leading length-of-list.
" The resulting list:  qarglist[0] corresponds to a:0
"                      qarglist[i] corresponds to a:{i}
fun! QArgSplitter(qarg)
"  call Dfunc("QArgSplitter(qarg<".a:qarg.">)")
  let qarglist    = split(a:qarg)
  let qarglistlen = len(qarglist)
  let qarglist    = insert(qarglist,qarglistlen)
"  call Dret("QArgSplitter ".string(qarglist))
  return qarglist
endfun

" ---------------------------------------------------------------------
" ListWinPosn: {{{2
"fun! ListWinPosn()                                                        " Decho 
"  if !exists("b:cecutil_iwinposn") || b:cecutil_iwinposn == 0             " Decho 
"   call Decho("nothing on SWP stack")                                     " Decho
"  else                                                                    " Decho
"   let jwinposn= b:cecutil_iwinposn                                       " Decho 
"   while jwinposn >= 1                                                    " Decho 
"    if exists("b:cecutil_winposn{jwinposn}")                              " Decho 
"     call Decho("winposn{".jwinposn."}<".b:cecutil_winposn{jwinposn}.">") " Decho 
"    else                                                                  " Decho 
"     call Decho("winposn{".jwinposn."} -- doesn't exist")                 " Decho 
"    endif                                                                 " Decho 
"    let jwinposn= jwinposn - 1                                            " Decho 
"   endwhile                                                               " Decho 
"  endif                                                                   " Decho
"endfun                                                                    " Decho 
"com! -nargs=0 LWP	call ListWinPosn()                                    " Decho 

" ---------------------------------------------------------------------
" SaveUserMaps: this function sets up a script-variable (s:restoremap) {{{2
"          which can be used to restore user maps later with
"          call RestoreUserMaps()
"
"          mapmode - see :help maparg for details (n v o i c l "")
"                    ex. "n" = Normal
"                    The letters "b" and "u" are optional prefixes;
"                    The "u" means that the map will also be unmapped
"                    The "b" means that the map has a <buffer> qualifier
"                    ex. "un"  = Normal + unmapping
"                    ex. "bn"  = Normal + <buffer>
"                    ex. "bun" = Normal + <buffer> + unmapping
"                    ex. "ubn" = Normal + <buffer> + unmapping
"          maplead - see mapchx
"          mapchx  - "<something>" handled as a single map item.
"                    ex. "<left>"
"                  - "string" a string of single letters which are actually
"                    multiple two-letter maps (using the maplead:
"                    maplead . each_character_in_string)
"                    ex. maplead="\" and mapchx="abc" saves user mappings for
"                        \a, \b, and \c
"                    Of course, if maplead is "", then for mapchx="abc",
"                    mappings for a, b, and c are saved.
"                  - :something  handled as a single map item, w/o the ":"
"                    ex.  mapchx= ":abc" will save a mapping for "abc"
"          suffix  - a string unique to your plugin
"                    ex.  suffix= "DrawIt"
fun! SaveUserMaps(mapmode,maplead,mapchx,suffix)
"  call Dfunc("SaveUserMaps(mapmode<".a:mapmode."> maplead<".a:maplead."> mapchx<".a:mapchx."> suffix<".a:suffix.">)")

  if !exists("s:restoremap_{a:suffix}")
   " initialize restoremap_suffix to null string
   let s:restoremap_{a:suffix}= ""
  endif

  " set up dounmap: if 1, then save and unmap  (a:mapmode leads with a "u")
  "                 if 0, save only
  let mapmode  = a:mapmode
  let dounmap  = 0
  let dobuffer = ""
  while mapmode =~ '^[bu]'
   if     mapmode =~ '^u'
    let dounmap = 1
    let mapmode = strpart(a:mapmode,1)
   elseif mapmode =~ '^b'
    let dobuffer = "<buffer> "
    let mapmode  = strpart(a:mapmode,1)
   endif
  endwhile
"  call Decho("dounmap=".dounmap."  dobuffer<".dobuffer.">")
 
  " save single map :...something...
  if strpart(a:mapchx,0,1) == ':'
"   call Decho("save single map :...something...")
   let amap= strpart(a:mapchx,1)
   if amap == "|" || amap == "\<c-v>"
    let amap= "\<c-v>".amap
   endif
   let amap                    = a:maplead.amap
   let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|:silent! ".mapmode."unmap ".dobuffer.amap
   if maparg(amap,mapmode) != ""
    let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|:".mapmode."map ".dobuffer.amap." ".maprhs
   endif
   if dounmap
	exe "silent! ".mapmode."unmap ".dobuffer.amap
   endif
 
  " save single map <something>
  elseif strpart(a:mapchx,0,1) == '<'
"   call Decho("save single map <something>")
   let amap       = a:mapchx
   if amap == "|" || amap == "\<c-v>"
    let amap= "\<c-v>".amap
"	call Decho("amap[[".amap."]]")
   endif
   let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|silent! ".mapmode."unmap ".dobuffer.amap
   if maparg(a:mapchx,mapmode) != ""
    let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|".mapmode."map ".dobuffer.amap." ".maprhs
   endif
   if dounmap
	exe "silent! ".mapmode."unmap ".dobuffer.amap
   endif
 
  " save multiple maps
  else
"   call Decho("save multiple maps")
   let i= 1
   while i <= strlen(a:mapchx)
    let amap= a:maplead.strpart(a:mapchx,i-1,1)
	if amap == "|" || amap == "\<c-v>"
	 let amap= "\<c-v>".amap
	endif
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|silent! ".mapmode."unmap ".dobuffer.amap
    if maparg(amap,mapmode) != ""
     let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	 let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|".mapmode."map ".dobuffer.amap." ".maprhs
    endif
	if dounmap
	 exe "silent! ".mapmode."unmap ".dobuffer.amap
	endif
    let i= i + 1
   endwhile
  endif
"  call Dret("SaveUserMaps : restoremap_".a:suffix.": ".s:restoremap_{a:suffix})
endfun

" ---------------------------------------------------------------------
" RestoreUserMaps: {{{2
"   Used to restore user maps saved by SaveUserMaps()
fun! RestoreUserMaps(suffix)
"  call Dfunc("RestoreUserMaps(suffix<".a:suffix.">)")
  if exists("s:restoremap_{a:suffix}")
   let s:restoremap_{a:suffix}= substitute(s:restoremap_{a:suffix},'|\s*$','','e')
   if s:restoremap_{a:suffix} != ""
"   	call Decho("exe ".s:restoremap_{a:suffix})
    exe "silent! ".s:restoremap_{a:suffix}
   endif
   unlet s:restoremap_{a:suffix}
  endif
"  call Dret("RestoreUserMaps")
endfun

" ==============
"  Restore: {{{1
" ==============
let &cpo= s:keepcpo
unlet s:keepcpo

" ================
"  Modelines: {{{1
" ================
" vim: ts=4 fdm=marker
doc/HiCurLine.txt	[[[1
198
*hicurline.txt*	The HiCurLine Tool		May 20, 2009

Author:  Charles E. Campbell, Jr.  <NdrOchip@ScampbellPfamily.AbizM>
	  (remove NOSPAM from Campbell's email first)
Copyright: (c) 2004-2009 by Charles E. Campbell, Jr.	*hicurline-copyright*
           The VIM LICENSE applies to HiCurLine.vim and HiCurLine.txt
           (see |copyright|) except use "HiCurLine" instead of "Vim"
	   No warranty, express or implied.  Use At-Your-Own-Risk.

==============================================================================
1. Contents						*hicurline-contents*

	1. Contents......................: |hicurline-contents|
	2. Installing HiCurLine..........: |hicurline-install|
	3. HiCurLine Manual..............: |hicurline|
	4. HiCurLine Usage...............: |hicurline-usage|
	     Starting....................: |hicurline-start|
	     Stopping....................: |hicurline-stopping|
	     User Map Protection.........: |hicurline-protect|
	     Highlighting Options........: |hicurline-option|
	5. HiCurLine History.............: |hicurline-history|


==============================================================================
2. Installing HiCurLine					*hicurline-install*

    1. Move/copy HiCurLine.tar.gz to
         unix/linux: ~/.vim
	 Windows   : ...\vimfiles
    2. gunzip HiCurLine.tar.gz
    3. tar -oxvf HiCurLine.tar
    4. vim
       :helptags doc
       :q
    5. This step is only for those who wish to have HiCurLine start up
       automatically:

       a) if you want HiCurLine to start up for all files:
          Put the following line in your <.vimrc> (or vimfiles, for Windows): >

	  let g:HiCurLineOn= 1
<
       b) if you want HiCurLine to start up automatically but only for
          specific filetypes.  For example, assume such a filetype is
	  for the C language: >

          mkdir ftplugin  (if ftplugin/ doesn't already exist)
	  cd ftplugin
	  mkdir c         (if ftplugin/c doesn't already exist)
	  cd c
    	  echo "HCLstart" >> c.vim
<

==============================================================================
3. HiCurLine Manual					*hicurline*
							*hicurline-manual*
	To Enable:

   /===============+=========================================================\
   || Starting &   |                                                        ||
   || Stopping     | Explanation                                            ||
   ++--------------+--------------------------------------------------------++
   || <Leader>hcli | start  HiCurLine                                       ||
   || :HCLstart    | start  HiCurLine                                       ||
   || <Leader>hcls | stop   HiCurLine                                       ||
   || :HCLstop     | stop   HiCurLine                                       ||
   || :HCL         | toggle HiCurLine                                       ||
   ++==============+========================================================++

 You may also choose from the DrChip.HiCurLine menu items if you're running
 gvim.  Check on vim's help for mapleader |mapleader| to learn how to set
 <Leader>; by default its the backslash - ie. by default \hcli will start and
 \hcls will stop HiCurLine.


==============================================================================
3. HiCurLine Usage					*hicurline-usage*

    See |hicurline-start| and |hicurline-stop| for how to start and
    stop HiCurLine.

    The HiCurLine plugin attempts to highlight the current line.

    As of version 4, such overloaded motions include:

		-  h  L      <c-d>   <home>
		+  H  M      <c-f>   <left>
		b  j  w      <c-u>   <leftmouse>
		B  k  <cr>   <down>  <right>
		e  l  <c-b>  <end>   <up>
		E

    Because vim is rich with commands that can move the cursor, the
    script also uses the CursorHold event (see |CursorHold| and
    |'updatetime'|) to highlight the current line whenever the
    cursor is left still for awhile.

STARTING						*hicurline-start*
    <Leader>hcli
    :HCLstart
    let g:HiCurLineOn= 1    (in your .vimrc or vimfiles)

    Typically one puts <hicurline.vim> into the .vim/plugin directory
    (vimfiles\plugin for MS) where it becomes always available.  It uses a
    minimal interface:

	<Leader>hcli : initialize highlighting of matching brackets
	            (by default its \hcli)

    A message, "[HiCurLine]", will appear on the message line.

    I've had it reported to me that sometimes HiCurLine can cause
    the entire file to be highlighted.  The fix was:

      remove the .viminfo file
      vim HiCurLine.vim
      :wq

    I'm not sure what the .viminfo file had that caused difficulties, but
    the second part of the solution probably changed the file's fileformat
    to one more acceptable to the o/s.  (HiCurLine.vim is delivered with
    ff=unix; see :he 'ff')


STOPPING				*hicurline-stop* *hicurline-stopping*
    <Leader>[hcls
    :HCLstop

    When you are done with HiCurLine, use

	    <Leader>[hcls : stop highlighting of matching brackets
	            	(by default its \hcls)

    will restore your usual options and remove the maps HiCurLine set up.

    A message, "[HiCurLine off]", will appear on the message line.

USER MAP PROTECTION					*hicurline-protect*

    Starting HiCurLine causes it to set up a number of maps which enables
    the highlighting of matching brackets in normal mode.  A few keypad
    entries in insert mode are also supported (up, down, right, left, home,
    and end).  Upon termination these maps are deleted and any previously
    defined mappings are restored.

HIGHLIGHTING CURRENT LINE OPTIONS			*hicurline-option*

    g:DrChipTopLvlMenu: by default its "DrChip"; you may set this to whatever
                        you like in your <.vimrc>.  This variable controls
			where HiCurLine's menu items are placed.
    HL_HiCurLine      : syntax highlighting group used for the current
                        line.  One may specify it or link it to another
                        highlighting group.  Default: Search >
			    ex. hi link HL_HiCurLine Statement
<
    HL_HiCurLine      : As an alternative to using the syntax group named
                        above; its a variable holding a highlighting group
			name (see |highlight-groups| for a standard list). >
			    ex. let HL_HiCurLine= "Special"
<

==============================================================================
4. History						*hicurline-history*
	
	v8   05/20/09 * cecutil bugfix
	v7   12/28/05 * now uses cecutil to save/restore user maps
	     01/19/06 * Like HiMtchBrkt(), HiCurLine now uses a HCLMapper()
	                function to implement command overloading.  Stacks
	                previous maps, for example.
	     01/19/06 * CursorHold time changed to 2 seconds
	     01/20/06 * g:HiCurLineOn variable for auto-startup installed
	     03/01/06 * turns matchparen off automatically (incompatible)
	v6   07/26/04 * Had fold markers; now also has fdm=marker in modeline
	              * \hclt will toggle between highlighting the current
	                line and not
	              * Cursorhold/FocusGained update time now set to 200ms
	     02/18/05 * Some cosmetic folding changes
	              * go =~ 'm' now used in test to see if menus are to be
	                generated
	     11/22/05 * commands changed to remove <cr>s
	v5   07/13/04 * Now uses CursorHold to check if the colorscheme
	                has been changed and, if so, to make sure HL_HiCurLine
	                is defined.  Included support for gg and G motions.
	                More debugging commands included, albeit commented
	                out for release.
	v4   06/23/03 * HL_HiCurLine : now holds the highlighting
	                group (by default, Search); allows the user
	                to override it
	v3   02/10/03 * same as v2, but got submitted somehow as v3
	                to vim.sf.net
	v2   02/06/03 * removed some unnecessary maps (f( f) $ 0 etc)
	                that were "leftover" from HiMtchBrkt
	                includes more motions: (+-HML)
	                uses CurSorHold to catch what I've missed so far
	v1   epoch    * modified <HiMtchBrkt.vim>

==============================================================================
vim:tw=78:ts=8:ft=help:sts=4