696 lines
24 KiB
VimL
696 lines
24 KiB
VimL
if exists("g:loaded_nerdtree_ui_glue_autoload")
|
|
finish
|
|
endif
|
|
let g:loaded_nerdtree_ui_glue_autoload = 1
|
|
|
|
" FUNCTION: nerdtree#ui_glue#createDefaultBindings() {{{1
|
|
function! nerdtree#ui_glue#createDefaultBindings()
|
|
let s = '<SNR>' . s:SID() . '_'
|
|
|
|
call NERDTreeAddKeyMap({ 'key': '<MiddleMouse>', 'scope': 'all', 'callback': s . 'handleMiddleMouse' })
|
|
call NERDTreeAddKeyMap({ 'key': '<LeftRelease>', 'scope': "all", 'callback': s."handleLeftClick" })
|
|
call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "DirNode", 'callback': s."activateDirNode" })
|
|
call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "FileNode", 'callback': s."activateFileNode" })
|
|
call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "Bookmark", 'callback': s."activateBookmark" })
|
|
call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "all", 'callback': s."activateAll" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'FileNode', 'callback': s."customOpenFile"})
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'DirNode', 'callback': s."customOpenDir"})
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'Bookmark', 'callback': s."customOpenBookmark"})
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'all', 'callback': s."activateAll" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "DirNode", 'callback': s."activateDirNode" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "FileNode", 'callback': s."activateFileNode" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "Bookmark", 'callback': s."activateBookmark" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Bookmark", 'callback': s."previewBookmark" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "all", 'callback': s."activateAll" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': "Node", 'callback': s."openHSplit" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': "Node", 'callback': s."openVSplit" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Node", 'callback': s."previewNodeCurrent" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': "Node", 'callback': s."previewNodeVSplit" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': "Node", 'callback': s."previewNodeHSplit" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenRecursively, 'scope': "DirNode", 'callback': s."openNodeRecursively" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdir, 'scope': 'all', 'callback': s . 'upDirCurrentRootClosed' })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdirKeepOpen, 'scope': 'all', 'callback': s . 'upDirCurrentRootOpen' })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChangeRoot, 'scope': 'Node', 'callback': s . 'chRoot' })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChdir, 'scope': "Node", 'callback': s."chCwd" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapQuit, 'scope': "all", 'callback': s."closeTreeWindow" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCWD, 'scope': "all", 'callback': "nerdtree#ui_glue#chRootCwd" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefreshRoot, 'scope': "all", 'callback': s."refreshRoot" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefresh, 'scope': "Node", 'callback': s."refreshCurrent" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapHelp, 'scope': "all", 'callback': s."displayHelp" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleZoom, 'scope': "all", 'callback': s."toggleZoom" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleHidden, 'scope': "all", 'callback': s."toggleShowHidden" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFilters, 'scope': "all", 'callback': s."toggleIgnoreFilter" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFiles, 'scope': "all", 'callback': s."toggleShowFiles" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleBookmarks, 'scope': "all", 'callback': s."toggleShowBookmarks" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseDir, 'scope': "Node", 'callback': s."closeCurrentDir" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseChildren, 'scope': "DirNode", 'callback': s."closeChildren" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapMenu, 'scope': "Node", 'callback': s."showMenu" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpParent, 'scope': "Node", 'callback': s."jumpToParent" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpFirstChild, 'scope': "Node", 'callback': s."jumpToFirstChild" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpLastChild, 'scope': "Node", 'callback': s."jumpToLastChild" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpRoot, 'scope': "all", 'callback': s."jumpToRoot" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpNextSibling, 'scope': "Node", 'callback': s."jumpToNextSibling" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpPrevSibling, 'scope': "Node", 'callback': s."jumpToPrevSibling" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': 'Node', 'callback': s . 'openInNewTab' })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Node', 'callback': s . 'openInNewTabSilent' })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': 'Bookmark', 'callback': s . 'openInNewTab' })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Bookmark', 'callback': s . 'openInNewTabSilent' })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': "DirNode", 'callback': s."openExplorer" })
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': "FileNode", 'callback': s."openExplorer" })
|
|
|
|
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapDeleteBookmark, 'scope': "Bookmark", 'callback': s."deleteBookmark" })
|
|
endfunction
|
|
|
|
|
|
"SECTION: Interface bindings {{{1
|
|
"============================================================
|
|
|
|
"FUNCTION: s:customOpenFile() {{{1
|
|
" Open file node with the "custom" key, initially <CR>.
|
|
function! s:customOpenFile(node)
|
|
call a:node.activate(s:initCustomOpenArgs().file)
|
|
endfunction
|
|
|
|
"FUNCTION: s:customOpenDir() {{{1
|
|
" Open directory node with the "custom" key, initially <CR>.
|
|
function! s:customOpenDir(node)
|
|
call s:activateDirNode(a:node, s:initCustomOpenArgs().dir)
|
|
endfunction
|
|
|
|
"FUNCTION: s:customOpenBookmark() {{{1
|
|
" Open bookmark node with the "custom" key, initially <CR>.
|
|
function! s:customOpenBookmark(node)
|
|
if a:node.path.isDirectory
|
|
call a:node.activate(b:NERDTree, s:initCustomOpenArgs().dir)
|
|
else
|
|
call a:node.activate(b:NERDTree, s:initCustomOpenArgs().file)
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:initCustomOpenArgs() {{{1
|
|
" Make sure NERDTreeCustomOpenArgs has needed keys
|
|
function! s:initCustomOpenArgs()
|
|
let g:NERDTreeCustomOpenArgs = get(g:, 'NERDTreeCustomOpenArgs', {})
|
|
return extend(g:NERDTreeCustomOpenArgs, {'file':{'reuse': 'all', 'where': 'p'}, 'dir':{}}, 'keep')
|
|
endfunction
|
|
|
|
"FUNCTION: s:activateAll() {{{1
|
|
"handle the user activating the updir line
|
|
function! s:activateAll()
|
|
if getline(".") ==# g:NERDTreeUI.UpDirLine()
|
|
return nerdtree#ui_glue#upDir(0)
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:activateDirNode(directoryNode, options) {{{1
|
|
" Open a directory with optional options
|
|
function! s:activateDirNode(directoryNode, ...)
|
|
|
|
if a:directoryNode.isRoot() && a:directoryNode.isOpen
|
|
call nerdtree#echo('cannot close tree root')
|
|
return
|
|
endif
|
|
|
|
call a:directoryNode.activate((a:0 > 0) ? a:1 : {})
|
|
endfunction
|
|
|
|
"FUNCTION: s:activateFileNode() {{{1
|
|
"handle the user activating a tree node
|
|
function! s:activateFileNode(node)
|
|
call a:node.activate({'reuse': 'all', 'where': 'p'})
|
|
endfunction
|
|
|
|
"FUNCTION: s:activateBookmark(bookmark) {{{1
|
|
"handle the user activating a bookmark
|
|
function! s:activateBookmark(bm)
|
|
call a:bm.activate(b:NERDTree, !a:bm.path.isDirectory ? {'where': 'p'} : {})
|
|
endfunction
|
|
|
|
" FUNCTION: nerdtree#ui_glue#bookmarkNode(name) {{{1
|
|
" Associate the current node with the given name
|
|
function! nerdtree#ui_glue#bookmarkNode(...)
|
|
let currentNode = g:NERDTreeFileNode.GetSelected()
|
|
if currentNode != {}
|
|
let name = a:1
|
|
if empty(name)
|
|
let name = currentNode.path.getLastPathComponent(0)
|
|
endif
|
|
try
|
|
call currentNode.bookmark(name)
|
|
call b:NERDTree.render()
|
|
catch /^NERDTree.IllegalBookmarkNameError/
|
|
call nerdtree#echo("bookmark names must not contain spaces")
|
|
endtry
|
|
else
|
|
call nerdtree#echo("select a node first")
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:chCwd(node) {{{1
|
|
function! s:chCwd(node)
|
|
try
|
|
call a:node.path.changeToDir()
|
|
catch /^NERDTree.PathChangeError/
|
|
call nerdtree#echoWarning("could not change cwd")
|
|
endtry
|
|
endfunction
|
|
|
|
" FUNCTION: s:chRoot(node) {{{1
|
|
" changes the current root to the selected one
|
|
function! s:chRoot(node)
|
|
call b:NERDTree.changeRoot(a:node)
|
|
endfunction
|
|
|
|
" FUNCTION: s:nerdtree#ui_glue#chRootCwd() {{{1
|
|
" Change the NERDTree root to match the current working directory.
|
|
function! nerdtree#ui_glue#chRootCwd()
|
|
NERDTreeCWD
|
|
endfunction
|
|
|
|
" FUNCTION: nnerdtree#ui_glue#clearBookmarks(bookmarks) {{{1
|
|
function! nerdtree#ui_glue#clearBookmarks(bookmarks)
|
|
if a:bookmarks ==# ''
|
|
let currentNode = g:NERDTreeFileNode.GetSelected()
|
|
if currentNode != {}
|
|
call currentNode.clearBookmarks()
|
|
endif
|
|
else
|
|
for name in split(a:bookmarks, ' ')
|
|
let bookmark = g:NERDTreeBookmark.BookmarkFor(name)
|
|
call bookmark.delete()
|
|
endfor
|
|
endif
|
|
call b:NERDTree.root.refresh()
|
|
call b:NERDTree.render()
|
|
endfunction
|
|
|
|
" FUNCTION: s:closeChildren(node) {{{1
|
|
" closes all childnodes of the current node
|
|
function! s:closeChildren(node)
|
|
call a:node.closeChildren()
|
|
call b:NERDTree.render()
|
|
call a:node.putCursorHere(0, 0)
|
|
endfunction
|
|
|
|
" FUNCTION: s:closeCurrentDir(node) {{{1
|
|
" Close the parent directory of the current node.
|
|
function! s:closeCurrentDir(node)
|
|
|
|
if a:node.isRoot()
|
|
call nerdtree#echo('cannot close parent of tree root')
|
|
return
|
|
endif
|
|
|
|
let l:parent = a:node.parent
|
|
|
|
while l:parent.isCascadable()
|
|
let l:parent = l:parent.parent
|
|
endwhile
|
|
|
|
if l:parent.isRoot()
|
|
call nerdtree#echo('cannot close tree root')
|
|
return
|
|
endif
|
|
|
|
call l:parent.close()
|
|
call b:NERDTree.render()
|
|
call l:parent.putCursorHere(0, 0)
|
|
endfunction
|
|
|
|
" FUNCTION: s:closeTreeWindow() {{{1
|
|
" close the tree window
|
|
function! s:closeTreeWindow()
|
|
if b:NERDTree.isWinTree() && b:NERDTree.previousBuf() != -1
|
|
exec "buffer " . b:NERDTree.previousBuf()
|
|
else
|
|
if winnr("$") > 1
|
|
call g:NERDTree.Close()
|
|
else
|
|
call nerdtree#echo("Cannot close last window")
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:deleteBookmark(bookmark) {{{1
|
|
" Prompt the user to confirm the deletion of the selected bookmark.
|
|
function! s:deleteBookmark(bookmark)
|
|
let l:message = "Delete the bookmark \"" . a:bookmark.name
|
|
\ . "\" from the bookmark list?"
|
|
|
|
let l:choices = "&Yes\n&No"
|
|
|
|
echo | redraw
|
|
let l:selection = confirm(l:message, l:choices, 1, 'Warning')
|
|
|
|
if l:selection != 1
|
|
call nerdtree#echo('bookmark not deleted')
|
|
return
|
|
endif
|
|
|
|
try
|
|
call a:bookmark.delete()
|
|
silent call b:NERDTree.root.refresh()
|
|
call b:NERDTree.render()
|
|
echo | redraw
|
|
catch /^NERDTree/
|
|
call nerdtree#echoWarning('could not remove bookmark')
|
|
endtry
|
|
endfunction
|
|
|
|
" FUNCTION: s:displayHelp() {{{1
|
|
" toggles the help display
|
|
function! s:displayHelp()
|
|
call b:NERDTree.ui.toggleHelp()
|
|
call b:NERDTree.render()
|
|
call b:NERDTree.ui.centerView()
|
|
endfunction
|
|
|
|
" FUNCTION: s:findAndRevealPath(pathStr) {{{1
|
|
function! s:findAndRevealPath(pathStr)
|
|
let l:pathStr = !empty(a:pathStr) ? a:pathStr : expand('%:p')
|
|
if !filereadable(l:pathStr)
|
|
let l:pathStr = fnamemodify(l:pathStr, ':h')
|
|
endif
|
|
|
|
if empty(l:pathStr)
|
|
call nerdtree#echoWarning('no file for the current buffer')
|
|
return
|
|
endif
|
|
|
|
try
|
|
let l:pathStr = g:NERDTreePath.Resolve(l:pathStr)
|
|
let l:pathObj = g:NERDTreePath.New(l:pathStr)
|
|
catch /^NERDTree.InvalidArgumentsError/
|
|
call nerdtree#echoWarning('invalid path')
|
|
return
|
|
endtry
|
|
|
|
if !g:NERDTree.ExistsForTab()
|
|
try
|
|
let l:cwd = g:NERDTreePath.New(getcwd())
|
|
catch /^NERDTree.InvalidArgumentsError/
|
|
call nerdtree#echo('current directory does not exist.')
|
|
let l:cwd = l:pathObj.getParent()
|
|
endtry
|
|
|
|
if l:pathObj.isUnder(l:cwd)
|
|
call g:NERDTreeCreator.CreateTabTree(l:cwd.str())
|
|
else
|
|
call g:NERDTreeCreator.CreateTabTree(l:pathObj.getParent().str())
|
|
endif
|
|
else
|
|
NERDTreeFocus
|
|
|
|
if !l:pathObj.isUnder(b:NERDTree.root.path)
|
|
call s:chRoot(g:NERDTreeDirNode.New(l:pathObj.getParent(), b:NERDTree))
|
|
endif
|
|
endif
|
|
|
|
if l:pathObj.isHiddenUnder(b:NERDTree.root.path)
|
|
call b:NERDTree.ui.setShowHidden(1)
|
|
endif
|
|
|
|
let l:node = b:NERDTree.root.reveal(l:pathObj)
|
|
call b:NERDTree.render()
|
|
call l:node.putCursorHere(1, 0)
|
|
endfunction
|
|
|
|
"FUNCTION: s:handleLeftClick() {{{1
|
|
"Checks if the click should open the current node
|
|
function! s:handleLeftClick()
|
|
let currentNode = g:NERDTreeFileNode.GetSelected()
|
|
if currentNode != {}
|
|
|
|
"the dir arrows are multibyte chars, and vim's string functions only
|
|
"deal with single bytes - so split the line up with the hack below and
|
|
"take the line substring manually
|
|
let line = split(getline(line(".")), '\zs')
|
|
let startToCur = ""
|
|
for i in range(0,len(line)-1)
|
|
let startToCur .= line[i]
|
|
endfor
|
|
|
|
if currentNode.path.isDirectory
|
|
if startToCur =~# g:NERDTreeUI.MarkupReg() && startToCur =~# '[+~'.g:NERDTreeDirArrowExpandable.g:NERDTreeDirArrowCollapsible.'] \?$'
|
|
call currentNode.activate()
|
|
return
|
|
endif
|
|
endif
|
|
|
|
if (g:NERDTreeMouseMode ==# 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode ==# 3
|
|
let char = strpart(startToCur, strlen(startToCur)-1, 1)
|
|
if char !~# g:NERDTreeUI.MarkupReg()
|
|
if currentNode.path.isDirectory
|
|
call currentNode.activate()
|
|
else
|
|
call currentNode.activate({'reuse': 'all', 'where': 'p'})
|
|
endif
|
|
return
|
|
endif
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:handleMiddleMouse() {{{1
|
|
function! s:handleMiddleMouse()
|
|
|
|
" A middle mouse click does not automatically position the cursor as one
|
|
" would expect. Forcing the execution of a regular left mouse click here
|
|
" fixes this problem.
|
|
execute "normal! \<LeftMouse>"
|
|
|
|
let l:currentNode = g:NERDTreeFileNode.GetSelected()
|
|
if empty(l:currentNode)
|
|
call nerdtree#echoError('use the pointer to select a node')
|
|
return
|
|
endif
|
|
|
|
if l:currentNode.path.isDirectory
|
|
call l:currentNode.openExplorer()
|
|
else
|
|
call l:currentNode.open({'where': 'h'})
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: nerdtree#ui_glue#invokeKeyMap(key) {{{1
|
|
"this is needed since I cant figure out how to invoke dict functions from a
|
|
"key map
|
|
function! nerdtree#ui_glue#invokeKeyMap(key)
|
|
call g:NERDTreeKeyMap.Invoke(a:key)
|
|
endfunction
|
|
|
|
" FUNCTION: s:jumpToFirstChild(node) {{{1
|
|
function! s:jumpToFirstChild(node)
|
|
call s:jumpToChild(a:node, 0)
|
|
endfunction
|
|
|
|
" FUNCTION: s:jumpToLastChild(node) {{{1
|
|
function! s:jumpToLastChild(node)
|
|
call s:jumpToChild(a:node, 1)
|
|
endfunction
|
|
|
|
" FUNCTION: s:jumpToChild(node, last) {{{1
|
|
" Jump to the first or last child node at the same file system level.
|
|
"
|
|
" Args:
|
|
" node: the node on which the cursor currently sits
|
|
" last: 1 (true) if jumping to last child, 0 (false) if jumping to first
|
|
function! s:jumpToChild(node, last)
|
|
let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
|
|
|
|
if l:node.isRoot()
|
|
return
|
|
endif
|
|
|
|
let l:parent = l:node.parent
|
|
let l:children = l:parent.getVisibleChildren()
|
|
|
|
let l:target = a:last ? l:children[len(l:children) - 1] : l:children[0]
|
|
|
|
call l:target.putCursorHere(1, 0)
|
|
call b:NERDTree.ui.centerView()
|
|
endfunction
|
|
|
|
" FUNCTION: s:jumpToParent(node) {{{1
|
|
" Move the cursor to the parent of the specified node. For a cascade, move to
|
|
" the parent of the cascade's first node. At the root node, do nothing.
|
|
function! s:jumpToParent(node)
|
|
let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
|
|
|
|
if l:node.isRoot()
|
|
return
|
|
endif
|
|
|
|
if empty(l:node.parent)
|
|
call nerdtree#echo('could not jump to parent node')
|
|
return
|
|
endif
|
|
|
|
call l:node.parent.putCursorHere(1, 0)
|
|
call b:NERDTree.ui.centerView()
|
|
endfunction
|
|
|
|
" FUNCTION: s:jumpToRoot() {{{1
|
|
" moves the cursor to the root node
|
|
function! s:jumpToRoot()
|
|
call b:NERDTree.root.putCursorHere(1, 0)
|
|
call b:NERDTree.ui.centerView()
|
|
endfunction
|
|
|
|
" FUNCTION: s:jumpToNextSibling(node) {{{1
|
|
function! s:jumpToNextSibling(node)
|
|
call s:jumpToSibling(a:node, 1)
|
|
endfunction
|
|
|
|
" FUNCTION: s:jumpToPrevSibling(node) {{{1
|
|
function! s:jumpToPrevSibling(node)
|
|
call s:jumpToSibling(a:node, 0)
|
|
endfunction
|
|
|
|
" FUNCTION: s:jumpToSibling(node, forward) {{{1
|
|
" Move the cursor to the next or previous node at the same file system level.
|
|
"
|
|
" Args:
|
|
" node: the node on which the cursor currently sits
|
|
" forward: 0 to jump to previous sibling, 1 to jump to next sibling
|
|
function! s:jumpToSibling(node, forward)
|
|
let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
|
|
let l:sibling = l:node.findSibling(a:forward)
|
|
|
|
if empty(l:sibling)
|
|
return
|
|
endif
|
|
|
|
call l:sibling.putCursorHere(1, 0)
|
|
call b:NERDTree.ui.centerView()
|
|
endfunction
|
|
|
|
" FUNCTION: nerdtree#ui_glue#openBookmark(name) {{{1
|
|
" Open the Bookmark that has the specified name. This function provides the
|
|
" implementation for the ":OpenBookmark" command.
|
|
function! nerdtree#ui_glue#openBookmark(name)
|
|
try
|
|
let l:bookmark = g:NERDTreeBookmark.BookmarkFor(a:name)
|
|
catch /^NERDTree.BookmarkNotFoundError/
|
|
call nerdtree#echoError('bookmark "' . a:name . '" not found')
|
|
return
|
|
endtry
|
|
if l:bookmark.path.isDirectory
|
|
call l:bookmark.open(b:NERDTree)
|
|
else
|
|
call l:bookmark.open(b:NERDTree, {'where': 'p'})
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:openHSplit(target) {{{1
|
|
function! s:openHSplit(target)
|
|
call a:target.activate({'where': 'h'})
|
|
endfunction
|
|
|
|
" FUNCTION: s:openVSplit(target) {{{1
|
|
function! s:openVSplit(target)
|
|
call a:target.activate({'where': 'v'})
|
|
endfunction
|
|
|
|
" FUNCTION: s:openExplorer(node) {{{1
|
|
function! s:openExplorer(node)
|
|
call a:node.openExplorer()
|
|
endfunction
|
|
|
|
" FUNCTION: s:openInNewTab(target) {{{1
|
|
function! s:openInNewTab(target)
|
|
let l:opener = g:NERDTreeOpener.New(a:target.path, {'where': 't'})
|
|
call l:opener.open(a:target)
|
|
endfunction
|
|
|
|
" FUNCTION: s:openInNewTabSilent(target) {{{1
|
|
function! s:openInNewTabSilent(target)
|
|
let l:opener = g:NERDTreeOpener.New(a:target.path, {'where': 't', 'stay': 1})
|
|
call l:opener.open(a:target)
|
|
endfunction
|
|
|
|
" FUNCTION: s:openNodeRecursively(node) {{{1
|
|
function! s:openNodeRecursively(node)
|
|
call nerdtree#echo("Recursively opening node. Please wait...")
|
|
call a:node.openRecursively()
|
|
call b:NERDTree.render()
|
|
call nerdtree#echo("")
|
|
endfunction
|
|
|
|
" FUNCTION: s:previewBookmark(bookmark) {{{1
|
|
function! s:previewBookmark(bookmark)
|
|
if a:bookmark.path.isDirectory
|
|
execute 'NERDTreeFind '.a:bookmark.path.str()
|
|
else
|
|
call a:bookmark.activate(b:NERDTree, {'stay': 1, 'where': 'p', 'keepopen': 1})
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:previewNodeCurrent(node) {{{1
|
|
function! s:previewNodeCurrent(node)
|
|
call a:node.open({'stay': 1, 'where': 'p', 'keepopen': 1})
|
|
endfunction
|
|
|
|
"FUNCTION: s:previewNodeHSplit(node) {{{1
|
|
function! s:previewNodeHSplit(node)
|
|
call a:node.open({'stay': 1, 'where': 'h', 'keepopen': 1})
|
|
endfunction
|
|
|
|
"FUNCTION: s:previewNodeVSplit(node) {{{1
|
|
function! s:previewNodeVSplit(node)
|
|
call a:node.open({'stay': 1, 'where': 'v', 'keepopen': 1})
|
|
endfunction
|
|
|
|
" FUNCTION: nerdtree#ui_glue#revealBookmark(name) {{{1
|
|
" put the cursor on the node associate with the given name
|
|
function! nerdtree#ui_glue#revealBookmark(name)
|
|
try
|
|
let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0, b:NERDTree)
|
|
call targetNode.putCursorHere(0, 1)
|
|
catch /^NERDTree.BookmarkNotFoundError/
|
|
call nerdtree#echo("Bookmark isnt cached under the current root")
|
|
endtry
|
|
endfunction
|
|
|
|
" FUNCTION: s:refreshRoot() {{{1
|
|
" Reloads the current root. All nodes below this will be lost and the root dir
|
|
" will be reloaded.
|
|
function! s:refreshRoot()
|
|
if !g:NERDTree.IsOpen()
|
|
return
|
|
endif
|
|
call nerdtree#echo("Refreshing the root node. This could take a while...")
|
|
|
|
let l:curWin = winnr()
|
|
call nerdtree#exec(g:NERDTree.GetWinNum() . "wincmd w", 1)
|
|
call b:NERDTree.root.refresh()
|
|
call b:NERDTree.render()
|
|
redraw
|
|
call nerdtree#exec(l:curWin . "wincmd w", 1)
|
|
call nerdtree#echo("")
|
|
endfunction
|
|
|
|
" FUNCTION: s:refreshCurrent(node) {{{1
|
|
" refreshes the root for the current node
|
|
function! s:refreshCurrent(node)
|
|
let node = a:node
|
|
if !node.path.isDirectory
|
|
let node = node.parent
|
|
endif
|
|
|
|
call nerdtree#echo("Refreshing node. This could take a while...")
|
|
call node.refresh()
|
|
call b:NERDTree.render()
|
|
call nerdtree#echo("")
|
|
endfunction
|
|
|
|
" FUNCTION: nerdtree#ui_glue#setupCommands() {{{1
|
|
function! nerdtree#ui_glue#setupCommands()
|
|
command! -n=? -complete=dir -bar NERDTree :call g:NERDTreeCreator.CreateTabTree('<args>')
|
|
command! -n=? -complete=dir -bar NERDTreeToggle :call g:NERDTreeCreator.ToggleTabTree('<args>')
|
|
command! -n=0 -bar NERDTreeClose :call g:NERDTree.Close()
|
|
command! -n=1 -complete=customlist,nerdtree#completeBookmarks -bar NERDTreeFromBookmark call g:NERDTreeCreator.CreateTabTree('<args>')
|
|
command! -n=0 -bar NERDTreeMirror call g:NERDTreeCreator.CreateMirror()
|
|
command! -n=? -complete=file -bar NERDTreeFind call s:findAndRevealPath('<args>')
|
|
command! -n=0 -bar NERDTreeRefreshRoot call s:refreshRoot()
|
|
command! -n=0 -bar NERDTreeFocus call NERDTreeFocus()
|
|
command! -n=0 -bar NERDTreeCWD call NERDTreeCWD()
|
|
endfunction
|
|
|
|
" Function: s:SID() {{{1
|
|
function s:SID()
|
|
if !exists("s:sid")
|
|
let s:sid = matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
|
|
endif
|
|
return s:sid
|
|
endfun
|
|
|
|
" FUNCTION: s:showMenu(node) {{{1
|
|
function! s:showMenu(node)
|
|
let mc = g:NERDTreeMenuController.New(g:NERDTreeMenuItem.AllEnabled())
|
|
call mc.showMenu()
|
|
endfunction
|
|
|
|
" FUNCTION: s:toggleIgnoreFilter() {{{1
|
|
function! s:toggleIgnoreFilter()
|
|
call b:NERDTree.ui.toggleIgnoreFilter()
|
|
endfunction
|
|
|
|
" FUNCTION: s:toggleShowBookmarks() {{{1
|
|
function! s:toggleShowBookmarks()
|
|
call b:NERDTree.ui.toggleShowBookmarks()
|
|
endfunction
|
|
|
|
" FUNCTION: s:toggleShowFiles() {{{1
|
|
function! s:toggleShowFiles()
|
|
call b:NERDTree.ui.toggleShowFiles()
|
|
endfunction
|
|
|
|
" FUNCTION: s:toggleShowHidden() {{{1
|
|
" toggles the display of hidden files
|
|
function! s:toggleShowHidden()
|
|
call b:NERDTree.ui.toggleShowHidden()
|
|
endfunction
|
|
|
|
" FUNCTION: s:toggleZoom() {{{1
|
|
function! s:toggleZoom()
|
|
call b:NERDTree.ui.toggleZoom()
|
|
endfunction
|
|
|
|
" FUNCTION: nerdtree#ui_glue#upDir(preserveState) {{{1
|
|
" Move the NERDTree up one level.
|
|
"
|
|
" Args:
|
|
" preserveState: if 1, the current root is left open when the new tree is
|
|
" rendered; if 0, the current root node is closed
|
|
function! nerdtree#ui_glue#upDir(preserveState)
|
|
|
|
try
|
|
call b:NERDTree.root.cacheParent()
|
|
catch /^NERDTree.CannotCacheParentError/
|
|
call nerdtree#echo('already at root directory')
|
|
return
|
|
endtry
|
|
|
|
let l:oldRoot = b:NERDTree.root
|
|
let l:newRoot = b:NERDTree.root.parent
|
|
|
|
call l:newRoot.open()
|
|
call l:newRoot.transplantChild(l:oldRoot)
|
|
|
|
if !a:preserveState
|
|
call l:oldRoot.close()
|
|
endif
|
|
|
|
call b:NERDTree.changeRoot(l:newRoot)
|
|
call l:oldRoot.putCursorHere(0, 0)
|
|
endfunction
|
|
|
|
" FUNCTION: s:upDirCurrentRootOpen() {{{1
|
|
function! s:upDirCurrentRootOpen()
|
|
call nerdtree#ui_glue#upDir(1)
|
|
endfunction
|
|
|
|
" FUNCTION: s:upDirCurrentRootClosed() {{{1
|
|
function! s:upDirCurrentRootClosed()
|
|
call nerdtree#ui_glue#upDir(0)
|
|
endfunction
|
|
|
|
" vim: set sw=4 sts=4 et fdm=marker:
|