Removed old plugins
This commit is contained in:
yan
Yan Pritzker
parent
372e405d02
commit
429396fcbf
@ -1 +1 @@
|
||||
Subproject commit 864d3aa422dbbcf5eb00b09edb003728e2da8ae1
|
||||
Subproject commit 93235d9a5f3523c3c8f9648f59a81450d10e2f59
|
||||
@ -1,449 +0,0 @@
|
||||
" camelcasemotion.vim: Mappings for motion through CamelCaseWords and
|
||||
" underscore_notation.
|
||||
"
|
||||
" DESCRIPTION: {{{1
|
||||
" VIM provides many built-in motions, e.g. to move to the next word, or
|
||||
" end of the current word. Most programming languages use either CamelCase
|
||||
" ("anIdentifier") or underscore_notation ("an_identifier") naming
|
||||
" conventions for identifiers. The best way to navigate inside those
|
||||
" identifiers using VIM built-in motions is the '[count]f{char}' motion, i.e.
|
||||
" 'f<uppercase char>' or 'f_', respectively. But we can make this easier:
|
||||
"
|
||||
" This script defines motions ',w', ',b' and ',e' (similar to 'w', 'b', 'e'),
|
||||
" which do not move word-wise (forward/backward), but Camel-wise; i.e. to word
|
||||
" boundaries and uppercase letters. The motions also work on underscore
|
||||
" notation, where words are delimited by underscore ('_') characters.
|
||||
" From here on, both CamelCase and underscore_notation entities are referred
|
||||
" to as "words" (in double quotes). Just like with the regular motions, a
|
||||
" [count] can be prepended to move over multiple "words" at once.
|
||||
" Outside of "words" (e.g. in non-keyword characters like // or ;), the new
|
||||
" motions move just like the regular motions.
|
||||
"
|
||||
" VIM provides a built-in text object called 'inner word' ('iw'), which works
|
||||
" in operator-pending and visual mode. Analog to that, this script defines
|
||||
" inner "word" motions 'i,w', 'i,b' and 'i,e', which select the "word" (or
|
||||
" multiple "words" if a [count] is given) where the cursor is located.
|
||||
"
|
||||
" USAGE:
|
||||
" Use the new motions ',w', ',b' and ',e' in normal mode, operator-pending
|
||||
" mode (cp. :help operator), and visual mode. For example, type 'bc,w' to
|
||||
" change 'Camel' in 'CamelCase' to something else.
|
||||
"
|
||||
" EXAMPLE: motions
|
||||
" Given the following CamelCase identifiers in a source code fragment:
|
||||
" set Script31337PathAndNameWithoutExtension11=%~dpn0
|
||||
" set Script31337PathANDNameWITHOUTExtension11=%~dpn0
|
||||
" and the corresponding identifiers in underscore_notation:
|
||||
" set script_31337_path_and_name_without_extension_11=%~dpn0
|
||||
" set SCRIPT_31337_PATH_AND_NAME_WITHOUT_EXTENSION_11=%~dpn0
|
||||
"
|
||||
" ,w moves to ([x] is cursor position): [s]et, [s]cript, [3]1337, [p]ath,
|
||||
" [a]nd, [n]ame, [w]ithout, [e]xtension, [1]1, [d]pn0, dpn[0], [s]et
|
||||
" ,b moves to: [d]pn0, [1]1, [e]xtension, [w]ithout, ...
|
||||
" ,e moves to: se[t], scrip[t], 3133[7], pat[h], an[d], nam[e], withou[t],
|
||||
" extensio[n], 1[1], dpn[0]
|
||||
"
|
||||
" EXAMPLE: inner motions
|
||||
" Given the following identifier, with the cursor positioned at [x]:
|
||||
" script_31337_path_and_na[m]e_without_extension_11
|
||||
"
|
||||
" v3i,w selects script_31337_path_and_[name_without_extension_]11
|
||||
" v3i,b selects script_31337_[path_and_name]_without_extension_11
|
||||
" v3i,e selects script_31337_path_and_[name_without_extension]_11
|
||||
" Instead of visual mode, you can also use c3i,w to change, d3i,w to delete,
|
||||
" gU3i,w to upper-case, and so on.
|
||||
"
|
||||
" INSTALLATION: {{{1
|
||||
" Put the script into your user or system VIM plugin directory (e.g.
|
||||
" ~/.vim/plugin).
|
||||
"
|
||||
" DEPENDENCIES:
|
||||
" - Requires VIM 7.0 or higher.
|
||||
"
|
||||
" CONFIGURATION:
|
||||
" If you want to use different mappings, map your keys to the
|
||||
" <Plug>CamelCaseMotion_? mapping targets _before_ sourcing this script
|
||||
" (e.g. in your .vimrc).
|
||||
"
|
||||
" Example: Replace the default 'w', 'b' and 'e' mappings instead of defining
|
||||
" additional mappings ',w', ',b' and ',e':
|
||||
" map <silent> w <Plug>CamelCaseMotion_w
|
||||
" map <silent> b <Plug>CamelCaseMotion_b
|
||||
" map <silent> e <Plug>CamelCaseMotion_e
|
||||
"
|
||||
" Example: Replace default 'iw' text-object and define 'ib' and 'ie' motions:
|
||||
" omap <silent> iw <Plug>CamelCaseMotion_iw
|
||||
" vmap <silent> iw <Plug>CamelCaseMotion_iw
|
||||
" omap <silent> ib <Plug>CamelCaseMotion_ib
|
||||
" vmap <silent> ib <Plug>CamelCaseMotion_ib
|
||||
" omap <silent> ie <Plug>CamelCaseMotion_ie
|
||||
" vmap <silent> ie <Plug>CamelCaseMotion_ie
|
||||
"
|
||||
" LIMITATIONS:
|
||||
"
|
||||
" ASSUMPTIONS:
|
||||
"
|
||||
" KNOWN PROBLEMS:
|
||||
" - A degenerate CamelCaseWord containing '\U\u\d' (e.g. "MaP1Roblem")
|
||||
" confuses the operator-pending and visual mode ,e mapping if 'selection' is
|
||||
" not set to "exclusive". It'll skip "P" and select "P1" in one step. As a
|
||||
" workaround, use ',w' instead of ',e'; those two mappings have the same
|
||||
" effect inside CamelCaseWords, anyway.
|
||||
" - The operator-pending and visual mode ,e mapping doesn't work properly when
|
||||
" it reaches the end of the buffer; the final character of the moved-over
|
||||
" "word" remains. As a workaround, use the default 'e' motion instead of
|
||||
" ',e'.
|
||||
" - When the VIM setting 'selection' is not set to "exclusive", a
|
||||
" forward-backward combination in visual mode (e.g. 'v,w,b') selects one
|
||||
" additional character to the left, instead of only the character where the
|
||||
" motion started. Likewise, extension of the visual selection from the front
|
||||
" end is off by one additional character.
|
||||
"
|
||||
" TODO:
|
||||
"
|
||||
" Copyright: (C) 2007-2008 by Ingo Karkat
|
||||
" The VIM LICENSE applies to this script; see ':help copyright'.
|
||||
"
|
||||
" Source: Based on vimtip #1016 by Anthony Van Ham.
|
||||
" Maintainer: Ingo Karkat <ingo@karkat.de>
|
||||
" REVISION DATE REMARKS {{{1
|
||||
" 1.40.017 19-May-2008 BF: Now using :normal! to be independent from
|
||||
" any user mappings. Thanks to Neil Walker for the
|
||||
" patch.
|
||||
" 1.40.016 28-Apr-2008 BF: Wrong forward motion stop at the second
|
||||
" digit if a word starts with multiple numbers
|
||||
" (e.g. 1234.56789). Thanks to Wasim Ahmed for
|
||||
" reporting this.
|
||||
" 1.40.015 24-Apr-2008 ENH: Added inner "word" text objects 'i,w' etc.
|
||||
" that work analoguous to the built-in 'iw' text
|
||||
" object. Thanks to David Kotchan for this
|
||||
" suggestion.
|
||||
" 1.30.014 20-Apr-2008 The motions now also stop at non-keyword
|
||||
" boundaries, just like the regular motions. This
|
||||
" has no effect inside a CamelCaseWord or inside
|
||||
" underscore_notation, but it makes the motions
|
||||
" behave like the regular motions (which is
|
||||
" important if you replace the default motions).
|
||||
" Thanks to Mun Johl for reporting this.
|
||||
" Now using non-capturing parentheses \%() in the
|
||||
" patterns.
|
||||
" 1.30.013 09-Apr-2008 Refactored away s:VisualCamelCaseMotion().
|
||||
" Allowing users to use mappings different than
|
||||
" ,w ,b ,e by defining <Plug>CamelCaseMotion_?
|
||||
" target mappings. This can even be used to
|
||||
" replace the default 'w', 'b' and 'e' mappings,
|
||||
" as suggested by Mun Johl.
|
||||
" Mappings are now created in a generic function.
|
||||
" Now requires VIM 7.0 or higher.
|
||||
" 1.20.012 02-Jun-2007 BF: Corrected motions through mixed
|
||||
" CamelCase_and_UnderScore words by re-ordering
|
||||
" and narrowing the search patterns.
|
||||
" 1.20.011 02-Jun-2007 Thanks again to Joseph Barker for discussing the
|
||||
" complicated visual mode mapping on the vim-dev
|
||||
" mailing list and coming up with a great
|
||||
" simplification:
|
||||
" Removed s:CheckForChangesToTheSelectionSetting().
|
||||
" Introduced s:VisualCamelCaseMotion(), which
|
||||
" handles the differences depending on the
|
||||
" 'selection' setting.
|
||||
" Visual mode mappings now directly map to the
|
||||
" s:VisualCamelCaseMotion() function; no mark is
|
||||
" clobbered, the complex mapping with the inline
|
||||
" expression has been retired.
|
||||
" 1.20.010 29-May-2007 BF: The operator-pending and visual mode ,e
|
||||
" mapping doesn't work properly when it reaches
|
||||
" the end of line; the final character of the
|
||||
" moved-over "word" remains. Fixed this problem
|
||||
" unless the "word" is at the very end of the
|
||||
" buffer.
|
||||
" ENH: The visual mode motions now also (mostly)
|
||||
" work with the (default) setting
|
||||
" 'set selection=inclusive', instead of selecting
|
||||
" one character too much.
|
||||
" ENH: All mappings will check for changes to the
|
||||
" 'selection' setting and remap the visual mode
|
||||
" mappings via function
|
||||
" s:SetupVisualModeMappings(). We cannot rely on
|
||||
" the setting while sourcing camelcasemotion.vim
|
||||
" because the mswin.vim script may be sourced
|
||||
" afterwards, and its 'behave mswin' changes
|
||||
" 'selection'.
|
||||
" Refactored the arguments of function
|
||||
" s:CamelCaseMotion(...).
|
||||
" 1.10.009 28-May-2007 BF: Degenerate CamelCaseWords that consist of
|
||||
" only a single uppercase letter (e.g. "P" in
|
||||
" "MapPRoblem") are skipped by all motions. Thanks
|
||||
" to Joseph Barker for reporting this.
|
||||
" BF: In CamelCaseWords that consist of uppercase
|
||||
" letters followed by decimals (e.g.
|
||||
" "MyUPPER123Problem", the uppercase "word" is
|
||||
" skipped by all motions.
|
||||
" 1.10.008 28-May-2007 Incorporated major improvements and
|
||||
" simplifications done by Joseph Barker:
|
||||
" Operator-pending and visual mode motions now
|
||||
" accept [count] of more than 9.
|
||||
" Visual selections can now be extended from
|
||||
" either end.
|
||||
" Instead of misusing the :[range], the special
|
||||
" variable v:count1 is used. Custom commands are
|
||||
" not needed anymore.
|
||||
" Operator-pending and visual mode mappings are
|
||||
" now generic: There's only a single mapping for
|
||||
" ,w that can be repeated, rather than having a
|
||||
" separate mapping for 1,w 2,w 3,w ...
|
||||
" 1.00.007 22-May-2007 Added documentation for publication.
|
||||
" 006 20-May-2007 BF: visual mode [1,2,3],e on pure CamelCase
|
||||
" mistakenly marks [2,4,6] words. If the cursor is
|
||||
" on a uppercase letter, the search pattern
|
||||
" '\u\l\+' doesn't match at the cursor position,
|
||||
" so another match won. Changed search pattern
|
||||
" from '\l\+',
|
||||
" 005 16-May-2007 Added support for underscore notation.
|
||||
" Added support for "forward to end of word"
|
||||
" (',e') motion.
|
||||
" 004 16-May-2007 Improved search pattern so that
|
||||
" UppercaseWORDSInBetween and digits are handled,
|
||||
" too.
|
||||
" 003 15-May-2007 Changed mappings from <Leader>w to ,w;
|
||||
" other \w mappings interfere here, because it's
|
||||
" irritating when the cursor jump doesn't happen
|
||||
" immediately, because VIM waits whether the
|
||||
" mapping is complete. ,w is faster to type that
|
||||
" \w (and, because of the left-right touch,
|
||||
" preferred over gw).
|
||||
" Added visual mode mappings.
|
||||
" 0.02 15-Feb-2006 BF: missing <SID> for omaps.
|
||||
" 0.01 11-Oct-2005 file creation
|
||||
|
||||
" Avoid installing twice or when in compatible mode
|
||||
if exists("loaded_camelcasemotion") || (v:version < 700)
|
||||
finish
|
||||
endif
|
||||
let loaded_camelcasemotion = 1
|
||||
" }}}1
|
||||
|
||||
"- functions ------------------------------------------------------------------"
|
||||
function! s:CamelCaseMove( direction, count, mode ) " {{{1
|
||||
" Note: There is no inversion of the regular expression character class
|
||||
" 'keyword character' (\k). We need an inversion "non-keyword" defined as
|
||||
" "any non-whitespace character that is not a keyword character (e.g.
|
||||
" [!@#$%^&*()]. This can be specified via a non-whitespace character in
|
||||
" whose place no keyword character matches (\k\@!\S).
|
||||
|
||||
"echo "count is " . a:count
|
||||
let l:i = 0
|
||||
while l:i < a:count
|
||||
if a:direction == 'e'
|
||||
" "Forward to end" motion.
|
||||
"call search( '\>\|\(\a\|\d\)\+\ze_', 'We' )
|
||||
" end of ...
|
||||
" number | ACRONYM followed by CamelCase or number | CamelCase | underscore_notation | non-keyword | word
|
||||
call search( '\d\+\|\u\+\ze\%(\u\l\|\d\)\|\u\l\+\|\%(\a\|\d\)\+\ze_\|\%(\k\@!\S\)\+\|\%(_\@!\k\)\+\>', 'We' )
|
||||
" Note: word must be defined as '\k\>'; '\>' on its own somehow
|
||||
" dominates over the previous branch. Plus, \k must exclude the
|
||||
" underscore, or a trailing one will be incorrectly moved over:
|
||||
" '\%(_\@!\k\)'.
|
||||
if a:mode == 'o'
|
||||
" Note: Special additional treatment for operator-pending mode
|
||||
" "forward to end" motion.
|
||||
" The difference between normal mode, operator-pending and visual
|
||||
" mode is that in the latter two, the motion must go _past_ the
|
||||
" final "word" character, so that all characters of the "word" are
|
||||
" selected. This is done by appending a 'l' motion after the
|
||||
" search for the next "word".
|
||||
"
|
||||
" In operator-pending mode, the 'l' motion only works properly
|
||||
" at the end of the line (i.e. when the moved-over "word" is at
|
||||
" the end of the line) when the 'l' motion is allowed to move
|
||||
" over to the next line. Thus, the 'l' motion is added
|
||||
" temporarily to the global 'whichwrap' setting.
|
||||
" Without this, the motion would leave out the last character in
|
||||
" the line. I've also experimented with temporarily setting
|
||||
" "set virtualedit=onemore" , but that didn't work.
|
||||
let l:save_ww = &whichwrap
|
||||
set whichwrap+=l
|
||||
normal! l
|
||||
let &whichwrap = l:save_ww
|
||||
endif
|
||||
else
|
||||
" Forward (a:direction == '') and backward (a:direction == 'b')
|
||||
" motion.
|
||||
|
||||
let l:direction = (a:direction == 'w' ? '' : a:direction)
|
||||
|
||||
" CamelCase: Jump to beginning of either (start of word, Word, WORD,
|
||||
" 123).
|
||||
" Underscore_notation: Jump to the beginning of an underscore-separated
|
||||
" word or number.
|
||||
"call search( '\<\|\u', 'W' . l:direction )
|
||||
"call search( '\<\|\u\(\l\+\|\u\+\ze\u\)\|\d\+', 'W' . l:direction )
|
||||
"call search( '\<\|\u\(\l\+\|\u\+\ze\u\)\|\d\+\|_\zs\(\a\|\d\)\+', 'W' . l:direction )
|
||||
" beginning of ...
|
||||
" word | empty line | non-keyword after whitespaces | non-whitespace after word | number | ACRONYM followed by CamelCase or number | CamelCase | underscore followed by ACRONYM, Camel, lowercase or number
|
||||
call search( '\<\D\|^$\|\%(^\|\s\)\+\zs\k\@!\S\|\>\S\|\d\+\|\u\+\ze\%(\u\l\|\d\)\|\u\l\+\|_\zs\%(\u\+\|\u\l\+\|\l\+\|\d\+\)', 'W' . l:direction )
|
||||
" Note: word must be defined as '\<\D' to avoid that a word like
|
||||
" 1234Test is moved over as [1][2]34[T]est instead of [1]234[T]est
|
||||
" because \< matches with zero width, and \d\+ will then start
|
||||
" matching '234'. To fix that, we make \d\+ be solely responsible
|
||||
" for numbers by taken this away from \< via \<\D. (An alternative
|
||||
" would be to replace \d\+ with \D\%#\zs\d\+, but that one is more
|
||||
" complex.) All other branches are not affected, because they match
|
||||
" multiple characters and not the same character multiple times.
|
||||
endif
|
||||
let l:i = l:i + 1
|
||||
endwhile
|
||||
endfunction
|
||||
" }}}1
|
||||
|
||||
function! s:CamelCaseMotion( direction, count, mode ) " {{{1
|
||||
"*******************************************************************************
|
||||
"* PURPOSE:
|
||||
" Perform the motion over CamelCaseWords or underscore_notation.
|
||||
"* ASSUMPTIONS / PRECONDITIONS:
|
||||
" none
|
||||
"* EFFECTS / POSTCONDITIONS:
|
||||
" Move cursor / change selection.
|
||||
"* INPUTS:
|
||||
" a:direction one of 'w', 'b', 'e'
|
||||
" a:count number of "words" to move over
|
||||
" a:mode one of 'n', 'o', 'v', 'iv' (latter one is a special visual mode
|
||||
" when inside the inner "word" text objects.
|
||||
"* RETURN VALUES:
|
||||
" none
|
||||
"*******************************************************************************
|
||||
" Visual mode needs special preparations and postprocessing;
|
||||
" normal and operator-pending mode breeze through to s:CamelCaseMove().
|
||||
|
||||
if a:mode == 'v'
|
||||
" Visual mode was left when calling this function. Reselecting the current
|
||||
" selection returns to visual mode and allows to call search() and issue
|
||||
" normal mode motions while staying in visual mode.
|
||||
normal! gv
|
||||
endif
|
||||
if a:mode == 'v' || a:mode == 'iv'
|
||||
|
||||
" Note_1a:
|
||||
if &selection != 'exclusive' && a:direction == 'w'
|
||||
normal! l
|
||||
endif
|
||||
endif
|
||||
|
||||
call s:CamelCaseMove( a:direction, a:count, a:mode )
|
||||
|
||||
if a:mode == 'v' || a:mode == 'iv'
|
||||
" Note: 'selection' setting.
|
||||
if &selection == 'exclusive' && a:direction == 'e'
|
||||
" When set to 'exclusive', the "forward to end" motion (',e') does not
|
||||
" include the last character of the moved-over "word". To include that, an
|
||||
" additional 'l' motion is appended to the motion; similar to the
|
||||
" special treatment in operator-pending mode.
|
||||
normal! l
|
||||
elseif &selection != 'exclusive' && a:direction != 'e'
|
||||
" Note_1b:
|
||||
" The forward and backward motions move to the beginning of the next "word".
|
||||
" When 'selection' is set to 'inclusive' or 'old', this is one character too far.
|
||||
" The appended 'h' motion undoes this. Because of this backward step,
|
||||
" though, the forward motion finds the current "word" again, and would
|
||||
" be stuck on the current "word". An 'l' motion before the CamelCase
|
||||
" motion (see Note_1a) fixes that.
|
||||
normal! h
|
||||
end
|
||||
endif
|
||||
endfunction
|
||||
" }}}1
|
||||
|
||||
function! s:CamelCaseInnerMotion( direction, count ) " {{{1
|
||||
" If the cursor is positioned on the first character of a CamelWord, the
|
||||
" backward motion would move to the previous word, which would result in a
|
||||
" wrong selection. To fix this, first move the cursor to the right, so that
|
||||
" the backward motion definitely will cover the current "word" under the
|
||||
" cursor.
|
||||
normal! l
|
||||
|
||||
" Move "word" backwards, enter visual mode, then move "word" forward. This
|
||||
" selects the inner "word" in visual mode; the operator-pending mode takes
|
||||
" this selection as the area covered by the motion.
|
||||
if a:direction == 'b'
|
||||
" Do not do the selection backwards, because the backwards "word" motion
|
||||
" in visual mode + selection=inclusive has an off-by-one error.
|
||||
call s:CamelCaseMotion( 'b', a:count, 'n' )
|
||||
normal! v
|
||||
" We decree that 'b' is the opposite of 'e', not 'w'. This makes more
|
||||
" sense at the end of a line and for underscore_notation.
|
||||
call s:CamelCaseMotion( 'e', a:count, 'iv' )
|
||||
else
|
||||
call s:CamelCaseMotion( 'b', 1, 'n' )
|
||||
normal! v
|
||||
call s:CamelCaseMotion( a:direction, a:count, 'iv' )
|
||||
endif
|
||||
endfunction
|
||||
" }}}1
|
||||
|
||||
"- mappings -------------------------------------------------------------------
|
||||
" The count is passed into the function through the special variable 'v:count1',
|
||||
" which is easier than misusing the :[range] that :call supports.
|
||||
" <C-U> is used to delete the unused range.
|
||||
" Another option would be to use a custom 'command! -count=1', but that doesn't
|
||||
" work with the normal mode mapping: When a count is typed before the mapping,
|
||||
" the ':' will convert a count of 3 into ':.,+2MyCommand', but ':3MyCommand'
|
||||
" would be required to use -count and <count>.
|
||||
"
|
||||
" We do not provide the fourth "backward to end" motion (,E), because it is
|
||||
" seldomly used.
|
||||
|
||||
function! s:CreateMotionMappings() "{{{1
|
||||
" Create mappings according to this template:
|
||||
" (* stands for the mode [nov], ? for the underlying motion [wbe].)
|
||||
"
|
||||
" *noremap <script> <Plug>CamelCaseMotion_? :<C-U>call <SID>CamelCaseMotion('?',v:count1,'*')<CR>
|
||||
" if ! hasmapto('<Plug>CamelCaseMotion_?', '*')
|
||||
" *map <silent> ,? <Plug>CamelCaseMotion_?
|
||||
" endif
|
||||
|
||||
for l:mode in ['n', 'o', 'v']
|
||||
for l:motion in ['w', 'b', 'e']
|
||||
let l:targetMapping = '<Plug>CamelCaseMotion_' . l:motion
|
||||
execute l:mode . 'noremap <script> ' . l:targetMapping . ' :<C-U>call <SID>CamelCaseMotion(''' . l:motion . ''',v:count1,''' . l:mode . ''')<CR>'
|
||||
if ! hasmapto(l:targetMapping, l:mode)
|
||||
execute l:mode . 'map <silent> ,' . l:motion . ' ' . l:targetMapping
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endfunction
|
||||
" }}}1
|
||||
|
||||
" To create a text motion, a mapping for operator-pending mode needs to be
|
||||
" defined. This mapping should move the cursor according to the implemented
|
||||
" motion, or mark the covered text via a visual selection. As inner text motions
|
||||
" need to mark both to the left and right of the cursor position, the visual
|
||||
" selection needs to be used.
|
||||
"
|
||||
" VIM's built-in inner text objects also work in visual mode; they have
|
||||
" different behavior depending on whether visual mode has just been entered or
|
||||
" whether text has already been selected.
|
||||
" We deviate from that and always override the existing selection.
|
||||
function! s:CreateInnerMotionMappings() "{{{1
|
||||
" Create mappings according to this template:
|
||||
" (* stands for the mode [ov], ? for the underlying motion [wbe].)
|
||||
"
|
||||
" *noremap <script> <Plug>CamelCaseMotion_i? :<C-U>call <SID>CamelCaseInnerMotion('?',v:count1)<CR>
|
||||
" if ! hasmapto('<Plug>CamelCaseInnerMotion_i?', '*')
|
||||
" *map <silent> i,? <Plug>CamelCaseInnerMotion_i?
|
||||
" endif
|
||||
|
||||
for l:mode in ['o', 'v']
|
||||
for l:motion in ['w', 'b', 'e']
|
||||
let l:targetMapping = '<Plug>CamelCaseMotion_i' . l:motion
|
||||
execute l:mode . 'noremap <script> ' . l:targetMapping . ' :<C-U>call <SID>CamelCaseInnerMotion(''' . l:motion . ''',v:count1)<CR>'
|
||||
if ! hasmapto(l:targetMapping, l:mode)
|
||||
execute l:mode . 'map <silent> i,' . l:motion . ' ' . l:targetMapping
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endfunction
|
||||
" }}}1
|
||||
|
||||
call s:CreateMotionMappings()
|
||||
call s:CreateInnerMotionMappings()
|
||||
|
||||
" vim: set sts=4 sw=4 noexpandtab ff=unix fdm=marker :
|
||||
@ -1,536 +0,0 @@
|
||||
" cecutil.vim : save/restore window position
|
||||
" save/restore mark position
|
||||
" save/restore selected user maps
|
||||
" Author: Charles E. Campbell, Jr.
|
||||
" Version: 18h ASTRO-ONLY
|
||||
" Date: Apr 05, 2010
|
||||
"
|
||||
" 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)
|
||||
"redraw!|call inputsave()|call input("Press <cr> to continue")|call inputrestore()
|
||||
|
||||
" ---------------------------------------------------------------------
|
||||
" Load Once: {{{1
|
||||
if &cp || exists("g:loaded_cecutil")
|
||||
finish
|
||||
endif
|
||||
let g:loaded_cecutil = "v18h"
|
||||
let s:keepcpo = &cpo
|
||||
set cpo&vim
|
||||
"DechoRemOn
|
||||
|
||||
" =======================
|
||||
" 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=? RWP call RestoreWinPosn(<args>)
|
||||
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>)
|
||||
|
||||
com! -bar -nargs=1 WLR call s:WinLineRestore(<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(...)
|
||||
" echomsg "Decho: SaveWinPosn() a:0=".a:0
|
||||
if line("$") == 1 && getline(1) == ""
|
||||
" echomsg "Decho: 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(".") " save-window line in file
|
||||
let swcol = col(".") " save-window column in file
|
||||
if swcol >= col("$")
|
||||
let swcol= swcol + virtcol(".") - virtcol("$") " adjust for virtual edit (cursor past end-of-line)
|
||||
endif
|
||||
let swwline = winline() - 1 " save-window window line
|
||||
let swwcol = virtcol(".") - wincol() " save-window window column
|
||||
let savedposn = ""
|
||||
" echomsg "Decho: sw[".swline.",".swcol."] sww[".swwline.",".swwcol."]"
|
||||
let savedposn = "call GoWinbufnr(".winbufnr(0).")"
|
||||
let savedposn = savedposn."|".s:modifier.swline
|
||||
let savedposn = savedposn."|".s:modifier."norm! 0z\<cr>"
|
||||
if swwline > 0
|
||||
let savedposn= savedposn.":".s:modifier."call s:WinLineRestore(".(swwline+1).")\<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
|
||||
" echomsg "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
|
||||
" echomsg "Decho: b:cecutil_winpos{".b:cecutil_iwinposn."}[".b:cecutil_winposn{b:cecutil_iwinposn}."]"
|
||||
" else " Decho
|
||||
" echomsg "Decho: b:cecutil_iwinposn doesn't exist"
|
||||
" endif " Decho
|
||||
" echomsg "Decho: SaveWinPosn [".savedposn."]"
|
||||
return savedposn
|
||||
endfun
|
||||
|
||||
" ---------------------------------------------------------------------
|
||||
" RestoreWinPosn: {{{2
|
||||
" call RestoreWinPosn()
|
||||
" call RestoreWinPosn(winposn)
|
||||
fun! RestoreWinPosn(...)
|
||||
" echomsg "Decho: RestoreWinPosn() a:0=".a:0
|
||||
" echomsg "Decho: getline(1)<".getline(1).">"
|
||||
" echomsg "Decho: line(.)=".line(".")
|
||||
if line("$") == 1 && getline(1) == ""
|
||||
" echomsg "Decho: 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}")
|
||||
" echomsg "Decho: using stack b:cecutil_winposn{".b:cecutil_iwinposn."}<".b:cecutil_winposn{b:cecutil_iwinposn}.">"
|
||||
try
|
||||
exe s:modifier.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
|
||||
" echomsg "Decho: using input a:1<".a:1.">"
|
||||
" use window position passed to this function
|
||||
exe 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.
|
||||
let vekeep= &ve
|
||||
set ve=all
|
||||
if virtcol('.') > 1
|
||||
exe s:modifier."norm! hl"
|
||||
elseif virtcol(".") < virtcol("$")
|
||||
exe s:modifier."norm! lh"
|
||||
endif
|
||||
let &ve= vekeep
|
||||
|
||||
let &l:so = so_keep
|
||||
let &l:siso = siso_keep
|
||||
let &l:ss = ss_keep
|
||||
|
||||
" echomsg "Decho: RestoreWinPosn"
|
||||
endfun
|
||||
|
||||
" ---------------------------------------------------------------------
|
||||
" s:WinLineRestore: {{{2
|
||||
fun! s:WinLineRestore(swwline)
|
||||
" echomsg "Decho: s:WinLineRestore(swwline=".a:swwline.")"
|
||||
while winline() < a:swwline
|
||||
let curwinline= winline()
|
||||
exe s:modifier."norm! \<c-y>"
|
||||
if curwinline == winline()
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
" echomsg "Decho: s:WinLineRestore"
|
||||
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
|
||||
Loading…
Reference in New Issue
Block a user