path: root/.vim/plugin/NERD_tree.vim

" vim global plugin that provides a nice tree explorer
" Last Change:  26 august 2007
" Maintainer:   Martin Grenfell <martin_grenfell at msn dot com>
let s:NERD_tree_version = '2.6.2'

"A help file is installed when the script is run for the first time. 
"Go :help NERD_tree.txt to see it.

" SECTION: Script init stuff {{{1
"============================================================
if exists("loaded_nerd_tree")
    finish
endif
if v:version < 700
    echoerr "NERDTree: this plugin requires vim >= 7. DOWNLOAD IT! You'll thank me later!"
    finish
endif
let loaded_nerd_tree = 1
"Function: s:InitVariable() function {{{2
"This function is used to initialise a given variable to a given value. The
"variable is only initialised if it does not exist prior
"
"Args:
"var: the name of the var to be initialised
"value: the value to initialise var to
"
"Returns:
"1 if the var is set, 0 otherwise
function! s:InitVariable(var, value)
    if !exists(a:var)
        exec 'let ' . a:var . ' = ' . "'" . a:value . "'"
        return 1
    endif
    return 0
endfunction

"SECTION: Init variable calls and other random constants {{{2 
call s:InitVariable("g:NERDChristmasTree", 1)
call s:InitVariable("g:NERDTreeAutoCenter", 1)
call s:InitVariable("g:NERDTreeAutoCenterThreshold", 3)
call s:InitVariable("g:NERDTreeCaseSensitiveSort", 0)
call s:InitVariable("g:NERDTreeChDirMode", 1)
if !exists("g:NERDTreeIgnore")
    let g:NERDTreeIgnore = ['\~$']
endif
call s:InitVariable("g:NERDTreeHighlightCursorline", 1)
call s:InitVariable("g:NERDTreeMouseMode", 1)
call s:InitVariable("g:NERDTreeNotificationThreshold", 100)
call s:InitVariable("g:NERDTreeShowHidden", 0)
call s:InitVariable("g:NERDTreeShowFiles", 1)
call s:InitVariable("g:NERDTreeSortDirs", 1)

if !exists("g:NERDTreeSortOrder")
    let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$',  '\.bak$', '\~$']
else
    "if there isnt a * in the sort sequence then add one 
    if count(g:NERDTreeSortOrder, '*') < 1
        call add(g:NERDTreeSortOrder, '*')
    endif
endif

"we need to use this number many times for sorting... so we calculate it only
"once here 
let g:NERDTreeSortStarIndex = index(g:NERDTreeSortOrder, '*')

call s:InitVariable("g:NERDTreeSplitVertical", 1)
call s:InitVariable("g:NERDTreeWinPos", 1)
call s:InitVariable("g:NERDTreeWinSize", 31)

let s:running_windows = has("win16") || has("win32") || has("win64")

"init the shell command that will be used to remove dir trees 
"
"Note: the space after the command is important
if s:running_windows
    call s:InitVariable("g:NERDTreeRemoveDirCmd", 'rmdir /s /q ')
else
    call s:InitVariable("g:NERDTreeRemoveDirCmd", 'rm -rf ')
endif


"SECTION: Init variable calls for key mappings {{{2 
call s:InitVariable("g:NERDTreeMapActivateNode", "o")
call s:InitVariable("g:NERDTreeMapChangeRoot", "C")
call s:InitVariable("g:NERDTreeMapChdir", "cd")
call s:InitVariable("g:NERDTreeMapCloseChildren", "X")
call s:InitVariable("g:NERDTreeMapCloseDir", "x")
call s:InitVariable("g:NERDTreeMapExecute", "!")
call s:InitVariable("g:NERDTreeMapFilesystemMenu", "m")
call s:InitVariable("g:NERDTreeMapHelp", "?")
call s:InitVariable("g:NERDTreeMapJumpFirstChild", "K")
call s:InitVariable("g:NERDTreeMapJumpLastChild", "J")
call s:InitVariable("g:NERDTreeMapJumpNextSibling", "<C-j>")
call s:InitVariable("g:NERDTreeMapJumpParent", "p")
call s:InitVariable("g:NERDTreeMapJumpPrevSibling", "<C-k>")
call s:InitVariable("g:NERDTreeMapJumpRoot", "P")
call s:InitVariable("g:NERDTreeMapOpenExpl", "e")
call s:InitVariable("g:NERDTreeMapOpenInTab", "t")
call s:InitVariable("g:NERDTreeMapOpenInTabSilent", "T")
call s:InitVariable("g:NERDTreeMapOpenRecursively", "O")
call s:InitVariable("g:NERDTreeMapOpenSplit", "<tab>")
call s:InitVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
call s:InitVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
call s:InitVariable("g:NERDTreeMapQuit", "q")
call s:InitVariable("g:NERDTreeMapRefresh", "r")
call s:InitVariable("g:NERDTreeMapRefreshRoot", "R")
call s:InitVariable("g:NERDTreeMapToggleFiles", "F")
call s:InitVariable("g:NERDTreeMapToggleFilters", "f")
call s:InitVariable("g:NERDTreeMapToggleHidden", "H")
call s:InitVariable("g:NERDTreeMapUpdir", "u")
call s:InitVariable("g:NERDTreeMapUpdirKeepOpen", "U")

"SECTION: Script level variable declaration{{{2
let s:escape_chars =  " `|\"~'#"
let s:NERDTreeWinName = '_NERD_tree_'

"init all the nerd tree markup 
let s:tree_vert = '|'
let s:tree_vert_last = '`'
let s:tree_wid = 2
let s:tree_wid_str = '  '
let s:tree_wid_strM1 = ' '
let s:tree_dir_open = '~'
let s:tree_dir_closed = '+'
let s:tree_file = '-'
let s:tree_markup_reg = '[ \-+~`|]'
let s:tree_markup_reg_neg = '[^ \-+~`|]'
let s:tree_up_dir_line = '.. (up a dir)'
let s:tree_RO_str = ' [RO]'
let s:tree_RO_str_reg = ' \[RO\]'

let s:os_slash = '/'
if s:running_windows
    let s:os_slash = '\'
endif


" SECTION: Commands {{{1
"============================================================
"init the command that users start the nerd tree with 
command! -n=? -complete=dir NERDTree :call s:InitNerdTree('<args>')
command! -n=? -complete=dir NERDTreeToggle :call s:Toggle('<args>')
" SECTION: Auto commands {{{1
"============================================================
"Save the cursor position whenever we close the nerd tree
exec "autocmd BufWinLeave *". s:NERDTreeWinName ."* :call <SID>SaveScreenState()"

"SECTION: Classes {{{1
"============================================================
"CLASS: oTreeFileNode {{{2
"This class is the parent of the oTreeDirNode class and constitures the
"'Component' part of the composite design pattern between the treenode
"classes.
"============================================================
let s:oTreeFileNode = {}
"FUNCTION: oTreeFileNode.CompareNodes {{{3 
"This is supposed to be a class level method but i cant figure out how to
"get func refs to work from a dict.. 
"
"A class level method that compares two nodes
"
"Args:
"n1, n2: the 2 nodes to compare
function! s:CompareNodes(n1, n2)
    return a:n1.path.CompareTo(a:n2.path)
endfunction

"FUNCTION: oTreeFileNode.Delete {{{3 
"Removes this node from the tree and calls the Delete method for its path obj
function! s:oTreeFileNode.Delete() dict
    call self.path.Delete()
    call self.parent.RemoveChild(self)
endfunction

"FUNCTION: oTreeFileNode.Equals(treenode) {{{3 
"
"Compares this treenode to the input treenode and returns 1 if they are the
"same node.
"
"Use this method instead of ==  because sometimes when the treenodes contain
"many children, vim seg faults when doing ==
"
"Args:
"treenode: the other treenode to compare to
function! s:oTreeFileNode.Equals(treenode) dict
    return self.path.Str(1) == a:treenode.path.Str(1)
endfunction

"FUNCTION: oTreeFileNode.FindNode(path) {{{3 
"Returns self if this node.path.Equals the given path.
"Returns {} if not equal.
"
"Args:
"path: the path object to compare against
function! s:oTreeFileNode.FindNode(path) dict
    if a:path.Equals(self.path)
        return self
    endif
    return {}
endfunction
"FUNCTION: oTreeFileNode.FindOpenDirSiblingWithChildren(direction) {{{3 
"
"Finds the next sibling for this node in the indicated direction. This sibling
"must be a directory and may/may not have children as specified.
"
"Args:
"direction: 0 if you want to find the previous sibling, 1 for the next sibling
"
"Return:
"a treenode object or {} if no appropriate sibling could be found
function! s:oTreeFileNode.FindOpenDirSiblingWithChildren(direction) dict
    "if we have no parent then we can have no siblings 
    if self.parent != {}
        let nextSibling = self.FindSibling(a:direction)

        while nextSibling != {}
            if nextSibling.path.isDirectory && nextSibling.HasVisibleChildren() && nextSibling.isOpen
                return nextSibling
            endif
            let nextSibling = nextSibling.FindSibling(a:direction)
        endwhile
    endif

    return {}
endfunction
"FUNCTION: oTreeFileNode.FindSibling(direction) {{{3 
"
"Finds the next sibling for this node in the indicated direction  
"
"Args:
"direction: 0 if you want to find the previous sibling, 1 for the next sibling
"
"Return:
"a treenode object or {} if no sibling could be found
function! s:oTreeFileNode.FindSibling(direction) dict
    "if we have no parent then we can have no siblings 
    if self.parent != {}

        "get the index of this node in its parents children 
        let siblingIndx = self.parent.GetChildIndex(self.path)

        if siblingIndx != -1
            "move a long to the next potential sibling node 
            let siblingIndx = a:direction == 1 ? siblingIndx+1 : siblingIndx-1

            "keep moving along to the next sibling till we find one that is valid 
            let numSiblings = self.parent.GetChildCount()
            while siblingIndx >= 0 && siblingIndx < numSiblings

                "if the next node is not an ignored node (i.e. wont show up in the
                "view) then return it
                if self.parent.children[siblingIndx].path.Ignore() == 0
                    return self.parent.children[siblingIndx]
                endif

                "go to next node 
                let siblingIndx = a:direction == 1 ? siblingIndx+1 : siblingIndx-1
            endwhile
        endif
    endif

    return {}
endfunction

"FUNCTION: oTreeFileNode.IsVisible() {{{3 
"returns 1 if this node should be visible according to the tree filters and
"hidden file filters (and their on/off status)
function! s:oTreeFileNode.IsVisible() dict
    return !self.path.Ignore()
endfunction


"FUNCTION: oTreeFileNode.IsRoot() {{{3 
"returns 1 if this node is t:NERDTreeRoot 
function! s:oTreeFileNode.IsRoot() dict
    if !s:TreeExistsForTab()
        throw "NERDTree.TreeFileNode.IsRoot exception: No tree exists for the current tab"
    endif
    return self.Equals(t:NERDTreeRoot)
endfunction

"FUNCTION: oTreeFileNode.New(path) {{{3 
"Returns a new TreeNode object with the given path and parent
"
"Args:
"path: a path object representing the full filesystem path to the file/dir that the node represents
function! s:oTreeFileNode.New(path) dict
    if a:path.isDirectory
        return s:oTreeDirNode.New(a:path)
    else
        let newTreeNode = {}
        let newTreeNode = copy(self)
        let newTreeNode.path = a:path
        let newTreeNode.parent = {}
        return newTreeNode
    endif
endfunction

"FUNCTION: oTreeFileNode.Rename {{{3 
"Calls the rename method for this nodes path obj 
function! s:oTreeFileNode.Rename(newName) dict
    call self.path.Rename(a:newName)
    call self.parent.RemoveChild(self)

    let parentPath = self.path.GetPathTrunk()
    let newParent = t:NERDTreeRoot.FindNode(parentPath)

    if newParent != {}
        call newParent.CreateChild(self.path, 1)
    endif
endfunction

"FUNCTION: oTreeFileNode.StrDisplay() {{{3 
"
"Returns a string that specifies how the node should be represented as a
"string
"
"Return:
"a string that can be used in the view to represent this node
function! s:oTreeFileNode.StrDisplay() dict
    return self.path.StrDisplay()
endfunction

"CLASS: oTreeDirNode {{{2
"This class is a child of the oTreeFileNode class and constitutes the
"'Composite' part of the composite design pattern between the treenode
"classes.
"============================================================
let s:oTreeDirNode = copy(s:oTreeFileNode)
"FUNCTION: oTreeDirNode.AddChild(treenode, inOrder) {{{3 
"Adds the given treenode to the list of children for this node
"
"Args:
"-treenode: the node to add
"-inOrder: 1 if the new node should be inserted in sorted order
function! s:oTreeDirNode.AddChild(treenode, inOrder) dict
    call add(self.children, a:treenode)
    let a:treenode.parent = self

    if a:inOrder
        call self.SortChildren()
    endif
endfunction

"FUNCTION: oTreeDirNode.Close {{{3 
"Closes this directory
function! s:oTreeDirNode.Close() dict
    let self.isOpen = 0
endfunction

"FUNCTION: oTreeDirNode.CloseChildren {{{3 
"Closes all the child dir nodes of this node 
function! s:oTreeDirNode.CloseChildren() dict
    for i in self.children
        if i.path.isDirectory
            call i.Close()
            call i.CloseChildren()
        endif
    endfor
endfunction

"FUNCTION: oTreeDirNode.CreateChild(path, inOrder) {{{3 
"Instantiates a new child node for this node with the given path. The new
"nodes parent is set to this node.
"
"Args:
"path: a Path object that this node will represent/contain
"inOrder: 1 if the new node should be inserted in sorted order
"
"Returns:
"the newly created node
function! s:oTreeDirNode.CreateChild(path, inOrder) dict
    let newTreeNode = s:oTreeFileNode.New(a:path)
    call self.AddChild(newTreeNode, a:inOrder)
    return newTreeNode
endfunction

"FUNCTION: oTreeDirNode.FindNode(path) {{{3 
"Will find one of the children (recursively) that has the given path
"
"Args:
"path: a path object
unlet s:oTreeDirNode.FindNode
function! s:oTreeDirNode.FindNode(path) dict
    if a:path.Equals(self.path)
        return self
    endif
    if stridx(a:path.Str(1), self.path.Str(1), 0) == -1
        return {}
    endif

    if self.path.isDirectory
        for i in self.children
            let retVal = i.FindNode(a:path)
            if retVal != {}
                return retVal
            endif
        endfor
    endif
    return {}
endfunction

"FUNCTION: oTreeDirNode.GetChildDirs() {{{3 
"Returns the number of children this node has
function! s:oTreeDirNode.GetChildCount() dict
    return len(self.children)
endfunction

"FUNCTION: oTreeDirNode.GetChildDirs() {{{3 
"Returns an array of all children of this node that are directories
"
"Return:
"an array of directory treenodes
function! s:oTreeDirNode.GetChildDirs() dict
    let toReturn = []
    for i in self.children
        if i.path.isDirectory
            call add(toReturn, i)
        endif
    endfor
    return toReturn
endfunction

"FUNCTION: oTreeDirNode.GetChildFiles() {{{3 
"Returns an array of all children of this node that are files
"
"Return:
"an array of file treenodes
function! s:oTreeDirNode.GetChildFiles() dict
    let toReturn = []
    for i in self.children
        if i.path.isDirectory == 0
            call add(toReturn, i)
        endif
    endfor
    return toReturn
endfunction

"FUNCTION: oTreeDirNode.GetChild(path) {{{3 
"Returns child node of this node that has the given path or {} if no such node
"exists.
"
"This function doesnt not recurse into child dir nodes
"
"Args:
"path: a path object
function! s:oTreeDirNode.GetChild(path) dict
    if stridx(a:path.Str(1), self.path.Str(1), 0) == -1
        return {}
    endif

    let index = self.GetChildIndex(a:path)
    if index == -1
        return {}
    else
        return self.children[index]
    endif

endfunction

"FUNCTION: oTreeDirNode.GetChildByIndex(indx, visible) {{{3 
"returns the child at the given index
"Args:
"indx: the index to get the child from
"visible: 1 if only the visible children array should be used, 0 if all the
"children should be searched.
function! s:oTreeDirNode.GetChildByIndex(indx, visible) dict
    let array_to_search = a:visible? self.GetVisibleChildren() : self.children
    if a:indx > len(array_to_search)
        throw "NERDTree.TreeDirNode.InvalidArguments exception. Index is out of bounds."
    endif
    return array_to_search[a:indx]
endfunction

"FUNCTION: oTreeDirNode.GetChildIndex(path) {{{3 
"Returns the index of the child node of this node that has the given path or
"-1 if no such node exists.
"
"This function doesnt not recurse into child dir nodes
"
"Args:
"path: a path object
function! s:oTreeDirNode.GetChildIndex(path) dict
    if stridx(a:path.Str(1), self.path.Str(1), 0) == -1
        return -1
    endif

    "do a binary search for the child 
    let a = 0
    let z = self.GetChildCount()
    while a < z
        let mid = (a+z)/2
        let diff = a:path.CompareTo(self.children[mid].path)

        if diff == -1
            let z = mid
        elseif diff == 1
            let a = mid+1
        else
            return mid
        endif
    endwhile
    return -1
endfunction

"FUNCTION: oTreeDirNode.GetVisibleChildCount() {{{3 
"Returns the number of visible children this node has
function! s:oTreeDirNode.GetVisibleChildCount() dict
    return len(self.GetVisibleChildren())
endfunction

"FUNCTION: oTreeDirNode.GetVisibleChildren() {{{3 
"Returns a list of children to display for this node, in the correct order
"
"Return:
"an array of treenodes
function! s:oTreeDirNode.GetVisibleChildren() dict
    let toReturn = []
    for i in self.children
        if i.path.Ignore() == 0
            call add(toReturn, i)
        endif
    endfor
    return toReturn
endfunction

"FUNCTION: oTreeDirNode.HasVisibleChildren {{{3 
"returns 1 if this node has any childre, 0 otherwise..
function! s:oTreeDirNode.HasVisibleChildren()
    return self.GetChildCount() != 0
endfunction

"FUNCTION: oTreeDirNode.InitChildren {{{3 
"Removes all childen from this node and re-reads them
"
"Args:
"silent: 1 if the function should not echo any "please wait" messages for
"large directories
"
"Return: the number of child nodes read
function! s:oTreeDirNode.InitChildren(silent) dict
    "remove all the current child nodes 
    let self.children = []

    "get an array of all the files in the nodes dir 
    let filesStr = globpath(self.path.GetDir(0), '*') . "\n" . globpath(self.path.GetDir(0), '.*')
    let files = split(filesStr, "\n")

    if !a:silent && len(files) > g:NERDTreeNotificationThreshold
        call s:Echo("Please wait, caching a large dir ...")
    endif

    let invalidFilesFound = 0
    for i in files

        "filter out the .. and . directories 
        if i !~ '\.\.$' && i !~ '\.$'

            "put the next file in a new node and attach it 
            try
                let path = s:oPath.New(i)
                call self.CreateChild(path, 0)
            catch /^NERDTree.Path.InvalidArguments/
                let invalidFilesFound = 1
            endtry
        endif
    endfor

    call self.SortChildren()

    if !a:silent && len(files) > g:NERDTreeNotificationThreshold
        call s:Echo("Please wait, caching a large dir ...")
        call s:Echo("Please wait, caching a large dir ... DONE (". self.GetChildCount() ." nodes cached).")
    endif

    if invalidFilesFound
        call s:EchoWarning("some files could not be loaded into the NERD tree")
    endif
    return self.GetChildCount()
endfunction
"FUNCTION: oTreeDirNode.New(path) {{{3 
"Returns a new TreeNode object with the given path and parent
"
"Args:
"path: a path object representing the full filesystem path to the file/dir that the node represents
unlet s:oTreeDirNode.New
function! s:oTreeDirNode.New(path) dict
    if a:path.isDirectory != 1
        throw "NERDTree.TreeDirNode.InvalidArguments exception. A TreeDirNode object must be instantiated with a directory Path object."
    endif

    let newTreeNode = copy(self)
    let newTreeNode.path = a:path

    let newTreeNode.isOpen = 0
    let newTreeNode.children = []

    let newTreeNode.parent = {}

    return newTreeNode
endfunction
"FUNCTION: oTreeDirNode.Open {{{3 
"Reads in all this nodes children
"
"Return: the number of child nodes read
function! s:oTreeDirNode.Open() dict
    let self.isOpen = 1
    if self.children == []
        return self.InitChildren(0)
    else
        return 0
    endif
endfunction

"FUNCTION: oTreeDirNode.OpenRecursively {{{3 
"Opens this treenode and all of its children whose paths arent 'ignored'
"because of the file filters.
"
"This method is actually a wrapper for the OpenRecursively2 method which does
"the work.
function! s:oTreeDirNode.OpenRecursively() dict
    call self.OpenRecursively2(1)
endfunction

"FUNCTION: oTreeDirNode.OpenRecursively2 {{{3 
"Dont call this method from outside this object.
"
"Opens this all children of this treenode recursively if either:
"   *they arent filtered by file filters
"   *a:forceOpen is 1
"
"Args:
"forceOpen: 1 if this node should be opened regardless of file filters
function! s:oTreeDirNode.OpenRecursively2(forceOpen) dict
    if self.path.Ignore() == 0 || a:forceOpen
        let self.isOpen = 1
        if self.children == []
            call self.InitChildren(1)
        endif

        for i in self.children
            if i.path.isDirectory == 1
                call i.OpenRecursively2(0) 
            endif
        endfor
    endif
endfunction

"FUNCTION: oTreeDirNode.Refresh {{{3 
function! s:oTreeDirNode.Refresh() dict
    let newChildNodes = []
    let invalidFilesFound = 0

    "go thru all the files/dirs under this node 
    let filesStr = globpath(self.path.GetDir(0), '*') . "\n" . globpath(self.path.GetDir(0), '.*')
    let files = split(filesStr, "\n")
    for i in files
        if i !~ '\.\.$' && i !~ '\.$'

            try
                "create a new path and see if it exists in this nodes children 
                let path = s:oPath.New(i)
                let newNode = self.GetChild(path)
                if newNode != {} 

                    "if the existing node is a dir can be refreshed then
                    "refresh it   
                    if newNode.path.isDirectory && (!empty(newNode.children) || newNode.isOpen == 1)
                        call newNode.Refresh()

                    "if we have a filenode then refresh the path 
                    elseif newNode.path.isDirectory == 0
                        call newNode.path.Refresh()
                    endif

                    call add(newChildNodes, newNode)

                "the node doesnt exist so create it 
                else
                    let newNode = s:oTreeFileNode.New(path)
                    let newNode.parent = self
                    call add(newChildNodes, newNode)
                endif


            catch /^NERDTree.InvalidArguments/
                let invalidFilesFound = 1
            endtry
        endif
    endfor

    "swap this nodes children out for the children we just read/refreshed 
    let self.children = newChildNodes
    call self.SortChildren()
    
    if invalidFilesFound
        call s:EchoWarning("some files could not be loaded into the NERD tree")
    endif
endfunction

"FUNCTION: oTreeDirNode.RemoveChild {{{3 
"
"Removes the given treenode from this nodes set of children
"
"Args:
"treenode: the node to remove
"
"Throws a NERDTree.TreeDirNode exception if the given treenode is not found
function! s:oTreeDirNode.RemoveChild(treenode) dict
    for i in range(0, self.GetChildCount()-1)
        if self.children[i].Equals(a:treenode)
            call remove(self.children, i)
            return
        endif
    endfor

    throw "NERDTree.TreeDirNode exception: child node was not found"
endfunction

"FUNCTION: oTreeDirNode.SortChildren {{{3 
"
"Sorts the children of this node according to alphabetical order and the
"directory priority.
"
function! s:oTreeDirNode.SortChildren() dict
    let CompareFunc = function("s:CompareNodes")
    call sort(self.children, CompareFunc)
endfunction

"FUNCTION: oTreeDirNode.ToggleOpen {{{3 
"Opens this directory if it is closed and vice versa
function! s:oTreeDirNode.ToggleOpen() dict
    if self.isOpen == 1
        call self.Close()
    else
        call self.Open()
    endif
endfunction

"FUNCTION: oTreeDirNode.TransplantChild(newNode) {{{3 
"Replaces the child of this with the given node (where the child node's full
"path matches a:newNode's fullpath). The search for the matching node is
"non-recursive
"
"Arg:
"newNode: the node to graft into the tree 
function! s:oTreeDirNode.TransplantChild(newNode) dict
    for i in range(0, self.GetChildCount()-1)
        if self.children[i].Equals(a:newNode)
            let self.children[i] = a:newNode
            let a:newNode.parent = self
            break
        endif
    endfor
endfunction
"============================================================
"CLASS: oPath {{{2
"============================================================
let s:oPath = {} 
"FUNCTION: oPath.ChangeToDir() {{{3 
function! s:oPath.ChangeToDir() dict
    let dir = self.Str(1)
    if self.isDirectory == 0
        let dir = self.GetPathTrunk().Str(1)
    endif

    try
        execute "cd " . dir
        call s:Echo("CWD is now: " . getcwd())
    catch
        throw "NERDTree.Path.Change exception: cannot change to " . dir
    endtry
endfunction

"FUNCTION: oPath.ChopTrailingSlash(str) {{{3 
function! s:oPath.ChopTrailingSlash(str) dict
    if a:str =~ '\/$'
        return substitute(a:str, "\/$", "", "")
    else
        return substitute(a:str, "\\$", "", "")
    endif
endfunction

"FUNCTION: oPath.CompareTo() {{{3 
"
"Compares this oPath to the given path and returns 0 if they are equal, -1 if
"this oPath is "less than" the given path, or 1 if it is "greater".
"
"Args:
"path: the path object to compare this to
"
"Return:
"1, -1 or 0
function! s:oPath.CompareTo(path) dict
    let thisPath = self.GetLastPathComponent(1)
    let thatPath = a:path.GetLastPathComponent(1)

    "if the paths are the same then clearly we return 0 
    if thisPath == thatPath
        return 0
    endif

    let thisSS = self.GetSortOrderIndex()
    let thatSS = a:path.GetSortOrderIndex()
    
    "compare the sort sequences, if they are different then the return
    "value is easy 
    if thisSS < thatSS
        return -1
    elseif thisSS > thatSS 
        return 1
    else
        "if the sort sequences are the same then compare the paths
        "alphabetically 
        let pathCompare = g:NERDTreeCaseSensitiveSort ? thisPath <# thatPath : thisPath <? thatPath
        if pathCompare
            return -1
        else
            return 1
        endif
    endif
endfunction

"FUNCTION: oPath.Create() {{{3 
"
"Factory method.
"
"Creates a path object with the given path. The path is also created on the
"filesystem. If the path already exists, a NERDTree.Path.Exists exception is
"thrown. If any other errors occur, a NERDTree.Path exception is thrown.
"
"Args:
"fullpath: the full filesystem path to the file/dir to create
function! s:oPath.Create(fullpath) dict
    "bail if the a:fullpath already exists 
    if isdirectory(a:fullpath) || filereadable(a:fullpath)
        throw "NERDTree.Path.Exists Exception: Directory Exists: '" . a:fullpath . "'"
    endif

    "get the unix version of the input path 
    let fullpath = a:fullpath
    if s:running_windows
        let fullpath = s:oPath.WinToUnixPath(fullpath)
    endif

    try 

        "if it ends with a slash, assume its a dir create it 
        if fullpath =~ '\/$'
            "whack the trailing slash off the end if it exists 
            let fullpath = substitute(fullpath, '\/$', '', '')

            call mkdir(fullpath, 'p')

        "assume its a file and create 
        else
            call writefile([], fullpath)
        endif
    catch /.*/
        throw "NERDTree.Path Exception: Could not create path: '" . a:fullpath . "'"
    endtry

    return s:oPath.New(fullpath)
endfunction

"FUNCTION: oPath.Delete() {{{3 
"
"Deletes the file represented by this path.
"Deletion of directories is not supported
"
"Throws NERDTree.Path.Deletion exceptions
function! s:oPath.Delete() dict
    if self.isDirectory 

        let cmd = ""
        if s:running_windows
            "if we are runnnig windows then put quotes around the pathstring 
            let cmd = g:NERDTreeRemoveDirCmd . self.StrForOS(1)
        else
            let cmd = g:NERDTreeRemoveDirCmd . self.StrForOS(0)
        endif
        let success = system(cmd)

        if v:shell_error != 0
            throw "NERDTree.Path.Deletion Exception: Could not delete directory: '" . self.StrForOS(0) . "'"
        endif
    else
        let success = delete(self.Str(0))
        if success != 0
            throw "NERDTree.Path.Deletion Exception: Could not delete file: '" . self.Str(0) . "'"
        endif
    endif
endfunction

"FUNCTION: oPath.GetDir() {{{3 
"
"Gets the directory part of this path. If this path IS a directory then the
"whole thing is returned
"
"Args:
"trailingSlash: 1 if a trailing slash is to be stuck on the end of the
"returned dir
"
"Return:
"string
function! s:oPath.GetDir(trailingSlash) dict
    let toReturn = ''
    if self.isDirectory
        let toReturn = '/'. join(self.pathSegments, '/')
    else
        let toReturn = '/'. join(self.pathSegments[0:-2], '/')
    endif

    if a:trailingSlash && toReturn !~ '\/$'
        let toReturn = toReturn . '/'
    endif

    return toReturn
endfunction

"FUNCTION: oPath.GetFile() {{{3 
"
"Returns the file component of this path. 
"
"Throws NERDTree.IllegalOperation exception if the node is a directory node 
function! s:oPath.GetFile() dict
    if self.isDirectory == 0
        return self.GetLastPathComponent(0)
    else
        throw "NERDTree.Path.IllegalOperation Exception: cannot get file component of a directory path"
    endif
endfunction

"FUNCTION: oPath.GetLastPathComponent(dirSlash) {{{3 
"
"Gets the last part of this path.   
"
"Args:
"dirSlash: if 1 then a trailing slash will be added to the returned value for
"directory nodes.
function! s:oPath.GetLastPathComponent(dirSlash) dict
    if empty(self.pathSegments)
        return ''
    endif
    let toReturn = self.pathSegments[-1]
    if a:dirSlash && self.isDirectory
        let toReturn = toReturn . '/'
    endif
    return toReturn
endfunction

"FUNCTION: oPath.GetPathTrunk() {{{3 
"Gets the path without the last segment on the end.
function! s:oPath.GetPathTrunk() dict
    return s:oPath.New('/' . join(self.pathSegments[0:-2], '/'))
endfunction

"FUNCTION: oPath.GetSortOrderIndex() {{{3 
"returns the index of the pattern in g:NERDTreeSortOrder that this path matches 
function! s:oPath.GetSortOrderIndex() dict
    let i = 0
    while i < len(g:NERDTreeSortOrder)
        if  self.GetLastPathComponent(1) =~ g:NERDTreeSortOrder[i]
            return i
        endif
        let i = i + 1
    endwhile
    return g:NERDTreeSortStarIndex
endfunction

"FUNCTION: oPath.Ignore() {{{3 
"returns true if this path should be ignored
function! s:oPath.Ignore() dict
    let lastPathComponent = self.GetLastPathComponent(0)

    "filter out the user specified paths to ignore 
    if t:NERDTreeIgnoreEnabled
        for i in g:NERDTreeIgnore
            if lastPathComponent =~ i
                return 1
            endif
        endfor
    endif

    "dont show hidden files unless instructed to 
    if g:NERDTreeShowHidden == 0 && lastPathComponent =~ '^\.'
        return 1
    endif

    if g:NERDTreeShowFiles == 0 && self.isDirectory == 0
        return 1
    endif

    return 0
endfunction

"FUNCTION: oPath.Equals() {{{3 
"
"Determines whether 2 path objecs are "equal".
"They are equal if the paths they represent are the same
"
"Args:
"path: the other path obj to compare this with
function! s:oPath.Equals(path) dict
    let this = self.ChopTrailingSlash(self.Str(1))
    let that = self.ChopTrailingSlash(a:path.Str(1))
    return this == that
endfunction

"FUNCTION: oPath.New() {{{3 
"
"The Constructor for the Path object
"Throws NERDTree.Path.InvalidArguments exception.
function! s:oPath.New(fullpath) dict
    let newPath = copy(self)

    call newPath.ReadInfoFromDisk(a:fullpath)

    return newPath
endfunction

"FUNCTION: oPath.NewMinimal() {{{3 
function! s:oPath.NewMinimal(fullpath) dict
    let newPath = copy(self)

    let fullpath = a:fullpath

    if s:running_windows
        let fullpath = s:oPath.WinToUnixPath(fullpath)
    endif

    let newPath.pathSegments = split(fullpath, '/')

    let newPath.isDirectory = isdirectory(fullpath)

    return newPath
endfunction

"FUNCTION: oPath.ReadInfoFromDisk(fullpath) {{{3 
"
"
"Throws NERDTree.Path.InvalidArguments exception.
function! s:oPath.ReadInfoFromDisk(fullpath) dict
    let fullpath = a:fullpath

    if s:running_windows
        let fullpath = s:oPath.WinToUnixPath(fullpath)
    endif

    let self.pathSegments = split(fullpath, '/')

    let self.isReadOnly = 0
    if isdirectory(fullpath)
        let self.isDirectory = 1
    elseif filereadable(fullpath)
        let self.isDirectory = 0
        let self.isReadOnly = filewritable(fullpath) == 0
    else
        throw "NERDTree.Path.InvalidArguments Exception: Invalid path = " . fullpath
    endif

    "grab the last part of the path (minus the trailing slash) 
    let lastPathComponent = self.GetLastPathComponent(0)

    "get the path to the new node with the parent dir fully resolved 
    let hardPath = resolve(self.StrTrunk()) . '/' . lastPathComponent

    "if  the last part of the path is a symlink then flag it as such 
    let self.isSymLink = (resolve(hardPath) != hardPath)
    if self.isSymLink
        let self.symLinkDest = resolve(fullpath)

        "if the link is a dir then slap a / on the end of its dest 
        if isdirectory(self.symLinkDest) 
            
            "we always wanna treat MS windows shortcuts as files for
            "simplicity 
            if hardPath !~ '\.lnk$'

                let self.symLinkDest = self.symLinkDest . '/'
            endif
        endif
    endif
endfunction

"FUNCTION: oPath.Refresh() {{{3 
function! s:oPath.Refresh() dict
    call self.ReadInfoFromDisk(self.Str(0))
endfunction

"FUNCTION: oPath.Rename() {{{3 
"
"Renames this node on the filesystem
function! s:oPath.Rename(newPath) dict
    if a:newPath == ''
        throw "NERDTree.Path.InvalidArguments exception. Invalid newPath for renaming = ". a:newPath
    endif

    let success =  rename(self.Str(0), a:newPath)
    if success != 0
        throw "NERDTree.Path.Rename Exception: Could not rename: '" . self.Str(0) . "'" . 'to:' . a:newPath
    endif
    let self.pathSegments = split(a:newPath, '/')
endfunction

"FUNCTION: oPath.Str(esc) {{{3 
"
"Gets the actual string path that this obj represents.
"
"Args:
"esc: if 1 then all the tricky chars in the returned string will be escaped      
function! s:oPath.Str(esc) dict
    let toReturn = '/' . join(self.pathSegments, '/')
    if self.isDirectory && toReturn != '/'
        let toReturn  = toReturn . '/'
    endif

    if a:esc
        let toReturn = escape(toReturn, s:escape_chars)
    endif
    return toReturn
endfunction

"FUNCTION: oPath.StrAbs() {{{3 
"
"Returns a string representing this path with all the symlinks resolved
"
"Return:
"string
function! s:oPath.StrAbs() dict
    return resolve(self.Str(1))
endfunction

"FUNCTION: oPath.StrDisplay() {{{3 
"
"Returns a string that specifies how the path should be represented as a
"string
"
"Return:
"a string that can be used in the view to represent this path
function! s:oPath.StrDisplay() dict
    let toReturn = self.GetLastPathComponent(1)

    if self.isSymLink
        let toReturn .=  ' -> ' . self.symLinkDest
    endif

    if self.isReadOnly
        let toReturn .=  s:tree_RO_str
    endif

    return toReturn
endfunction

"FUNCTION: oPath.StrForEditCmd() {{{3 
"
"Return: the string for this path that is suitable to be used with the :edit
"command
function! s:oPath.StrForEditCmd() dict
    if s:running_windows
        return self.StrForOS(0)
    else
        return self.Str(1)
    endif

endfunction
"FUNCTION: oPath.StrForOS(esc) {{{3 
"
"Gets the string path for this path object that is appropriate for the OS.
"EG, in windows c:\foo\bar
"    in *nix  /foo/bar
"
"Args: 
"esc: if 1 then all the tricky chars in the returned string will be
" escaped. If we are running windows then the str is double quoted instead.
function! s:oPath.StrForOS(esc) dict
    let lead = s:os_slash

    "if we are running windows then slap a drive letter on the front 
    if s:running_windows
        let lead = strpart(getcwd(), 0, 2) . s:os_slash
    endif

    let toReturn = lead . join(self.pathSegments, s:os_slash)

    if a:esc
        if s:running_windows
            let toReturn = '"' .  toReturn . '"'
        else
            let toReturn = escape(toReturn, s:escape_chars)
        endif
    endif
    return toReturn
endfunction

"FUNCTION: oPath.StrTrunk() {{{3 
"Gets the path without the last segment on the end.
function! s:oPath.StrTrunk() dict
    return '/' . join(self.pathSegments[0:-2], '/')
endfunction

"FUNCTION: oPath.WinToUnixPath(pathstr){{{3
"Takes in a windows path and returns the unix equiv
"
"A class level method
"
"Args:
"pathstr: the windows path to convert
function! s:oPath.WinToUnixPath(pathstr) dict
    let toReturn = a:pathstr

    "remove the x:\ of the front
    let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', "")

    "convert all \ chars to / 
    let toReturn = substitute(toReturn, '\', '/', "g")

    return toReturn
endfunction

" SECTION: General Functions {{{1
"============================================================
"FUNCTION: s:Abs(num){{{2
"returns the absolute value of the input
function! s:Abs(num) 
    if a:num > 0
        return a:num
    else
        return 0 - a:num
    end
endfunction

"FUNCTION: s:BufInWindows(bnum){{{2
"[[STOLEN FROM VTREEEXPLORER.VIM]]
"Determine the number of windows open to this buffer number. 
"Care of Yegappan Lakshman.  Thanks! 
"
"Args:
"bnum: the subject buffers buffer number
function! s:BufInWindows(bnum) 
    let cnt = 0
    let winnum = 1
    while 1
        let bufnum = winbufnr(winnum)
        if bufnum < 0
            break
        endif
        if bufnum == a:bnum
            let cnt = cnt + 1
        endif
        let winnum = winnum + 1
    endwhile

    return cnt
endfunction " >>>

"FUNCTION: s:InitNerdTree(dir) {{{2 
"Initialized the NERD tree, where the root will be initialized with the given
"directory
"
"Arg:
"dir: the dir to init the root with
function! s:InitNerdTree(dir)
    let dir = a:dir == '' ? expand('%:p:h') : a:dir
    let dir = resolve(dir)

    if !isdirectory(dir)
        call s:EchoWarning("Error reading: " . dir)
        return
    endif

    "if instructed to, then change the vim CWD to the dir the NERDTree is
    "inited in 
    if g:NERDTreeChDirMode != 0
        exec "cd " . dir
    endif

    let t:treeShowHelp = 0
    let t:NERDTreeIgnoreEnabled = 1

    if s:TreeExistsForTab()
        if s:IsTreeOpen()
            call s:CloseTree()
        endif
        unlet t:NERDTreeRoot
    endif

	let path = s:oPath.New(dir)
    let t:NERDTreeRoot = s:oTreeDirNode.New(path)
    call t:NERDTreeRoot.Open()

    call s:CreateTreeWin()

    call s:RenderView()
endfunction

" Function: s:InstallDocumentation(full_name, revision)   {{{2
"   Install help documentation.
" Arguments:
"   full_name: Full name of this vim plugin script, including path name.
"   revision:  Revision of the vim script. #version# mark in the document file
"              will be replaced with this string with 'v' prefix.
" Return:
"   1 if new document installed, 0 otherwise.
" Note: Cleaned and generalized by guo-peng Wen.
"
" Note about authorship: this function was taken from the vimspell plugin
" which can be found at http://www.vim.org/scripts/script.php?script_id=465
"
function! s:InstallDocumentation(full_name, revision)
    " Name of the document path based on the system we use:
    if has("vms")
         " No chance that this script will work with
         " VMS -  to much pathname juggling here.
         return 1
    elseif (has("unix"))
        " On UNIX like system, using forward slash:
        let l:slash_char = '/'
        let l:mkdir_cmd  = ':silent !mkdir -p '
    else
        " On M$ system, use backslash. Also mkdir syntax is different.
        " This should only work on W2K and up.
        let l:slash_char = '\'
        let l:mkdir_cmd  = ':silent !mkdir '
    endif

    let l:doc_path = l:slash_char . 'doc'
    let l:doc_home = l:slash_char . '.vim' . l:slash_char . 'doc'

    " Figure out document path based on full name of this script:
    let l:vim_plugin_path = fnamemodify(a:full_name, ':h')
    let l:vim_doc_path    = fnamemodify(a:full_name, ':h:h') . l:doc_path
    if (!(filewritable(l:vim_doc_path) == 2))
         "Doc path: " . l:vim_doc_path
        call s:Echo("Doc path: " . l:vim_doc_path)
        execute l:mkdir_cmd . '"' . l:vim_doc_path . '"'
        if (!(filewritable(l:vim_doc_path) == 2))
            " Try a default configuration in user home:
            let l:vim_doc_path = expand("~") . l:doc_home
            if (!(filewritable(l:vim_doc_path) == 2))
                execute l:mkdir_cmd . '"' . l:vim_doc_path . '"'
                if (!(filewritable(l:vim_doc_path) == 2))
                    " Put a warning:
                    call s:Echo("Unable to open documentation directory")
                    call s:Echo("type :help add-local-help for more information.")
                    call s:Echo(l:vim_doc_path)
                    return 0
                endif
            endif
        endif
    endif

    " Exit if we have problem to access the document directory:
    if (!isdirectory(l:vim_plugin_path) || !isdirectory(l:vim_doc_path) || filewritable(l:vim_doc_path) != 2)
        return 0
    endif

    " Full name of script and documentation file:
    let l:script_name = fnamemodify(a:full_name, ':t')
    let l:doc_name    = fnamemodify(a:full_name, ':t:r') . '.txt'
    let l:plugin_file = l:vim_plugin_path . l:slash_char . l:script_name
    let l:doc_file    = l:vim_doc_path    . l:slash_char . l:doc_name

    " Bail out if document file is still up to date:
    if (filereadable(l:doc_file) && getftime(l:plugin_file) < getftime(l:doc_file))
        return 0
    endif

    " Prepare window position restoring command:
    if (strlen(@%))
        let l:go_back = 'b ' . bufnr("%")
    else
        let l:go_back = 'enew!'
    endif

    " Create a new buffer & read in the plugin file (me):
    setl nomodeline
    exe 'enew!'
    exe 'r ' . l:plugin_file

    setl modeline
    let l:buf = bufnr("%")
    setl noswapfile modifiable

    norm zR
    norm gg

    " Delete from first line to a line starts with
    " === START_DOC
    1,/^=\{3,}\s\+START_DOC\C/ d

    " Delete from a line starts with
    " === END_DOC
    " to the end of the documents:
    /^=\{3,}\s\+END_DOC\C/,$ d

    " Remove fold marks:
    :%s/{{{[1-9]/    /

    " Add modeline for help doc: the modeline string is mangled intentionally
    " to avoid it be recognized by VIM:
    call append(line('$'), '')
    call append(line('$'), ' v' . 'im:tw=78:ts=8:ft=help:norl:')

    " Replace revision:
    "exe "normal :1s/#version#/ v" . a:revision . "/\<CR>"
    exe "normal! :%s/#version#/ v" . a:revision . "/\<CR>"

    " Save the help document:
    exe 'w! ' . l:doc_file
    exe l:go_back
    exe 'bw ' . l:buf

    " Build help tags:
    exe 'helptags ' . l:vim_doc_path

    return 1
endfunction

" Function: s:TreeExistsForTab()   {{{2
" Returns 1 if a nerd tree root exists in the current tab
function! s:TreeExistsForTab()
    return exists("t:NERDTreeRoot")
endfunction

" SECTION: Public Functions {{{1
"============================================================
"Returns the node that the cursor is currently on.
"
"If the cursor is not in the NERDTree window, it is temporarily put there.
"
"If no NERD tree window exists for the current tab, a NERDTree.NoTreeForTab
"exception is thrown.
"
"If the cursor is not on a node then an empty dictionary {} is returned.
function! NERDTreeGetCurrentNode()
    if !s:TreeExistsForTab() || !s:IsTreeOpen()
        throw "NERDTree.NoTreeForTab exception: there is no NERD tree open for the current tab"
    endif
    
    let winnr = winnr()
    if winnr != s:GetTreeWinNum()
        call s:PutCursorInTreeWin()
    endif

    let treenode = s:GetSelectedNode()

    if winnr != winnr()
        wincmd w
    endif

    return treenode
endfunction

"Returns the path object for the current node. 
"
"Subject to the same conditions as NERDTreeGetCurrentNode
function! NERDTreeGetCurrentPath()
    let node = NERDTreeGetCurrentNode()
    if node != {}
        return node.path
    else
        return {}
    endif
endfunction

" SECTION: View Functions {{{1
"============================================================
"FUNCTION: s:CenterView() {{{2 
"centers the nerd tree window around the cursor (provided the nerd tree
"options permit)
function! s:CenterView()
    if g:NERDTreeAutoCenter
        let current_line = winline()
        let lines_to_top = current_line
        let lines_to_bottom = winheight(s:GetTreeWinNum()) - current_line
        if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold
            normal! zz
        endif
    endif
endfunction

"FUNCTION: s:CloseTree() {{{2 
"Closes the NERD tree window
function! s:CloseTree()
    if !s:IsTreeOpen()
        throw "NERDTree.view.CloseTree exception: no NERDTree is open"
    endif

    if winnr("$") != 1
        execute s:GetTreeWinNum() . " wincmd w"
        close
        execute "wincmd p"
    else
        :q
    endif
endfunction

"FUNCTION: s:CreateTreeWin() {{{2 
"Inits the NERD tree window. ie. opens it, sizes it, sets all the local
"options etc
function! s:CreateTreeWin()
    "create the nerd tree window 
    let splitLocation = g:NERDTreeWinPos ? "topleft " : "belowright "
    let splitMode = g:NERDTreeSplitVertical ? "vertical " : ""
    let splitSize = g:NERDTreeWinSize 
    let t:NERDTreeWinName = localtime() . s:NERDTreeWinName
    let cmd = splitLocation . splitMode . splitSize . ' new ' . t:NERDTreeWinName
    silent! execute cmd

    setl winfixwidth

    "throwaway buffer options
    setlocal noswapfile
    setlocal buftype=nofile
    setlocal bufhidden=delete 
    setlocal nowrap
    setlocal foldcolumn=0
    setlocal nobuflisted
    setlocal nospell
    iabc <buffer>

    if g:NERDTreeHighlightCursorline
        setlocal cursorline
    endif

    " syntax highlighting
    if has("syntax") && exists("g:syntax_on") && !has("syntax_items")
        call s:SetupSyntaxHighlighting()
    endif

    " for line continuation
    let cpo_save1 = &cpo
    set cpo&vim

    call s:BindMappings()
endfunction

"FUNCTION: s:DrawTree {{{2 
"Draws the given node recursively
"
"Args:
"curNode: the node that is being rendered with this call
"depth: the current depth in the tree for this call
"drawText: 1 if we should actually draw the line for this node (if 0 then the
"child nodes are rendered only)
"vertMap: a binary array that indicates whether a vertical bar should be draw
"for each depth in the tree
"isLastChild:true if this curNode is the last child of its parent
function! s:DrawTree(curNode, depth, drawText, vertMap, isLastChild)
    if a:drawText == 1

        let treeParts = ''

        "get all the leading spaces and vertical tree parts for this line
        if a:depth > 1
            for j in a:vertMap[0:-2]
                if j == 1
                    let treeParts = treeParts . s:tree_vert . s:tree_wid_strM1
                else
                    let treeParts = treeParts . s:tree_wid_str
                endif
            endfor
        endif

        "get the last vertical tree part for this line which will be different
        "if this node is the last child of its parent
        if a:isLastChild
            let treeParts = treeParts . s:tree_vert_last
        else
            let treeParts = treeParts . s:tree_vert 
        endif


        "smack the appropriate dir/file symbol on the line before the file/dir
        "name itself
        if a:curNode.path.isDirectory
            if a:curNode.isOpen
                let treeParts = treeParts . s:tree_dir_open
            else
                let treeParts = treeParts . s:tree_dir_closed
            endif
        else
            let treeParts = treeParts . s:tree_file
        endif
        let line = treeParts . a:curNode.StrDisplay()

        call setline(line(".")+1, line)
        call cursor(line(".")+1, col("."))
    endif

    "if the node is an open dir, draw its children 
    if a:curNode.path.isDirectory == 1 && a:curNode.isOpen == 1 

        let childNodesToDraw = a:curNode.GetVisibleChildren()
        if len(childNodesToDraw) > 0

            "draw all the nodes children except the last 
            let lastIndx = len(childNodesToDraw)-1
            if lastIndx > 0
                for i in childNodesToDraw[0:lastIndx-1]
                    call s:DrawTree(i, a:depth + 1, 1, add(copy(a:vertMap), 1), 0)
                endfor
            endif

            "draw the last child, indicating that it IS the last 
            call s:DrawTree(childNodesToDraw[lastIndx], a:depth + 1, 1, add(copy(a:vertMap), 0), 1)
        endif
    endif
endfunction


"FUNCTION: s:DumpHelp  {{{2
"prints out the quick help 
function! s:DumpHelp()
    let old_h = @h
    if t:treeShowHelp == 1
        let @h=   "\" NERD tree (" . s:NERD_tree_version . ") quickhelp~\n"
        let @h=@h."\" ============================\n"
        let @h=@h."\" File node mappings~\n"
        let @h=@h."\" ". (g:NERDTreeMouseMode == 3 ? "single" : "double") ."-click,\n"
        let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n"
        let @h=@h."\" ". g:NERDTreeMapPreview .": preview \n"
        let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
        let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
        let @h=@h."\" middle-click,\n"
        let @h=@h."\" ". g:NERDTreeMapOpenSplit .": open split\n"
        let @h=@h."\" ". g:NERDTreeMapPreviewSplit .": preview split\n"
        let @h=@h."\" ". g:NERDTreeMapExecute.": Execute file\n"

        let @h=@h."\" \n\" ----------------------------\n"
        let @h=@h."\" Directory node mappings~\n"
        let @h=@h."\" ". (g:NERDTreeMouseMode == 1 ? "double" : "single") ."-click,\n"
        let @h=@h."\" ". g:NERDTreeMapActivateNode .": open/close node \n"
        let @h=@h."\" ". g:NERDTreeMapOpenRecursively .": recursively open node\n"
        let @h=@h."\" ". g:NERDTreeMapCloseDir .": close parent of node\n"
        let @h=@h."\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n"
        let @h=@h."\"    current node recursively\n"
        let @h=@h."\" middle-click,\n"
        let @h=@h."\" ". g:NERDTreeMapOpenExpl.": Open netrw for selected\n"
        let @h=@h."\"    node \n"

        let @h=@h."\" \n\" ----------------------------\n"
        let @h=@h."\" Tree navigation mappings~\n"
        let @h=@h."\" ". g:NERDTreeMapJumpRoot .": go to root\n"
        let @h=@h."\" ". g:NERDTreeMapJumpParent .": go to parent\n"
        let @h=@h."\" ". g:NERDTreeMapJumpFirstChild  .": go to first child\n"
        let @h=@h."\" ". g:NERDTreeMapJumpLastChild   .": go to last child\n"
        let @h=@h."\" ". g:NERDTreeMapJumpNextSibling .": go to next sibling\n"
        let @h=@h."\" ". g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n"

        let @h=@h."\" \n\" ----------------------------\n"
        let @h=@h."\" Filesystem mappings~\n"
        let @h=@h."\" ". g:NERDTreeMapChangeRoot .": change tree root to the\n"
        let @h=@h."\"    selected dir\n"
        let @h=@h."\" ". g:NERDTreeMapUpdir .": move tree root up a dir\n"
        let @h=@h."\" ". g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n"
        let @h=@h."\"    but leave old root open\n"
        let @h=@h."\" ". g:NERDTreeMapRefresh .": refresh cursor dir\n"
        let @h=@h."\" ". g:NERDTreeMapRefreshRoot .": refresh current root\n"
        let @h=@h."\" ". g:NERDTreeMapFilesystemMenu .": Show filesystem menu\n"
        let @h=@h."\" ". g:NERDTreeMapChdir .":change the CWD to the\n"
        let @h=@h."\"    selected dir\n"

        let @h=@h."\" \n\" ----------------------------\n"
        let @h=@h."\" Tree filtering mappings~\n"
        let @h=@h."\" ". g:NERDTreeMapToggleHidden .": hidden files (" . (g:NERDTreeShowHidden ? "on" : "off") . ")\n"
        let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (t:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n"
        let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (g:NERDTreeShowFiles ? "on" : "off") . ")\n"

        let @h=@h."\" \n\" ----------------------------\n"
        let @h=@h."\" Other mappings~\n"
        let @h=@h."\" ". g:NERDTreeMapQuit .": Close the NERDTree window\n"
        let @h=@h."\" ". g:NERDTreeMapHelp .": toggle help\n"
    else
        let @h="\" Press ". g:NERDTreeMapHelp ." for help\n"
    endif

    silent! put h

    let @h = old_h
endfunction
"FUNCTION: s:Echo  {{{2
"A wrapper for :echo. Appends 'NERDTree:' on the front of all messages
"
"Args:
"msg: the message to echo
function! s:Echo(msg)
    redraw
    echo "NERDTree: " . a:msg
endfunction
"FUNCTION: s:EchoWarning {{{2
"Wrapper for s:Echo, sets the message type to warningmsg for this message
"Args: 
"msg: the message to echo
function! s:EchoWarning(msg)
    echohl warningmsg
    call s:Echo(a:msg)
    echohl normal
endfunction
"FUNCTION: s:EchoError {{{2
"Wrapper for s:Echo, sets the message type to errormsg for this message
"Args: 
"msg: the message to echo
function! s:EchoError(msg)
    echohl errormsg
    call s:Echo(a:msg)
    echohl normal
endfunction
"FUNCTION: s:FindNodeLineNumber(treenode){{{2
"Finds the line number for the given tree node
"
"Args:
"treenode: the node to find the line no. for
function! s:FindNodeLineNumber(treenode) 
    "if the node is the root then return the root line no. 
    if a:treenode.IsRoot()
        return s:FindRootNodeLineNumber()
    endif

    let totalLines = line("$")

    "the path components we have matched so far 
    let pathcomponents = [substitute(t:NERDTreeRoot.path.Str(0), '/ *$', '', '')]
    "the index of the component we are searching for 
    let curPathComponent = 1

    let fullpath = a:treenode.path.Str(0)


    let lnum = s:FindRootNodeLineNumber()
    while lnum > 0
        let lnum = lnum + 1
        "have we reached the bottom of the tree? 
        if lnum == totalLines+1
            return -1
        endif

        let curLine = getline(lnum)

        let indent = match(curLine,s:tree_markup_reg_neg) / s:tree_wid
        if indent == curPathComponent
            let curLine = s:StripMarkupFromLine(curLine, 1)

            let curPath =  join(pathcomponents, '/') . '/' . curLine
            if stridx(fullpath, curPath, 0) == 0 
                if fullpath == curPath || strpart(fullpath, len(curPath)-1,1) == '/'
                    let curLine = substitute(curLine, '/ *$', '', '')
                    call add(pathcomponents, curLine)
                    let curPathComponent = curPathComponent + 1

                    if fullpath == curPath
                        return lnum
                    endif
                endif
            endif
        endif
    endwhile
    return -1
endfunction

"FUNCTION: s:FindRootNodeLineNumber(path){{{2
"Finds the line number of the root node  
function! s:FindRootNodeLineNumber() 
    let rootLine = 1
    while getline(rootLine) !~ '^/'
        let rootLine = rootLine + 1
    endwhile
    return rootLine
endfunction

"FUNCTION: s:GetPath(ln) {{{2 
"Gets the full path to the node that is rendered on the given line number
"
"Args:
"ln: the line number to get the path for
"
"Return:
"A path if a node was selected, {} if nothing is selected.
"If the 'up a dir' line was selected then the path to the parent of the
"current root is returned
function! s:GetPath(ln) 
    let line = getline(a:ln)

    "check to see if we have the root node 
    if line =~ '^\/'
        return t:NERDTreeRoot.path
    endif

    " in case called from outside the tree
    if line !~ '^ *[|`]' || line =~ '^$'
        return {}
    endif

    if line == s:tree_up_dir_line
        return s:oPath.New( t:NERDTreeRoot.path.GetDir(0) )
    endif

    "get the indent level for the file (i.e. how deep in the tree it is) 
    "let indent = match(line,'[^-| `]') / s:tree_wid
    let indent = match(line, s:tree_markup_reg_neg) / s:tree_wid


    "remove the tree parts and the leading space 
    let curFile = s:StripMarkupFromLine(line, 0)

    let wasdir = 0
    if curFile =~ '/$' 
        let wasdir = 1
    endif
    let curFile = substitute (curFile,' -> .*',"","") " remove link to
    if wasdir == 1
        let curFile = substitute (curFile, '/\?$', '/', "")
    endif


    let dir = ""
    let lnum = a:ln
    while lnum > 0
        let lnum = lnum - 1
        let curLine = getline(lnum)

        "have we reached the top of the tree? 
        if curLine =~ '^/'
            let sd = substitute (curLine, '[ ]*$', "", "")
            let dir = sd . dir
            break
        endif
        if curLine =~ '/$'
            let lpindent = match(curLine,s:tree_markup_reg_neg) / s:tree_wid
            if lpindent < indent
                let indent = indent - 1
                let sd = substitute (curLine, '^' . s:tree_markup_reg . '*',"","") 
                let sd = substitute (sd, ' -> .*', '',"") 

                " remove leading escape
                let sd = substitute (sd,'^\\', "", "")

                let dir = sd . dir
                continue
            endif
        endif
    endwhile
    let curFile = dir . curFile
    return s:oPath.NewMinimal(curFile)
endfunction 

"FUNCTION: s:GetSelectedDir() {{{2 
"Returns the current node if it is a dir node, or else returns the current
"nodes parent
function! s:GetSelectedDir() 
    let currentDir = s:GetSelectedNode()
    if currentDir != {} && !currentDir.IsRoot()
        if currentDir.path.isDirectory == 0
            let currentDir = currentDir.parent
        endif
    endif
    return currentDir
endfunction
"FUNCTION: s:GetSelectedNode() {{{2 
"gets the treenode that the cursor is currently over
function! s:GetSelectedNode() 
    try 
        let path = s:GetPath(line("."))
        if path == {}
            return {}
        endif
        return t:NERDTreeRoot.FindNode(path)
    catch /^NERDTree/
        return {}
    endtry
endfunction

"FUNCTION: s:GetTreeBufNum() {{{2
"gets the nerd tree buffer number for this tab
function! s:GetTreeBufNum() 
    if exists("t:NERDTreeWinName")
        return bufnr(t:NERDTreeWinName)
    else
        return -1
    endif
endfunction
"FUNCTION: s:GetTreeWinNum() {{{2
"gets the nerd tree window number for this tab
function! s:GetTreeWinNum() 
    if exists("t:NERDTreeWinName")
        return bufwinnr(t:NERDTreeWinName)
    else
        return -1
    endif
endfunction

"FUNCTION: s:IsTreeOpen() {{{2
function! s:IsTreeOpen() 
    return s:GetTreeWinNum() != -1
endfunction

" FUNCTION: s:JumpToChild(direction) {{{2
" Args:
" direction: 0 if going to first child, 1 if going to last
function! s:JumpToChild(direction) 
    let currentNode = s:GetSelectedNode()
    if currentNode == {} || currentNode.IsRoot()
        call s:Echo("cannot jump to " . (a:direction ? "last" : "first") .  " child")
        return
    end
    let dirNode = currentNode.parent
    let childNodes = dirNode.GetVisibleChildren()

    let targetNode = childNodes[0]
    if a:direction
        let targetNode = childNodes[len(childNodes) - 1]
    endif

    if targetNode.Equals(currentNode)
        let siblingDir = currentNode.parent.FindOpenDirSiblingWithChildren(a:direction)
        if siblingDir != {} 
            let indx = a:direction ? siblingDir.GetVisibleChildCount()-1 : 0
            let targetNode = siblingDir.GetChildByIndex(indx, 1)
        endif
    endif

    call s:PutCursorOnNode(targetNode, 1)

    call s:CenterView()
endfunction


"FUNCTION: s:OpenDirNodeSplit(treenode) {{{2
"Open the file represented by the given node in a new window.
"No action is taken for file nodes
"
"ARGS:
"treenode: file node to open
function! s:OpenDirNodeSplit(treenode) 
    if a:treenode.path.isDirectory == 1
        call s:OpenNodeSplit(a:treenode)
    endif
endfunction

"FUNCTION: s:OpenFileNode(treenode) {{{2
"Open the file represented by the given node in the current window, splitting
"the window if needed
"
"ARGS:
"treenode: file node to open
function! s:OpenFileNode(treenode) 
    call s:PutCursorInTreeWin()

    if s:ShouldSplitToOpen(winnr("#"))
        call s:OpenFileNodeSplit(a:treenode)
    else
        try
            wincmd p
            exec ("edit " . a:treenode.path.StrForEditCmd())
        catch /^Vim\%((\a\+)\)\=:E37/
            call s:PutCursorInTreeWin()
            call s:Echo("Cannot open file, it is already open and modified")
        catch /^Vim\%((\a\+)\)\=:/
            echo v:exception
        endtry
    endif
endfunction

"FUNCTION: s:OpenFileNodeSplit(treenode) {{{2
"Open the file represented by the given node in a new window.
"No action is taken for dir nodes
"
"ARGS:
"treenode: file node to open
function! s:OpenFileNodeSplit(treenode) 
    if a:treenode.path.isDirectory == 0
        try
            call s:OpenNodeSplit(a:treenode)
        catch /^NERDTree.view.FileOpen/
            call s:Echo("Cannot open file, it is already open and modified" )
        endtry
    endif
endfunction

"FUNCTION: s:OpenNodeSplit(treenode) {{{2
"Open the file/dir represented by the given node in a new window
"
"ARGS:
"treenode: file node to open
function! s:OpenNodeSplit(treenode) 
    call s:PutCursorInTreeWin()

    " Save the user's settings for splitbelow and splitright
    let savesplitbelow=&splitbelow
    let savesplitright=&splitright

    " Figure out how to do the split based on the user's preferences.
    " We want to split to the (left,right,top,bottom) of the explorer
    " window, but we want to extract the screen real-estate from the
    " window next to the explorer if possible.
    "
    " 'there' will be set to a command to move from the split window
    " back to the explorer window
    "
    " 'back' will be set to a command to move from the explorer window
    " back to the newly split window
    "
    " 'right' and 'below' will be set to the settings needed for
    " splitbelow and splitright IF the explorer is the only window.
    "
    if g:NERDTreeSplitVertical == 1
        let there= g:NERDTreeWinPos ? "wincmd h" : "wincmd l"
        let back= g:NERDTreeWinPos ? "wincmd l" : "wincmd h"
        let right=g:NERDTreeWinPos ? 1 : 0
        let below=0
    else
        let there= g:NERDTreeWinPos ? "wincmd k" : "wincmd j"
        let back= g:NERDTreeWinPos ? "wincmd j" : "wincmd k"
        let right=0
        let below=g:NERDTreeWinPos ? 1 : 0
    endif

    " Attempt to go to adjacent window
    exec(back)

    let onlyOneWin = (winnr() == s:GetTreeWinNum())

    " If no adjacent window, set splitright and splitbelow appropriately
    if onlyOneWin
        let &splitright=right
        let &splitbelow=below
    else
        " found adjacent window - invert split direction
        let &splitright=!right
        let &splitbelow=!below
    endif

    " Create a variable to use if splitting vertically
    let splitMode = ""
    if (onlyOneWin && g:NERDTreeSplitVertical) || (!onlyOneWin && !g:NERDTreeSplitVertical)
        let splitMode = "vertical"
    endif

    " Open the new window
    try
        exec("silent " . splitMode." sp " . a:treenode.path.StrForEditCmd())
    catch /^Vim\%((\a\+)\)\=:E37/
		call s:PutCursorInTreeWin()
        throw "NERDTree.view.FileOpen exception: ". a:treenode.path.Str(0) ." is already open and modified."
    catch /^Vim\%((\a\+)\)\=:/
        do nothing 
    endtry

    " resize the explorer window if it is larger than the requested size
    exec(there)

    if g:NERDTreeWinSize =~ '[0-9]\+' && winheight("") > g:NERDTreeWinSize
        exec("silent vertical resize ".g:NERDTreeWinSize)
    endif

    wincmd p

    " Restore splitmode settings
    let &splitbelow=savesplitbelow
    let &splitright=savesplitright
endfunction 

"FUNCTION: s:PromptToDelBuffer(bufnum, msg){{{2
"prints out the given msg and, if the user responds by pushing 'y' then the
"buffer with the given bufnum is deleted
"
"Args:
"bufnum: the buffer that may be deleted
"msg: a message that will be echoed to the user asking them if they wish to
"     del the buffer
function! s:PromptToDelBuffer(bufnum, msg) 
    echo a:msg
    if nr2char(getchar()) == 'y'
        exec "silent bdelete! " . a:bufnum
    endif
endfunction

"FUNCTION: s:PutCursorOnNode(treenode, is_jump){{{2
"Places the cursor on the line number representing the given node
"
"Args:
"treenode: the node to put the cursor on
"is_jump: 1 if this cursor movement should be counted as a jump by vim
function! s:PutCursorOnNode(treenode, is_jump) 
    let ln = s:FindNodeLineNumber(a:treenode)
    if ln != -1
        if a:is_jump
            mark '
        endif
        call cursor(ln, col("."))
    endif
endfunction

"FUNCTION: s:PutCursorInTreeWin(){{{2
"Places the cursor in the nerd tree window
function! s:PutCursorInTreeWin() 
	if !s:IsTreeOpen()
		throw "NERDTree.view.InvalidOperation Exception: No NERD tree window exists"
	endif

	exec s:GetTreeWinNum() . "wincmd w"
endfunction

"FUNCTION: s:RenderView {{{2 
"The entry function for rendering the tree. Renders the root then calls
"s:DrawTree to draw the children of the root
"
"Args:
function! s:RenderView()
    execute s:GetTreeWinNum() . "wincmd w"

    setlocal modifiable

    "remember the top line of the buffer and the current line so we can
    "restore the view exactly how it was
    let curLine = line(".")
    let curCol = col(".")
    let topLine = line("w0")

    "delete all lines in the buffer (being careful not to clobber a register)  
    :silent 1,$delete _

    call s:DumpHelp()

    "delete the blank line before the help and add one after it 
    call setline(line(".")+1, " ")
    call cursor(line(".")+1, col("."))

    "add the 'up a dir' line 
    call setline(line(".")+1, s:tree_up_dir_line)
    call cursor(line(".")+1, col("."))

    "draw the header line  
    call setline(line(".")+1, t:NERDTreeRoot.path.Str(0))
    call cursor(line(".")+1, col("."))

    "draw the tree 
    call s:DrawTree(t:NERDTreeRoot, 0, 0, [], t:NERDTreeRoot.GetChildCount() == 1)

    "delete the blank line at the top of the buffer
    :silent 1,1delete _

    "restore the view 
    call cursor(topLine, 1)
    normal! zt
    call cursor(curLine, curCol)

    setlocal nomodifiable
endfunction

"FUNCTION: s:RenderViewSavingPosition {{{2 
"Renders the tree and ensures the cursor stays on the current node or the
"current nodes parent if it is no longer available upon re-rendering
function! s:RenderViewSavingPosition()
    let currentNode = s:GetSelectedNode()

    "go up the tree till we find a node that will be visible or till we run
    "out of nodes 
    while currentNode != {} && !currentNode.IsVisible() && !currentNode.IsRoot()
        let currentNode = currentNode.parent
    endwhile

    call s:RenderView()

    if currentNode != {}
        call s:PutCursorOnNode(currentNode, 0)
    endif
endfunction
"FUNCTION: s:RestoreScreenState() {{{2 
"
"Sets the screen state back to what it was when s:SaveScreenState was last
"called.
"
"Assumes the cursor is in the NERDTree window
function! s:RestoreScreenState()
    if !exists("t:NERDTreeOldTopLine") || !exists("t:NERDTreeOldPos")
        return
    endif

    call cursor(t:NERDTreeOldTopLine, 0)
    normal! zt
    call setpos(".", t:NERDTreeOldPos)
endfunction

"FUNCTION: s:SaveScreenState() {{{2 
"Saves the current cursor position in the current buffer and the window
"scroll position 
"
"Assumes the cursor is in the NERDTree window
function! s:SaveScreenState()
    let t:NERDTreeOldPos = getpos(".")
    let t:NERDTreeOldTopLine = line("w0")
endfunction

"FUNCTION: s:SetupSyntaxHighlighting() {{{2 
function! s:SetupSyntaxHighlighting()
    "treeFlags are syntax items that should be invisible, but give clues as to
    "how things should be highlighted
    syn match treeFlag #\~#
    syn match treeFlag #\[RO\]#

    "highlighting for the .. (up dir) line at the top of the tree 
    execute "syn match treeUp #". s:tree_up_dir_line ."#"

    "highlighting for the ~/+ symbols for the directory nodes 
    syn match treeClosable #\~\<#
    syn match treeClosable #\~\.#
    syn match treeOpenable #+\<#
    syn match treeOpenable #+\.#he=e-1

    "highlighting for the tree structural parts 
    syn match treePart #|#
    syn match treePart #`#
    syn match treePartFile #[|`]-#hs=s+1 contains=treePart

    "quickhelp syntax elements 
    syn match treeHelpKey #" \{1,2\}[^ ]*:#hs=s+2,he=e-1
    syn match treeHelpKey #" \{1,2\}[^ ]*,#hs=s+2,he=e-1
    syn match treeHelpTitle #" .*\~#hs=s+2,he=e-1 contains=treeFlag
    syn match treeToggleOn #".*(on)#hs=e-2,he=e-1 contains=treeHelpKey
    syn match treeToggleOff #".*(off)#hs=e-3,he=e-1 contains=treeHelpKey
    syn match treeHelp  #^" .*# contains=treeHelpKey,treeHelpTitle,treeFlag,treeToggleOff,treeToggleOn

    "highlighting for sym links 
    syn match treeLink #[^-| `].* -> #

    "highlighting for readonly files 
    syn match treeRO #[0-9a-zA-Z]\+.*\[RO\]# contains=treeFlag

    "highlighing for directory nodes and file nodes 
    syn match treeDirSlash #/#
    syn match treeDir #[^-| `].*/\([ {}]\{4\}\)*$# contains=treeLink,treeDirSlash,treeOpenable,treeClosable
    syn match treeFile  #|-.*# contains=treeLink,treePart,treeRO,treePartFile
    syn match treeFile  #`-.*# contains=treeLink,treePart,treeRO,treePartFile
    syn match treeCWD #^/.*$# 

    if g:NERDChristmasTree
        hi def link treePart Special
        hi def link treePartFile Type
        hi def link treeFile Macro
        hi def link treeDirSlash Identifier
        hi def link treeClosable Type
    else
        hi def link treePart Normal
        hi def link treePartFile Normal
        hi def link treeFile Normal
        hi def link treeClosable Title
    endif

    hi def link treeHelp String
    hi def link treeHelpKey Identifier
    hi def link treeHelpTitle Macro
    hi def link treeToggleOn Question
    hi def link treeToggleOff WarningMsg

    hi def link treeDir Directory
    hi def link treeUp Directory
    hi def link treeCWD Statement
    hi def link treeLink Title
    hi def link treeOpenable Title
    hi def link treeFlag ignore
    hi def link treeRO WarningMsg

    hi def link NERDTreeCurrentNode Search
endfunction

"FUNCTION: s:ShouldSplitToOpen() {{{2
"Returns 1 if opening a file from the tree in the given window requires it to
"be split
"
"Args: 
"winnumber: the number of the window in question
function! s:ShouldSplitToOpen(winnumber)
    if &hidden
        return 0
    endif
    let oldwinnr = winnr()

    exec a:winnumber . "wincmd p"
    let modified = &modified
    exec oldwinnr . "wincmd p"

    return winnr("$") == 1 || (modified && s:BufInWindows(winbufnr(a:winnumber)) < 2)
endfunction

"FUNCTION: s:StripMarkupFromLine(line){{{2
"returns the given line with all the tree parts stripped off
"
"Args:
"line: the subject line
"removeLeadingSpaces: 1 if leading spaces are to be removed (leading spaces =
"any spaces before the actual text of the node)
function! s:StripMarkupFromLine(line, removeLeadingSpaces) 
    let line = a:line
    "remove the tree parts and the leading space 
    let line = substitute (line,"^" . s:tree_markup_reg . "*","","")

    "strip off any read only flag 
    let line = substitute (line, s:tree_RO_str_reg, "","")

    let wasdir = 0
    if line =~ '/$' 
        let wasdir = 1
    endif
    let line = substitute (line,' -> .*',"","") " remove link to
    if wasdir == 1
        let line = substitute (line, '/\?$', '/', "")
    endif

    if a:removeLeadingSpaces
        let line = substitute (line, '^ *', '', '')
    endif

    return line
endfunction

"FUNCTION: s:Toggle(dir) {{{2 
"Toggles the NERD tree. I.e the NERD tree is open, it is closed, if it is
"closed it is restored or initialized (if it doesnt exist)     
"
"Args:
"dir: the full path for the root node (is only used if the NERD tree is being
"initialized.
function! s:Toggle(dir)
    if s:TreeExistsForTab()
        if !s:IsTreeOpen()
            call s:CreateTreeWin()
            call s:RenderView()

            call s:RestoreScreenState()
        else
            call s:CloseTree()
        endif
    else
        call s:InitNerdTree(a:dir)
    endif
endfunction
"SECTION: Interface bindings {{{1
"============================================================
"FUNCTION: s:ActivateNode() {{{2
"If the current node is a file, open it in the previous window (or a new one
"if the previous is modified). If it is a directory then it is opened.
function! s:ActivateNode()
    if getline(".") == s:tree_up_dir_line
        return s:UpDir(0)
    endif
    let treenode = s:GetSelectedNode()
    if treenode == {} 
        call s:EchoWarning("cannot open selected entry")
        return
    endif

    if treenode.path.isDirectory
        call treenode.ToggleOpen()
        call s:RenderView()
        call s:PutCursorOnNode(treenode, 0)
    else
        call s:OpenFileNode(treenode)
    endif
endfunction

"FUNCTION: s:BindMappings() {{{2
function! s:BindMappings()
    " set up mappings and commands for this buffer
    nnoremap <silent> <buffer> <middlerelease> :call <SID>HandleMiddleMouse()<cr>
    nnoremap <silent> <buffer> <leftrelease> <leftrelease>:call <SID>CheckForActivate()<cr>
    nnoremap <silent> <buffer> <2-leftmouse> :call <SID>ActivateNode()<cr>

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapActivateNode . " :call <SID>ActivateNode()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenSplit ." :call <SID>OpenEntrySplit()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreview ." :call <SID>PreviewNode(0)<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreviewSplit ." :call <SID>PreviewNode(1)<cr>"


    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapExecute ." :call <SID>ExecuteNode()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenRecursively ." :call <SID>OpenNodeRecursively()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapUpdirKeepOpen ." :call <SID>UpDir(1)<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapUpdir ." :call <SID>UpDir(0)<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapChangeRoot ." :call <SID>ChRoot()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapChdir ." :call <SID>ChCwd()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapQuit ." :NERDTreeToggle<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapRefreshRoot ." :call <SID>RefreshRoot()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapRefresh ." :call <SID>RefreshCurrent()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapHelp ." :call <SID>DisplayHelp()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleHidden ." :call <SID>ToggleShowHidden()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleFilters ." :call <SID>ToggleIgnoreFilter()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleFiles ." :call <SID>ToggleShowFiles()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapCloseDir ." :call <SID>CloseCurrentDir()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapCloseChildren ." :call <SID>CloseChildren()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapFilesystemMenu ." :call <SID>ShowFileSystemMenu()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpParent ." :call <SID>JumpToParent()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpNextSibling ." :call <SID>JumpToSibling(1)<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpPrevSibling ." :call <SID>JumpToSibling(0)<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpFirstChild ." :call <SID>JumpToFirstChild()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpLastChild ." :call <SID>JumpToLastChild()<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpRoot ." :call <SID>JumpToRoot()<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTab ." :call <SID>OpenNodeNewTab(0)<cr>"
    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTabSilent ." :call <SID>OpenNodeNewTab(1)<cr>"

    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenExpl ." :call <SID>OpenExplorer()<cr>"


endfunction

"FUNCTION: s:CheckForActivate() {{{2
"Checks if the click should open the current node, if so then activate() is
"called (directories are automatically opened if the symbol beside them is
"clicked)
function! s:CheckForActivate()
    let currentNode = s:GetSelectedNode()
    if currentNode != {} 
        let startToCur = strpart(getline(line(".")), 0, col("."))
        let char = strpart(startToCur, strlen(startToCur)-1, 1)

        "if they clicked a dir, check if they clicked on the + or ~ sign
        "beside it 
        if currentNode.path.isDirectory
            let reg = '^' . s:tree_markup_reg .'*[' . s:tree_dir_open . s:tree_dir_closed . ']$'
            if startToCur =~ reg
                call s:ActivateNode()
                return
            endif
        endif

        if (g:NERDTreeMouseMode == 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode == 3
            if char !~ s:tree_markup_reg && startToCur !~ '\/$'
                call s:ActivateNode()
                return
            endif
        endif
    endif
endfunction

" FUNCTION: s:ChCwd() {{{2
function! s:ChCwd() 
    let treenode = s:GetSelectedNode()
    if treenode == {} 
        call s:Echo("Select a node first")
        return
    endif

    try
        call treenode.path.ChangeToDir()
    catch /^NERDTree.Path.Change/
        call s:EchoWarning("could not change cwd")
    endtry
endfunction

" FUNCTION: s:ChRoot() {{{2
" changes the current root to the selected one
function! s:ChRoot() 
    let treenode = s:GetSelectedNode()
    if treenode == {} || treenode.path.isDirectory == 0
        call s:Echo("Select a directory node first")
        return
    endif

    if treenode.isOpen == 0
        call treenode.Open()
    endif

    let t:NERDTreeRoot = treenode
    
    "change dir to the dir of the new root if instructed to 
    if g:NERDTreeChDirMode == 2
        exec "cd " . treenode.path.StrForEditCmd()
    endif


    call s:RenderView()
    call s:PutCursorOnNode(t:NERDTreeRoot, 0)
endfunction

" FUNCTION: s:CloseChildren() {{{2
" closes all childnodes of the current node
function! s:CloseChildren() 
    let currentNode = s:GetSelectedDir()
    if currentNode == {}
        call s:Echo("Select a node first")
        return
    endif

    call currentNode.CloseChildren()
    call s:RenderView()
    call s:PutCursorOnNode(currentNode, 0)
endfunction
" FUNCTION: s:CloseCurrentDir() {{{2
" closes the parent dir of the current node
function! s:CloseCurrentDir() 
    let treenode = s:GetSelectedNode()
    if treenode == {}
        call s:Echo("Select a node first")
        return
    endif

    let parent = treenode.parent
    if parent.IsRoot()
        call s:Echo("cannot close tree root")
    else
        call treenode.parent.Close()
        call s:RenderView()
        call s:PutCursorOnNode(treenode.parent, 0)
    endif
endfunction

" FUNCTION: s:DeleteNode() {{{2
" if the current node is a file, pops up a dialog giving the user the option
" to delete it
function! s:DeleteNode() 
    let currentNode = s:GetSelectedNode()
    if currentNode == {}
        call s:Echo("Put the cursor on a file node first")
        return
    endif

    let confirmed = 0

    if currentNode.path.isDirectory
        let choice =input("Delete the current node\n" .
                         \ "==========================================================\n" . 
                         \ "STOP! To delete this entire directory, type 'yes'\n" . 
                         \ "" . currentNode.path.StrForOS(0) . ": ")
        let confirmed = choice == 'yes'
    else
        echo "Delete the current node\n" .
           \ "==========================================================\n". 
           \ "Are you sure you wish to delete the node:\n" . 
           \ "" . currentNode.path.StrForOS(0) . " (yN):"
        let choice = nr2char(getchar())
        let confirmed = choice == 'y'
    endif


    if confirmed
        try
            call currentNode.Delete()
            call s:RenderView()

            "if the node is open in a buffer, ask the user if they want to
            "close that buffer 
            let bufnum = bufnr(currentNode.path.Str(0))
            if buflisted(bufnum)
                let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) == -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
                call s:PromptToDelBuffer(bufnum, prompt)
            endif

            redraw
        catch /^NERDTree/
            call s:EchoWarning("Could not remove node")
        endtry
    else
        call s:Echo("delete aborted" )
    endif

endfunction

" FUNCTION: s:DisplayHelp() {{{2
" toggles the help display
function! s:DisplayHelp() 
    let t:treeShowHelp = t:treeShowHelp ? 0 : 1
    call s:RenderView()
    call s:CenterView()
endfunction

" FUNCTION: s:ExecuteNode() {{{2
function! s:ExecuteNode()
    let treenode = s:GetSelectedNode()
    if treenode == {} || treenode.path.isDirectory
        call s:Echo("Select an executable file node first" )
    else
        echo "NERDTree executor\n" .
           \ "==========================================================\n". 
           \ "Complete the command to execute (add arguments etc): \n\n"
        let cmd = treenode.path.StrForOS(1) 
        let cmd = input(':!', cmd . ' ')

        if cmd != ''
            exec ':!' . cmd
        else
            call s:Echo("command aborted")
        endif
    endif
endfunction

" FUNCTION: s:HandleMiddleMouse() {{{2
function! s:HandleMiddleMouse() 
    let curNode = s:GetSelectedNode()
    if curNode == {}
        call s:Echo("Put the cursor on a node first" )
        return
    endif

    if curNode.path.isDirectory
        call s:OpenExplorer()
    else
        call s:OpenEntrySplit()
    endif
endfunction


" FUNCTION: s:InsertNewNode() {{{2
" Adds a new node to the filesystem and then into the tree
function! s:InsertNewNode() 
    let curDirNode = s:GetSelectedDir()
    if curDirNode == {}
        call s:Echo("Put the cursor on a node first" )
        return
    endif

    let newNodeName = input("Add a childnode\n".
                          \ "==========================================================\n". 
                          \ "Enter the dir/file name to be created. Dirs end with a '/'\n" . 
                          \ "", curDirNode.path.Str(0))
    
    if newNodeName == ''
        call s:Echo("Node Creation Aborted.")
        return
    endif

    try
        let newPath = s:oPath.Create(newNodeName)

        let parentNode = t:NERDTreeRoot.FindNode(newPath.GetPathTrunk())

        let newTreeNode = s:oTreeFileNode.New(newPath)
        if parentNode.isOpen || !empty(parentNode.children) 
            call parentNode.AddChild(newTreeNode, 1)
            call s:RenderView()
            call s:PutCursorOnNode(newTreeNode, 1)
        endif
    catch /^NERDTree/
        call s:EchoWarning("Node Not Created.")
    endtry
endfunction

" FUNCTION: s:JumpToFirstChild() {{{2
" wrapper for the jump to child method
function! s:JumpToFirstChild() 
    call s:JumpToChild(0)
endfunction

" FUNCTION: s:JumpToLastChild() {{{2
" wrapper for the jump to child method
function! s:JumpToLastChild() 
    call s:JumpToChild(1)
endfunction

" FUNCTION: s:JumpToParent() {{{2
" moves the cursor to the parent of the current node
function! s:JumpToParent() 
    let currentNode = s:GetSelectedNode()
    if !empty(currentNode)
        if !empty(currentNode.parent) 
            call s:PutCursorOnNode(currentNode.parent, 1)
            call s:CenterView()
        else
            call s:Echo("cannot jump to parent")
        endif
    else
        call s:Echo("put the cursor on a node first")
    endif
endfunction

" FUNCTION: s:JumpToRoot() {{{2
" moves the cursor to the root node
function! s:JumpToRoot() 
    call s:PutCursorOnNode(t:NERDTreeRoot, 1)
    call s:CenterView()
endfunction

" FUNCTION: s:JumpToSibling() {{{2
" moves the cursor to the sibling of the current node in the given direction
"
" Args:
" forward: 1 if the cursor should move to the next sibling, 0 if it should
" move back to the previous sibling
function! s:JumpToSibling(forward) 
    let currentNode = s:GetSelectedNode()
    if !empty(currentNode)

        if !currentNode.path.isDirectory

            if a:forward
                let sibling = currentNode.parent.FindSibling(1)
            else
                let sibling = currentNode.parent
            endif

        else
            let sibling = currentNode.FindSibling(a:forward)
        endif

        if !empty(sibling)
            call s:PutCursorOnNode(sibling, 1)
            call s:CenterView()
        endif
    else
        call s:Echo("put the cursor on a node first")
    endif
endfunction

" FUNCTION: s:OpenEntrySplit() {{{2
" Opens the currently selected file from the explorer in a
" new window 
function! s:OpenEntrySplit() 
    let treenode = s:GetSelectedNode()
    if treenode != {}
        call s:OpenFileNodeSplit(treenode)
    else
        call s:Echo("select a node first")
    endif
endfunction 

" FUNCTION: s:OpenExplorer() {{{2
function! s:OpenExplorer() 
    let treenode = s:GetSelectedDir()
    if treenode != {}
        let oldwin = winnr()
        wincmd p
        if oldwin == winnr() || (&modified && s:BufInWindows(winbufnr(winnr())) < 2)
            wincmd p
            call s:OpenDirNodeSplit(treenode)
        else
            exec ("silent edit " . treenode.path.StrForEditCmd())
        endif
    else
        call s:Echo("select a node first")
    endif
endfunction

" FUNCTION: s:OpenNodeNewTab(stayCurrentTab) {{{2
" Opens the currently selected file from the explorer in a
" new tab
"
" Args:
" stayCurrentTab: if 1 then vim will stay in the current tab, if 0 then vim
" will go to the tab where the new file is opened
function! s:OpenNodeNewTab(stayCurrentTab) 
    let treenode = s:GetSelectedNode()
    if treenode != {}
        let curTabNr = tabpagenr()
        exec "tabedit " . treenode.path.StrForEditCmd()
        if a:stayCurrentTab
            exec "tabnext " . curTabNr
        endif
    else
        call s:Echo("select a node first")
    endif
endfunction 


" FUNCTION: s:OpenNodeRecursively() {{{2
function! s:OpenNodeRecursively() 
    let treenode = s:GetSelectedNode()
    if treenode == {} || treenode.path.isDirectory == 0
        call s:Echo("Select a directory node first" )
    else
        call s:Echo("Recursively opening node. Please wait...")
        call treenode.OpenRecursively()
        call s:RenderView()
        redraw
        call s:Echo("Recursively opening node. Please wait... DONE")
    endif
    
endfunction

"FUNCTION: s:PreviewNode() {{{2
function! s:PreviewNode(openNewWin) 
    let treenode = s:GetSelectedNode()
    if treenode == {} || treenode.path.isDirectory
        call s:Echo("Select a file node first" )
        return
    endif

    if a:openNewWin
        call s:OpenEntrySplit()
    else
        call s:ActivateNode()
    end
    call s:PutCursorInTreeWin()
endfunction

" FUNCTION: s:RefreshRoot() {{{2
" Reloads the current root. All nodes below this will be lost and the root dir
" will be reloaded.
function! s:RefreshRoot() 
    call s:Echo("Refreshing the root node. This could take a while...")
    call t:NERDTreeRoot.Refresh()
    call s:RenderView()
    redraw
    call s:Echo("Refreshing the root node. This could take a while... DONE")
endfunction

" FUNCTION: s:RefreshCurrent() {{{2
" refreshes the root for the current node
function! s:RefreshCurrent() 
    let treenode = s:GetSelectedDir()
    if treenode == {} 
        call s:Echo("Refresh failed. Select a node first")
        return
    endif

    call s:Echo("Refreshing node. This could take a while...")
    call treenode.Refresh()
    call s:RenderView()
    redraw
    call s:Echo("Refreshing node. This could take a while... DONE")
endfunction
" FUNCTION: s:RenameCurrent() {{{2
" allows the user to rename the current node
function! s:RenameCurrent() 
    let curNode = s:GetSelectedNode()
    if curNode == {}
        call s:Echo("Put the cursor on a node first" )
        return
    endif

    let newNodePath = input("Rename the current node\n" .
                          \ "==========================================================\n" . 
                          \ "Enter the new path for the node:                          \n" . 
                          \ "", curNode.path.Str(0))
    
    if newNodePath == ''
        call s:Echo("Node Renaming Aborted.")
        return
    endif

    let newNodePath = substitute(newNodePath, '\/$', '', '')

    try
        let bufnum = bufnr(curNode.path.Str(0))

        call curNode.Rename(newNodePath)
        call s:RenderView()

        "if the node is open in a buffer, ask the user if they want to
        "close that buffer 
        if bufnum != -1
            let prompt = "|\n|Node renamed.\n|\n|The old file is open in buffer ". bufnum . (bufwinnr(bufnum) == -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
            call s:PromptToDelBuffer(bufnum, prompt)
        endif

        call s:PutCursorOnNode(curNode, 1)

        redraw
    catch /^NERDTree/
        call s:EchoWarning("Node Not Renamed.")
    endtry
endfunction

" FUNCTION: s:ShowFileSystemMenu() {{{2
function! s:ShowFileSystemMenu() 
    let curNode = s:GetSelectedNode()
    if curNode == {}
        call s:Echo("Put the cursor on a node first" )
        return
    endif


    echo "NERDTree Filesystem Menu\n" .
       \ "==========================================================\n". 
       \ "Select the desired operation:                             \n" . 
       \ " (1) - Add a childnode\n".
       \ " (2) - Rename the current node\n".
       \ " (3) - Delete the current node\n\n"

    let choice = nr2char(getchar())

    if choice == 1
        call s:InsertNewNode()
    elseif choice == 2
        call s:RenameCurrent()
    elseif choice == 3
        call s:DeleteNode()
    endif
endfunction

" FUNCTION: s:ToggleIgnoreFilter() {{{2
" toggles the use of the NERDTreeIgnore option 
function! s:ToggleIgnoreFilter() 
    let t:NERDTreeIgnoreEnabled = !t:NERDTreeIgnoreEnabled
    call s:RenderViewSavingPosition()
    call s:CenterView()
endfunction

" FUNCTION: s:ToggleShowFiles() {{{2
" toggles the display of hidden files
function! s:ToggleShowFiles() 
    let g:NERDTreeShowFiles = !g:NERDTreeShowFiles
    call s:RenderViewSavingPosition()
    call s:CenterView()
endfunction

" FUNCTION: s:ToggleShowHidden() {{{2
" toggles the display of hidden files
function! s:ToggleShowHidden() 
    let g:NERDTreeShowHidden = !g:NERDTreeShowHidden
    call s:RenderViewSavingPosition()
    call s:CenterView()
endfunction

"FUNCTION: s:UpDir(keepState) {{{2
"moves the tree up a level
"
"Args:
"keepState: 1 if the current root should be left open when the tree is
"re-rendered
function! s:UpDir(keepState) 
    let cwd = t:NERDTreeRoot.path.Str(0)
    if cwd == "/" || cwd =~ '^[^/]..$'
        call s:Echo("already at top dir")
    else
        if !a:keepState
            call t:NERDTreeRoot.Close()
        endif

        let oldRoot = t:NERDTreeRoot

        if empty(t:NERDTreeRoot.parent)
            let path = t:NERDTreeRoot.path.GetPathTrunk()
            let newRoot = s:oTreeDirNode.New(path)
            call newRoot.Open()
            call newRoot.TransplantChild(t:NERDTreeRoot)
            let t:NERDTreeRoot = newRoot
        else
            let t:NERDTreeRoot = t:NERDTreeRoot.parent

        endif

        call s:RenderView()
        call s:PutCursorOnNode(oldRoot, 0)
    endif
endfunction


" SECTION: Doc installation call {{{1
silent call s:InstallDocumentation(expand('<sfile>:p'), s:NERD_tree_version)
"============================================================
finish
" SECTION: The help file {{{1 
"=============================================================================
" Title {{{2
" ============================================================================
=== START_DOC
*NERD_tree.txt*   A tree explorer plugin that owns your momma!       #version#





    ________  ________   _   ____________  ____     __________  ____________~
   /_  __/ / / / ____/  / | / / ____/ __ \/ __ \   /_  __/ __ \/ ____/ ____/~
    / / / /_/ / __/    /  |/ / __/ / /_/ / / / /    / / / /_/ / __/ / __/   ~
   / / / __  / /___   / /|  / /___/ _, _/ /_/ /    / / / _, _/ /___/ /___   ~
  /_/ /_/ /_/_____/  /_/ |_/_____/_/ |_/_____/    /_/ /_/ |_/_____/_____/   ~


                              Reference Manual~




==============================================================================
CONTENTS {{{2                                              *NERDTree-contents* 

    1.Intro...................................|NERDTree|
    2.Functionality provided..................|NERDTreeFunctionality|
        2.1 Commands..........................|NERDTreeCommands|
        2.2 NERD tree mappings................|NERDTreeMappings|
        2.3 The filesystem menu...............|NERDTreeFilesysMenu|
    3.Options.................................|NERDTreeOptions|
        3.1 Option summary....................|NERDTreeOptionSummary|
        3.2 Option details....................|NERDTreeOptionDetails|
    4.Public functions........................|NERDTreePublicFunctions|
    5.TODO list...............................|NERDTreeTodo|
    6.The Author..............................|NERDTreeAuthor|
    7.Changelog...............................|NERDTreeChangelog|
    8.Credits.................................|NERDTreeCredits|

==============================================================================
1. Intro {{{2                                                       *NERDTree*

What is this "NERD tree"??

The NERD tree allows you to explore your filesystem and to open files and
directories. It presents the filesystem to you in the form of a tree which you
manipulate with the keyboard and/or mouse. It also allows you to perform
simple filesystem operations so you can alter the tree dynamically.

The following features and functionality are provided by the NERD tree:
    * Files and directories are displayed in a hierarchical tree structure
    * Different highlighting is provided for the following types of nodes:
        * files
        * directories
        * sym-links
        * windows .lnk files
        * read-only files
    * Many (customisable) mappings are provided to manipulate the tree:
        * Mappings to open/close/explore directory nodes
        * Mappings to open files in new/existing windows/tabs     
        * Mappings to change the current root of the tree 
        * Mappings to navigate around the tree 
        * ...
    * Most NERD tree navigation can also be done with the mouse  
    * Dynamic customisation of tree content
        * custom file filters to prevent e.g. vim backup files being displayed
        * optional displaying of hidden files (. files)
        * files can be "turned off" so that only directories are displayed
    * A textual filesystem menu is provided which allows you to
      create/delete/rename file and directory nodes
    * The position and size of the NERD tree window can be customised 
    * The order in which the nodes in the tree are listed can be customised.
    * A model of your filesystem is created/maintained as you explore it. This
      has several advantages:
        * All filesystem information is cached and is only re-read on demand
        * If you revisit a part of the tree that you left earlier in your
          session, the directory nodes will be opened/closed as you left them       
    * The script remembers the cursor position and window position in the NERD
      tree so you can toggle it off (or just close the tree window) and then
      reopen it (with NERDTreeToggle) the NERD tree window will appear EXACTLY
      as you left it
    * You can have a separate NERD tree for each tab   

==============================================================================
2. Functionality provided {{{2                         *NERDTreeFunctionality* 

------------------------------------------------------------------------------
2.1. Commands {{{3                                          *NERDTreeCommands*

:NERDTree [start-directory]                                 *:NERDTree*
                Opens a fresh NERD tree in [start-directory] or the current
                directory if [start-directory] isn't specified.
                For example: >
                    :NERDTree /home/marty/vim7/src
<               will open a NERD tree in /home/marty/vim7/src.

:NERDTreeToggle [start-directory]                           *:NERDTreeToggle*
                If a NERD tree already exists for this tab, it is reopened and
                rendered again.  If no NERD tree exists for this tab then this
                command acts the same as the |:NERDTree| command.

------------------------------------------------------------------------------
2.2. NERD tree Mappings {{{3                                *NERDTreeMappings*

Default  Description~                                             help-tag~
Key~

o.......Open selected file, or expand selected dir...............|NERDTree-o|
go......Open selected file, but leave cursor in the NERDTree.....|NERDTree-go|
t.......Open selected node in a new tab..........................|NERDTree-t|
T.......Same as 't' but keep the focus on the current tab........|NERDTree-T|
<tab>...Open selected file in a split window.....................|NERDTree-tab|
g<tab>..Same as <tab>, but leave the cursor on the NERDTree......|NERDTree-gtab|
!.......Execute the current file.................................|NERDTree-!|
O.......Recursively open the selected directory..................|NERDTree-O|
x.......Close the current nodes parent...........................|NERDTree-x|
X.......Recursively close all children of the current node.......|NERDTree-X|
e.......Open a netrw for the current dir.........................|NERDTree-e|

double-click.......same as the |NERDTree-o| map.
middle-click.......same as |NERDTree-tab| for files, same as 
                   |NERDTree-e| for dirs.

P.......Jump to the root node....................................|NERDTree-P|
p.......Jump to current nodes parent.............................|NERDTree-p|
K.......Jump up inside directories at the current tree depth.....|NERDTree-K|
J.......Jump down inside directories at the current tree depth...|NERDTree-J|
<C-j>...Jump down to the next sibling of the current directory...|NERDTree-c-j|
<C-k>...Jump up to the previous sibling of the current directory.|NERDTree-c-k|

C.......Change the tree root to the selected dir.................|NERDTree-C|
u.......Move the tree root up one directory......................|NERDTree-u|
U.......Same as 'u' except the old root node is left open........|NERDTree-U|
r.......Recursively refresh the current directory................|NERDTree-r|
R.......Recursively refresh the current root.....................|NERDTree-R|
m.......Display the filesystem menu..............................|NERDTree-m|
cd......Change the CWD to the dir of the selected node...........|NERDTree-cd|

H.......Toggle whether hidden files displayed....................|NERDTree-H|
f.......Toggle whether the file filters are used.................|NERDTree-f|
F.......Toggle whether files are displayed.......................|NERDTree-F|

q.......Close the NERDTree window................................|NERDTree-q|
?.......Toggle the display of the quick help.....................|NERDTree-?|

------------------------------------------------------------------------------
                                                                  *NERDTree-o*
Default key: o
Map option: NERDTreeMapActivateNode
Applies to: files and directories.

If a file node is selected, it is opened in the previous window. If a
directory is selected it is opened or closed depending on its current state.

------------------------------------------------------------------------------
                                                                 *NERDTree-go*
Default key: go
Map option: None
Applies to: files.

If a file node is selected, it is opened in the previous window, but the
cursor does not move.

The key combo for this mapping is always "g" + NERDTreeMapActivateNode (see
|NERDTree-o|).

------------------------------------------------------------------------------
                                                                  *NERDTree-t*
Default key: t
Map option: NERDTreeMapOpenInTab
Applies to: files and directories.

Opens the selected file in a new tab. If a directory is selected, a netrw is
opened in a new tab.

------------------------------------------------------------------------------
                                                                  *NERDTree-T*
Default key: T
Map option: NERDTreeMapOpenInTabSilent
Applies to: files and directories.

The same as |NERDTree-t| except that the focus is kept in the current tab.

------------------------------------------------------------------------------
                                                                *NERDTree-tab*
Default key: <tab>
Map option: NERDTreeMapOpenSplit
Applies to: files.

Opens the selected file in a new split window and puts the cursor in the new
window.

------------------------------------------------------------------------------
                                                               *NERDTree-gtab*
Default key: g<tab>
Map option: None
Applies to: files.

The same as |NERDTree-tab| except that the cursor is not moved.

The key combo for this mapping is always "g" + NERDTreeMapOpenSplit (see
|NERDTree-tab|).

------------------------------------------------------------------------------
                                                                  *NERDTree-!*
Default key: !
Map option: NERDTreeMapExecute
Applies to: files.

Executes the selected file, prompting for arguments first.

------------------------------------------------------------------------------
                                                                  *NERDTree-O*
Default key: O
Map option: NERDTreeMapOpenRecursively
Applies to: directories.

Recursively opens the selelected directory.

All files and directories are cached, but if a directory would not be
displayed due to file filters (see |NERDTreeIgnore| |NERDTree-f|) or the
hidden file filter (see |NERDTreeShowHidden|) then it is not opened. This is
handy, especially if you have .svn directories.


------------------------------------------------------------------------------
                                                                  *NERDTree-x*
Default key: x
Map option: NERDTreeMapCloseDir
Applies to: files and directories.

Closes the parent of the selected node.

------------------------------------------------------------------------------
                                                                  *NERDTree-X*
Default key: X
Map option: NERDTreeMapCloseChildren
Applies to: directories.

Recursively closes all children of the selected directory.

Tip: To quickly "reset" the tree, use |NERDTree-P| with this mapping.

------------------------------------------------------------------------------
                                                                  *NERDTree-e*
Default key: e
Map option: NERDTreeMapOpenExpl
Applies to: files and directories.

Opens a netrw on the selected directory, or the selected file's directory.

------------------------------------------------------------------------------
                                                                  *NERDTree-P*
Default key: P
Map option: NERDTreeMapJumpRoot
Applies to: no restrictions.

Jump to the tree root.

------------------------------------------------------------------------------
                                                                  *NERDTree-p*
Default key: p
Map option: NERDTreeMapJumpParent
Applies to: files and directories.

Jump to the parent node of the selected node.

------------------------------------------------------------------------------
                                                                  *NERDTree-K*
Default key: K
Map option: NERDTreeMapJumpFirstChild
Applies to: files and directories.

Jump to the first child of the current nodes parent.

If the cursor is already on the first node then do the following:
    * loop back thru the siblings of the current nodes parent until we find an
      open dir with children
    * go to the first child of that node

------------------------------------------------------------------------------
                                                                  *NERDTree-J*
Default key: J
Map option: NERDTreeMapJumpLastChild
Applies to: files and directories.

Jump to the last child of the current nodes parent.

If the cursor is already on the last node then do the following:
    * loop forward thru the siblings of the current nodes parent until we find
      an open dir with children
    * go to the last child of that node

------------------------------------------------------------------------------
                                                                *NERDTree-c-j*
Default key: <C-j>
Map option: NERDTreeMapJumpNextSibling
Applies to: files and directories.

If a dir node is selected, jump to the next sibling of that node.
If a file node is selected, jump to the next sibling of that nodes parent.

------------------------------------------------------------------------------
                                                                *NERDTree-c-k*
Default key: <C-k>
Map option: NERDTreeMapJumpPrevSibling
Applies to: files and directories.

If a dir node is selected, jump to the previous sibling of that node.
If a file node is selected, jump to the previous sibling of that nodes parent.

------------------------------------------------------------------------------
                                                                  *NERDTree-C*
Default key: C
Map option: NERDTreeMapChdir
Applies to: directories.

Made the selected directory node the new tree root.

------------------------------------------------------------------------------
                                                                  *NERDTree-u*
Default key: u
Map option: NERDTreeMapUpdir
Applies to: no restrictions.

Move the tree root up a dir (like doing a "cd ..").

------------------------------------------------------------------------------
                                                                  *NERDTree-U*
Default key: U
Map option: NERDTreeMapUpdirKeepOpen
Applies to: no restrictions.

Like |NERDTree-u| except that the old tree root is kept open.

------------------------------------------------------------------------------
                                                                  *NERDTree-r*
Default key: r
Map option: NERDTreeMapRefresh
Applies to: files and directories.

If a dir is selected, recursively refresh that dir, i.e. scan the filesystem
for changes and represent them in the tree.

If a file node is selected then the above is done on it's parent.

------------------------------------------------------------------------------
                                                                  *NERDTree-R*
Default key: R
Map option: NERDTreeMapRefreshRoot
Applies to: no restrictions.

Recursively refresh the tree root.

------------------------------------------------------------------------------
                                                                  *NERDTree-m*
Default key: m
Map option: NERDTreeMapFilesystemMenu
Applies to: files and directories.

Display the filesystem menu. See |NERDTreeFilesysMenu| for details.

------------------------------------------------------------------------------
                                                                  *NERDTree-H*
Default key: H
Map option: NERDTreeMapToggleHidden
Applies to: no restrictions.

Toggles whether hidden files are displayed. Hidden files are any
file/directory that starts with a "."

------------------------------------------------------------------------------
                                                                  *NERDTree-f*
Default key: f
Map option: NERDTreeMapToggleFilters
Applies to: no restrictions.

Toggles whether file filters are used. See |NERDTreeIgnore| for details.

------------------------------------------------------------------------------
                                                                  *NERDTree-F*
Default key: F
Map option: NERDTreeMapToggleFiles
Applies to: no restrictions.

Toggles whether file nodes are displayed.

------------------------------------------------------------------------------
                                                                  *NERDTree-q*
Default key: q
Map option: NERDTreeMapQuit
Applies to: no restrictions.

Closes the NERDtree window.

------------------------------------------------------------------------------
                                                                  *NERDTree-?*
Default key: ?
Map option: NERDTreeMapHelp
Applies to: no restrictions.

Toggles whether the quickhelp is displayed.

------------------------------------------------------------------------------
2.3. The filesystem menu {{{3                            *NERDTreeFilesysMenu*

The purpose of the filesystem menu is to allow you to perform basic filesystem
operations quickly from the NERD tree rather than the console.  

The filesystem menu can be accessed with 'm' mapping and has three supported
operations: >
    1. Adding nodes.
    2. Renaming nodes.
    3. Deleting nodes.
<
1. Adding nodes:
To add a node move the cursor onto (or anywhere inside) the directory you wish
to create the new node inside. Select the 'add node' option from the
filesystem menu and type a filename. If the filename you type ends with a '/'
character then a directory will be created. Once the operation is completed,
the cursor is placed on the new node.

2. Renaming nodes:
To rename a node, put the cursor on it and select the 'rename' option from the
filesystem menu.  Enter the new name for the node and it will be renamed. If
the old file is open in a buffer, you will be asked if you wish to delete that
buffer. Once the operation is complete the cursor will be placed on the
renamed node.

3. Deleting nodes:
To delete a node put the cursor on it and select the 'delete' option from the
filesystem menu. After confirmation the node will be deleted. If a file is
deleted but still exists as a buffer you will be given the option to delete
that buffer. 

==============================================================================
3. Customisation {{{2                                        *NERDTreeOptions*


------------------------------------------------------------------------------
3.1. Customisation summary {{{3                        *NERDTreeOptionSummary*

The script provides the following options that can customise the behaviour the
NERD tree. These options should be set in your vimrc.

|loaded_nerd_tree|              Turns off the script.

|NERDChristmasTree|             Tells the NERD tree to make itself colourful
                                and pretty.

|NERDTreeAutoCenter|            Controls whether the NERD tree window centers
                                when the cursor moves within a specified
                                distance to the top/bottom of the window.
|NERDTreeAutoCenterThreshold|   Controls the sensitivity of autocentering.

|NERDTreeCaseSensitiveSort|     Tells the NERD tree whether to be case
                                sensitive or not when sorting nodes.

|NERDTreeChDirMode|             Tells the NERD tree if/when it should change
                                vim's current working directory.

|NERDTreeHighlightCursorline|   Tell the NERD tree whether to highlight the
                                current cursor line.

|NERDTreeIgnore|                Tells the NERD tree which files to ignore.

|NERDTreeMouseMode|             Tells the NERD tree how to handle mouse
                                clicks.

|NERDTreeShowFiles|             Tells the NERD tree whether to display files
                                in the tree on startup.

|NERDTreeShowHidden|            Tells the NERD tree whether to display hidden
                                files on startup.

|NERDTreeSortOrder|             Tell the NERD tree how to sort the nodes in
                                the tree.

|NERDTreeSplitVertical|         Tells the script whether the NERD tree should
                                be created by splitting the window vertically
                                or horizontally.

|NERDTreeWinPos|                Tells the script where to put the NERD tree
                                window.
                               

|NERDTreeWinSize|               Sets the window size when the NERD tree is
                                opened.

------------------------------------------------------------------------------
3.2. Customisation details {{{3                        *NERDTreeOptionDetails*

To enable any of the below options you should put the given line in your 
~/.vimrc

                                                            *loaded_nerd_tree*              
If this plugin is making you feel homicidal, it may be a good idea to turn it
off with this line in your vimrc: >
    let loaded_nerd_tree=1
<
------------------------------------------------------------------------------
                                                           *NERDChristmasTree*
Values: 0 or 1.
Default: 1.

If this option is set to 1 then some extra syntax highlighting elements are
added to the nerd tree to make it more colourful.

Set it to 0 for a more vanilla looking tree.

------------------------------------------------------------------------------
                                                          *NERDTreeAutoCenter*                
Values: 0 or 1.
Default: 1

If set to 1, the NERD tree window will center around the cursor if it moves to
within |NERDTreeAutoCenterThreshold| lines of the top/bottom of the window.

This is ONLY done in response to tree navigation mappings, 
i.e. |NERDTree-J| |NERDTree-K| |NERDTree-C-J| |NERDTree-c-K| |NERDTree-p|
|NERDTree-P|

The centering is done with a |zz| operation.

------------------------------------------------------------------------------
                                                 *NERDTreeAutoCenterThreshold*                
Values: Any natural number.
Default: 3

This option controls the "sensitivity" of the NERD tree auto centering. See
|NERDTreeAutoCenter| for details.

------------------------------------------------------------------------------
                                                   *NERDTreeCaseSensitiveSort*        
Values: 0 or 1.
Default: 0.

By default the NERD tree does not sort nodes case sensitively, i.e. nodes
could appear like this: >
    bar.c
    Baz.c
    blarg.c
    boner.c
    Foo.c
<
But, if you set this option to 1 then the case of the nodes will be taken into
account. The above nodes would then be sorted like this: >
    Baz.c
    Foo.c
    bar.c
    blarg.c
    boner.c
<
------------------------------------------------------------------------------
                                                           *NERDTreeChDirMode*                

Values: 0, 1 or 2.
Default: 1.

Use this option to tell the script when (if at all) to change the current
working directory (CWD) for vim.

If it is set to 0 then the CWD is never changed by the NERD tree.

If set to 1 then the CWD is changed when the NERD tree is first loaded to the
directory it is initialized in. For example, if you start the NERD tree with >
    :NERDTree /home/marty/foobar
<
then the CWD will be changed to /home/marty/foobar and will not be changed
again unless you init another NERD tree with a similar command.

If the option is set to 2 then it behaves the same as if set to 1 except that
the CWD is changed whenever the tree root is changed. For example, if the CWD
is /home/marty/foobar and you make the node for /home/marty/foobar/baz the new
root then the CWD will become /home/marty/foobar/baz.

Note to windows users: it is highly recommended that you have this option set
to either 1 or 2 or else the script wont function properly if you attempt to
open a NERD tree on a different drive to the one vim is currently in.

Authors note: at work i have this option set to 1 because i have a giant ctags
file in the root dir of my project. This way i can initialise the NERD tree
with the root dir of my project and always have ctags available to me --- no
matter where i go with the NERD tree.

------------------------------------------------------------------------------
                                                 *NERDTreeHighlightCursorline*
Values: 0 or 1.
Default: 1.

If set to 1, the current cursor line in the NERD tree buffer will be
highlighted. This is done using the |cursorline| option.

------------------------------------------------------------------------------
                                                              *NERDTreeIgnore*                
Values: a list of regular expressions.
Default: ['\~$'].

This option is used to specify which files the NERD tree should ignore.  It
must be a list of regular expressions. When the NERD tree is rendered, any
files/dirs that match any of the regex's in NERDTreeIgnore wont be displayed. 

For example if you put the following line in your vimrc: >
    let NERDTreeIgnore=['\.vim$', '\~$']
<
then all files ending in .vim or ~ will be ignored. 

Note: to tell the NERD tree not to ignore any files you must use the following
line: >
    let NERDTreeIgnore=[]
<

The file filters can be turned on and off dynamically with the |NERDTree-f|
mapping.

------------------------------------------------------------------------------
                                                           *NERDTreeMouseMode*                
Values: 1, 2 or 3.
Default: 1.

If set to 1 then a double click on a node is required to open it. 
If set to 2 then a single click will open directory nodes, while a double
click will still be required for file nodes.
If set to 3 then a single click will open any node.

Note: a double click anywhere on a line that a tree node is on will
activate it, but all single-click activations must be done on name of the node
itself. For example, if you have the following node: >
    | | |-application.rb
<
then (to single click activate it) you must click somewhere in
'application.rb'.

------------------------------------------------------------------------------
                                                           *NERDTreeShowFiles*            
Values: 0 or 1.
Default: 1.

If this option is set to 1 then files are displayed in the NERD tree. If it is
set to 0 then only directories are displayed.

This option can be toggled dynamically with the |NERDTree-F| mapping and is
useful for drastically shrinking the tree when you are navigating to a
different part of the tree.

------------------------------------------------------------------------------
                                                          *NERDTreeShowHidden*            
Values: 0 or 1.
Default: 0.

This option tells vim whether to display hidden files by default. This option
can be dynamically toggled with the |NERDTree-H| mapping.
Use one of the follow lines to set this option: >
    let NERDTreeShowHidden=0
    let NERDTreeShowHidden=1
<
                                                       
------------------------------------------------------------------------------
                                                           *NERDTreeSortOrder*
Values: a list of regular expressions.
Default: ['\/$', '*', '\.swp$',  '\.bak$', '\~$']

This option is set to a list of regular expressions which are used to
specify the order of nodes under their parent.

For example, if the option is set to: >
    ['\.vim$', '\.c$', '\.h$', '*', 'foobar']
<
then all .vim files will be placed at the top, followed by all .c files then
all .h files. All files containing the string 'foobar' will be placed at the
end.  The star is a special flag: it tells the script that every node that
doesnt match any of the other regexps should be placed here.

If no star is present in NERDTreeSortOrder then one is automatically appended
to the array.

The regex '\/$' should be used to match directory nodes.

After this sorting is done, the files in each group are sorted alphabetically.

Other examples: >
    (1) ['*', '\/$']
    (2) []
    (3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$',  '\.bak$', '\~$']
<
1. Directories will appear last, everything else will appear above.
2. Every will simply appear in alphabetical order.
3. Dirs will appear first, then ruby and php. Swap files, bak files and vim
   backup files will appear last with everything else preceding them.

------------------------------------------------------------------------------
                                                       *NERDTreeSplitVertical*
Values: 0 or 1.
Default: 1.

This option, along with |NERDTreeWinPos|, is used to determine where the NERD
tree window appears. 

If it is set to 1 then the NERD tree window will appear on either the left or
right side of the screen (depending on the |NERDTreeWinPos| option).

If it set to 0 then the NERD tree window will appear at the top of the screen.

------------------------------------------------------------------------------
                                                              *NERDTreeWinPos*
Values: 0 or 1.
Default: 1.

This option works in conjunction with the |NERDTreeSplitVertical| option to
determine where NERD tree window is placed on the screen.

If the option is set to 1 then the NERD tree will appear on the left or top of
the screen (depending on the value of |NERDTreeSplitVertical|). If set to 0,
the window will appear on the right or bottom of the screen. 

This option is makes it possible to use two different explorer type
plugins simultaneously. For example, you could have the taglist plugin on the
left of the window and the NERD tree on the right.

------------------------------------------------------------------------------
                                                             *NERDTreeWinSize*
Values: a positive integer.
Default: 31.

This option is used to change the size of the NERD tree when it is loaded.

==============================================================================
                                                     *NERDTreePublicFunctions*
5. Public functions {{{2 ~

The script provides 2 public functions for your hacking pleasure. Their
signatures are: >
    function! NERDTreeGetCurrentNode()
    function! NERDTreeGetCurrentPath()
<
The first returns the node object that the cursor is currently on, while the
second returns the corresponding path object.

This is probably a good time to mention that the script implements prototype
style OO. To see the functions that each class provides you can read look at
the code.

Use the node objects to manipulate the structure of the tree. Use the path
objects to access the data the tree represents and to make changes to the
filesystem.

==============================================================================
5. TODO list {{{2                                               *NERDTreeTodo*

Window manager integration?

==============================================================================
6. The Author {{{2                                            *NERDTreeAuthor*

The author of the NERD tree is a terrible terrible monster called Martyzilla
who gobbles up small children with milk and sugar for breakfast. He has an odd
love/hate relationship with computers (but monsters hate everything by nature
you know...) which can be awkward for him since he is a pro computer nerd for
a living.

He can be reached at martin_grenfell at msn.com. He would love to hear from
you, so feel free to send him suggestions and/or comments about this plugin.
Don't be shy --- the worst he can do is slaughter you and stuff you in the
fridge for later ;)

==============================================================================
7. Changelog {{{2                                          *NERDTreeChangelog* 

2.6.2
    - Now when you try to open a file node into a window that is modified, the
      window is not split if the &hidden option is set. Thanks to  Niels Aan
      de Brugh for this suggestion.

2.6.1
    - Fixed a major bug with the <tab> mapping. Thanks to Zhang Weiwu for
      emailing me.

2.6.0
    - Extended the behaviour of <c-j/k>. Now if the cursor is on a file node
      and you use <c-j/k> the cursor will jump to its PARENTS next/previous
      sibling. Go :help NERDTree-c-j and :help NERDTree-c-k for info.
    - Extended the behaviour of the J/K mappings. Now if the cursor is on the
      last child of a node and you push J/K it will jump down to the last child
      of the next/prev of its parents siblings that is open and has children.
      Go :help NERDTree-J and :help NERDTree-K for info.
    - The goal of these changes is to make tree navigation faster.
    - Reorganised the help page a bit.
    - Removed the E mapping.
    - bugfixes

2.5.0
    - Added an option to enforce case sensitivity when sorting tree nodes.
      Read :help NERDTreeCaseSensitiveSort for details.  (thanks to Michael
      Madsen for emailing me about this). Case sensitivity defaults to off.
    - Made the script echo a "please wait" style message when opening large
      directories. Thanks to AOYAMA Shotaro for this suggestion.
    - Added 2 public functions that can be used to retrieve the treenode and
      path that the cursor is on. Read :help NERDTreePublicFunctions for
      details (thanks again to AOYAMA Shotaro for the idea :).
    - added 2 new mappings for file nodes: "g<tab>" and "go". These are the
      same as the "<tab>" and "o" maps except that the cursor stays in the
      NERDTree. Note: these maps are slaved to the o and <tab> mappings, so if
      eg you remap "<tab>" to "i" then the "g<tab>" map will also be changed
      to "gi".
    - Renamed many of the help tags to be simpler.
    - Simplified the ascii "graphics" for the filesystem menu
    - Fixed bugs.
    - Probably created bugs.
    - Refactoring.

2.4.0
    - Added the P mapping to jump to the tree root.
    - Added window centering functionality that can be triggered when doing
      using any of the tree nav mappings. Essentially, if the cursor comes
      within a certain distance of the top/bottom of the window then a zz is
      done in the window. Two related options were added: NERDTreeAutoCenter
      to turn this functionality on/off, and NERDTreeAutoCenterThreshold to
      control how close the cursor has to be to the window edge to trigger the
      centering.

2.3.0
    - Tree navigation changes:
      - Added J and K mappings to jump to last/first child of the current dir.
        Options to customise these mappings have also been added.
      - Remapped the jump to next/prev sibling commands to be <C-j> and <C-k> by
        default.
      These changes should hopefully make tree navigation mappings easier to
      remember and use as the j and k keys are simply reused 3 times (twice
      with modifier keys).

    - Made it so that, when any of the tree filters are toggled, the cursor
      stays with the selected node (or goes to its parent/grandparent/... if
      that node is no longer visible)
    - Fixed an error in the doc for the mouse mode option.
    - Made the quickhelp correctly display the current single/double click
      mappings for opening nodes as specified by the NERDTreeMouseMode option.
    - Fixed a bug where the script was spazzing after prompting you to delete
      a modified buffer when using the filesystem menu.  
    - Refactoring
2.2.3
    - Refactored the :echo output from the script.
    - Fixed some minor typos in the doc.
    - Made some minor changes to the output of the 'Tree filtering mappings'
      part of the quickhelp 

2.2.2
    - More bugfixes... doh.

2.2.1
    - Bug fix that was causing an exception when closing the nerd tree. Thanks
      to Tim carey-smith and Yu Jun for pointing this out.

2.2.0
    - Now 'cursorline' is set in the NERD tree buffer by default. See :help
      NERDTreeHighlightCursorline for how to disable it.

2.1.2
    - Stopped the script from clobbering the 1,2,3 .. 9 registers.
    - Made it "silent!"ly delete buffers when renaming/deleting file nodes.
    - Minor correction to the doc
    - Fixed a bug when refreshing that was occurring when the node you
      refreshed had been deleted externally.
    - Fixed a bug that was occurring when you open a file that is already open
      and modified.

2.1.1
    - Added a bit more info about the buffers you are prompted to delete when
      renaming/deleting nodes from the filesystem menu that are already loaded
      into buffers.
    - Refactoring and bugfixes

2.1.0
    - Finally removed the blank line that always appears at the top of the
      NERDTree buffer
    - Added NERDTreeMouseMode option. If set to 1, then a double click is
      required to activate all nodes, if set to 2 then a single click will
      activate directory nodes, if set to 3 then a single click will activate
      all nodes.
    - Now if you delete a file node and have it open in a buffer you are given
      the option to delete that buffer as well. Similarly if you rename a file
      you are given the option to delete any buffers containing the old file
      (if any exist)
    - When you rename or create a node, the cursor is now put on the new node,
      this makes it easy immediately edit  the new file.
    - Fixed a bug with the ! mapping that was occurring on windows with paths
      containing spaces.
    - Made all the mappings customisable. See |NERD_tree-mappings| for
      details. A side effect is that a lot of the "double mappings" have
      disappeared. E.g 'o' is now the key that is used to activate a node,
      <CR> is no longer mapped to the same.
    - Made the script echo warnings in some places rather than standard echos
    - Insane amounts of refactoring all over the place.

2.0.0
    - Added two new NERDChristmasTree decorations. First person to spot them
      and email me gets a free copy of the NERDTree.
    - Made it so that when you jump around the tree (with the p, s and S
      mappings) it is counted as a jump by vim. This means if you, eg, push
      'p' one too many times then you can go `` or ctrl-o.
    - Added a new option called NERDTreeSortOrder which takes an array of
      regexs and is used to determine the order that the treenodes are listed
      in. Go :help NERDTreeSortOrder for details.
    - Removed the NERDTreeSortDirs option because it is consumed by
      NERDTreeSortOrder
    - Added the 'i' mapping which is the same as <tab> but requires less
      effort to reach.
    - Added the ! mapping which is  used to execute file in the tree (after it
      prompts you for arguments etc)


==============================================================================
8. Credits {{{2                                              *NERDTreeCredits*

Thanks to Tim Carey-Smith for testing/using the NERD tree from the first
pre-beta version, for his many suggestions and for his constant stream of bug
complaints.

Thanks to Vigil for trying it out before the first release :) and suggesting
that mappings to open files in new tabs should be implemented.

Thanks to Nick Brettell for testing, fixing my spelling and suggesting i put a
    .. (up a directory)
line in the gui.

Thanks to Thomas Scott Urban - the author of the vtreeexplorer plugin - whose
gui code i borrowed from.

Thanks to Terrance Cohen for pointing out a bug where the script was changing
vims CWD all over the show.

Thanks to Yegappan Lakshmanan (author of Taglist and other orgasmically
wonderful plugins) for telling me how to fix a bug that was causing vim to go
into visual mode everytime you double clicked a node :)

Thanks to Jason Mills for sending me a fix that allows windows paths to use
forward slashes as well as backward.

Thanks to Michael Geddes (frogonwheels on #vim at freenode) for giving me some
tips about syntax highlighting when i was doing highlighting for the
quickhelp.

Thanks to Yu Jun for emailing me about a bug that was occurring when closing
the tree.

Thanks to Michael Madsen for emailing me about making case sensitivity
optional when sorting nodes.

Thanks to AOYAMA Shotaro for suggesting that i echo a "please wait" message
when opening large directories. 

Thanks to Michael Madsen for requesting the NERDTreeCaseSensitiveSort option.

Thanks to AOYAMA Shotaro for suggesting that a "please wait" style message be
echoed when opening large directories. Also, thanks for the suggestion of
having public functions in the script to access the internal data :D

Thanks to Zhang Weiwu for emailing me about a bug with the the <tab> mapping
in 2.6.0

Thanks to  Niels Aan de Brugh for the suggestion that the script now split the
window if you try to open a file in a window containing a modified buffer when
the &hidden option is set.

=== END_DOC
" vim: set ts=4 sw=4 foldmethod=marker foldmarker={{{,}}} foldlevel=2: