--- /dev/null
+" Vim color file
+" Maintainer: Thorsten Maerz <info@netztorte.de>
+" Last Change: 2006 Dec 07
+" grey on black
+" optimized for TFT panels
+
+set background=dark
+hi clear
+if exists("syntax_on")
+ syntax reset
+endif
+"colorscheme default
+let g:colors_name = "cake"
+
+" hardcoded colors :
+" GUI Comment : #80a0ff = Light blue
+
+" GUI
+highlight Normal guifg=Grey80 guibg=Black
+highlight Search guifg=Black guibg=Red gui=bold
+highlight Visual guifg=#404040 gui=bold
+highlight Cursor guifg=Black guibg=Green gui=bold
+highlight Special guifg=Orange
+highlight Comment guifg=#80a0ff
+highlight StatusLine guifg=Black guibg=white
+highlight Statement guifg=Yellow gui=NONE
+highlight Type gui=NONE
+highlight CurBuf guifg=Cyan
+highlight Pmenu guibg=blue gui=bold
+
+" Console
+highlight Normal ctermfg=LightGrey ctermbg=Black
+highlight Search ctermfg=Black ctermbg=Red cterm=NONE
+highlight Visual cterm=reverse
+highlight Cursor ctermfg=Black ctermbg=Green cterm=bold
+highlight Special ctermfg=Brown
+highlight Comment ctermfg=Blue
+highlight StatusLine ctermfg=White ctermbg=Black
+highlight Statement ctermfg=Yellow cterm=NONE
+highlight Type cterm=NONE
+highlight CurBuf ctermfg=Cyan
+highlight Pmenu ctermbg=blue cterm=bold
+
+" only for vim 5
+if has("unix")
+ if v:version<600
+ highlight Normal ctermfg=Grey ctermbg=Black cterm=NONE guifg=Grey80 guibg=Black gui=NONE
+ highlight Search ctermfg=Black ctermbg=Red cterm=bold guifg=Black guibg=Red gui=bold
+ highlight Visual ctermfg=Black ctermbg=yellow cterm=bold guifg=#404040 gui=bold
+ highlight Special ctermfg=LightBlue cterm=NONE guifg=LightBlue gui=NONE
+ highlight Comment ctermfg=Cyan cterm=NONE guifg=LightBlue gui=NONE
+ endif
+endif
+
+++ /dev/null
-*NERD_tree.txt* A tree explorer plugin that owns your momma!
-
-
-
- omg its ... ~
-
- ________ ________ _ ____________ ____ __________ ____________~
- /_ __/ / / / ____/ / | / / ____/ __ \/ __ \ /_ __/ __ \/ ____/ ____/~
- / / / /_/ / __/ / |/ / __/ / /_/ / / / / / / / /_/ / __/ / __/ ~
- / / / __ / /___ / /| / /___/ _, _/ /_/ / / / / _, _/ /___/ /___ ~
- /_/ /_/ /_/_____/ /_/ |_/_____/_/ |_/_____/ /_/ /_/ |_/_____/_____/ ~
-
-
- Reference Manual~
-
-
-
-
-==============================================================================
-CONTENTS *NERDTree-contents*
-
- 1.Intro...................................|NERDTree|
- 2.Functionality provided..................|NERDTreeFunctionality|
- 2.1.Global commands...................|NERDTreeGlobalCommands|
- 2.2.Bookmarks.........................|NERDTreeBookmarks|
- 2.2.1.The bookmark table..........|NERDTreeBookmarkTable|
- 2.2.2.Bookmark commands...........|NERDTreeBookmarkCommands|
- 2.2.3.Invalid bookmarks...........|NERDTreeInvalidBookmarks|
- 2.3.NERD tree mappings................|NERDTreeMappings|
- 2.4.The NERD tree menu................|NERDTreeMenu|
- 3.Options.................................|NERDTreeOptions|
- 3.1.Option summary....................|NERDTreeOptionSummary|
- 3.2.Option details....................|NERDTreeOptionDetails|
- 4.The NERD tree API.......................|NERDTreeAPI|
- 4.1.Key map API.......................|NERDTreeKeymapAPI|
- 4.2.Menu API..........................|NERDTreeMenuAPI|
- 5.About...................................|NERDTreeAbout|
- 6.Changelog...............................|NERDTreeChangelog|
- 7.Credits.................................|NERDTreeCredits|
- 8.License.................................|NERDTreeLicense|
-
-==============================================================================
-1. Intro *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.
-
-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
- * executable 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
- * ...
- * Directories and files can be bookmarked.
- * Most NERD tree navigation can also be done with the mouse
- * Filtering of tree content (can be toggled at runtime)
- * 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
- * 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, share trees across tabs,
- or a mix of both.
- * By default the script overrides the default file browser (netw), so if
- you :edit a directory a (slighly modified) NERD tree will appear in the
- current window
- * A programmable menu system is provided (simulates right clicking on a
- node)
- * one default menu plugin is provided to perform basic filesytem
- operations (create/delete/move/copy files/directories)
- * There's an API for adding your own keymappings
-
-
-==============================================================================
-2. Functionality provided *NERDTreeFunctionality*
-
-------------------------------------------------------------------------------
-2.1. Global Commands *NERDTreeGlobalCommands*
-
-:NERDTree [<start-directory> | <bookmark>] *:NERDTree*
- Opens a fresh NERD tree. The root of the tree depends on the argument
- given. There are 3 cases: If no argument is given, the current directory
- will be used. If a directory is given, that will be used. If a bookmark
- name is given, the corresponding directory will be used. For example: >
- :NERDTree /home/marty/vim7/src
- :NERDTree foo (foo is the name of a bookmark)
-<
-:NERDTreeFromBookmark <bookmark> *:NERDTreeFromBookmark*
- Opens a fresh NERD tree with the root initialized to the dir for
- <bookmark>. This only reason to use this command over :NERDTree is for
- the completion (which is for bookmarks rather than directories).
-
-:NERDTreeToggle [<start-directory> | <bookmark>] *: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.
-
-:NERDTreeMirror *:NERDTreeMirror*
- Shares an existing NERD tree, from another tab, in the current tab.
- Changes made to one tree are reflected in both as they are actually the
- same buffer.
-
- If only one other NERD tree exists, that tree is automatically mirrored. If
- more than one exists, the script will ask which tree to mirror.
-
-:NERDTreeClose *:NERDTreeClose*
- Close the NERD tree in this tab.
-
-:NERDTreeFind *:NERDTreeFind*
- Find the current file in the tree.
-
- If not tree exists and the current file is under vim's CWD, then init a
- tree at the CWD and reveal the file. Otherwise init a tree in the current
- file's directory.
-
- In any case, the current file is revealed and the cursor is placed on it.
-
-------------------------------------------------------------------------------
-2.2. Bookmarks *NERDTreeBookmarks*
-
-Bookmarks in the NERD tree are a way to tag files or directories of interest.
-For example, you could use bookmarks to tag all of your project directories.
-
-------------------------------------------------------------------------------
-2.2.1. The Bookmark Table *NERDTreeBookmarkTable*
-
-If the bookmark table is active (see |NERDTree-B| and
-|'NERDTreeShowBookmarks'|), it will be rendered above the tree. You can double
-click bookmarks or use the |NERDTree-o| mapping to activate them. See also,
-|NERDTree-t| and |NERDTree-T|
-
-------------------------------------------------------------------------------
-2.2.2. Bookmark commands *NERDTreeBookmarkCommands*
-
-Note that the following commands are only available in the NERD tree buffer.
-
-:Bookmark <name>
- Bookmark the current node as <name>. If there is already a <name>
- bookmark, it is overwritten. <name> must not contain spaces.
- If <name> is not provided, it defaults to the file or directory name.
- For directories, a trailing slash is present.
-
-:BookmarkToRoot <bookmark>
- Make the directory corresponding to <bookmark> the new root. If a treenode
- corresponding to <bookmark> is already cached somewhere in the tree then
- the current tree will be used, otherwise a fresh tree will be opened.
- Note that if <bookmark> points to a file then its parent will be used
- instead.
-
-:RevealBookmark <bookmark>
- If the node is cached under the current root then it will be revealed
- (i.e. directory nodes above it will be opened) and the cursor will be
- placed on it.
-
-:OpenBookmark <bookmark>
- <bookmark> must point to a file. The file is opened as though |NERDTree-o|
- was applied. If the node is cached under the current root then it will be
- revealed and the cursor will be placed on it.
-
-:ClearBookmarks [<bookmarks>]
- Remove all the given bookmarks. If no bookmarks are given then remove all
- bookmarks on the current node.
-
-:ClearAllBookmarks
- Remove all bookmarks.
-
-:ReadBookmarks
- Re-read the bookmarks in the |'NERDTreeBookmarksFile'|.
-
-See also |:NERDTree| and |:NERDTreeFromBookmark|.
-
-------------------------------------------------------------------------------
-2.2.3. Invalid Bookmarks *NERDTreeInvalidBookmarks*
-
-If invalid bookmarks are detected, the script will issue an error message and
-the invalid bookmarks will become unavailable for use.
-
-These bookmarks will still be stored in the bookmarks file (see
-|'NERDTreeBookmarksFile'|), down the bottom. There will always be a blank line
-after the valid bookmarks but before the invalid ones.
-
-Each line in the bookmarks file represents one bookmark. The proper format is:
-<bookmark name><space><full path to the bookmark location>
-
-After you have corrected any invalid bookmarks, either restart vim, or go
-:ReadBookmarks from the NERD tree window.
-
-------------------------------------------------------------------------------
-2.3. NERD tree Mappings *NERDTreeMappings*
-
-Default Description~ help-tag~
-Key~
-
-o.......Open files, directories and bookmarks....................|NERDTree-o|
-go......Open selected file, but leave cursor in the NERDTree.....|NERDTree-go|
-t.......Open selected node/bookmark in a new tab.................|NERDTree-t|
-T.......Same as 't' but keep the focus on the current tab........|NERDTree-T|
-i.......Open selected file in a split window.....................|NERDTree-i|
-gi......Same as i, but leave the cursor on the NERDTree..........|NERDTree-gi|
-s.......Open selected file in a new vsplit.......................|NERDTree-s|
-gs......Same as s, but leave the cursor on the NERDTree..........|NERDTree-gs|
-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.......Edit the current dif.....................................|NERDTree-e|
-
-<CR>...............same as |NERDTree-o|.
-double-click.......same as the |NERDTree-o| map.
-middle-click.......same as |NERDTree-i| for files, same as
- |NERDTree-e| for dirs.
-
-D.......Delete the current bookmark .............................|NERDTree-D|
-
-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 NERD tree menu...............................|NERDTree-m|
-cd......Change the CWD to the dir of the selected node...........|NERDTree-cd|
-
-I.......Toggle whether hidden files displayed....................|NERDTree-I|
-f.......Toggle whether the file filters are used.................|NERDTree-f|
-F.......Toggle whether files are displayed.......................|NERDTree-F|
-B.......Toggle whether the bookmark table is displayed...........|NERDTree-B|
-
-q.......Close the NERDTree window................................|NERDTree-q|
-A.......Zoom (maximize/minimize) the NERDTree window.............|NERDTree-A|
-?.......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.
-
-If a bookmark that links to a directory is selected then that directory
-becomes the new root.
-
-If a bookmark that links to a file is selected then that file is opened in the
-previous window.
-
-------------------------------------------------------------------------------
- *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 fresh
-NERD Tree for that directory is opened in a new tab.
-
-If a bookmark which points to a directory is selected, open a NERD tree for
-that directory in a new tab. If the bookmark points to a file, open that file
-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-i*
-Default key: i
-Map option: NERDTreeMapOpenSplit
-Applies to: files.
-
-Opens the selected file in a new split window and puts the cursor in the new
-window.
-
-------------------------------------------------------------------------------
- *NERDTree-gi*
-Default key: gi
-Map option: None
-Applies to: files.
-
-The same as |NERDTree-i| except that the cursor is not moved.
-
-The key combo for this mapping is always "g" + NERDTreeMapOpenSplit (see
-|NERDTree-i|).
-
-------------------------------------------------------------------------------
- *NERDTree-s*
-Default key: s
-Map option: NERDTreeMapOpenVSplit
-Applies to: files.
-
-Opens the selected file in a new vertically split window and puts the cursor in
-the new window.
-
-------------------------------------------------------------------------------
- *NERDTree-gs*
-Default key: gs
-Map option: None
-Applies to: files.
-
-The same as |NERDTree-s| except that the cursor is not moved.
-
-The key combo for this mapping is always "g" + NERDTreeMapOpenVSplit (see
-|NERDTree-s|).
-
-------------------------------------------------------------------------------
- *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 its contents are not
-cached. 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.
-
-|:edit|s the selected directory, or the selected file's directory. This could
-result in a NERD tree or a netrw being opened, depending on
-|'NERDTreeHijackNetrw'|.
-
-------------------------------------------------------------------------------
- *NERDTree-D*
-Default key: D
-Map option: NERDTreeMapDeleteBookmark
-Applies to: lines in the bookmarks table
-
-Deletes the currently selected bookmark.
-
-------------------------------------------------------------------------------
- *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.
-
-Jump to the next sibling of the selected node.
-
-------------------------------------------------------------------------------
- *NERDTree-C-K*
-Default key: <C-K>
-Map option: NERDTreeMapJumpPrevSibling
-Applies to: files and directories.
-
-Jump to the previous sibling of the selected node.
-
-------------------------------------------------------------------------------
- *NERDTree-C*
-Default key: C
-Map option: NERDTreeMapChdir
-Applies to: directories.
-
-Make the selected directory node the new tree root. If a file is selected, its
-parent is used.
-
-------------------------------------------------------------------------------
- *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: NERDTreeMapMenu
-Applies to: files and directories.
-
-Display the NERD tree menu. See |NERDTreeMenu| for details.
-
-------------------------------------------------------------------------------
- *NERDTree-cd*
-Default key: cd
-Map option: NERDTreeMapChdir
-Applies to: files and directories.
-
-Change vims current working directory to that of the selected node.
-
-------------------------------------------------------------------------------
- *NERDTree-I*
-Default key: I
-Map option: NERDTreeMapToggleHidden
-Applies to: no restrictions.
-
-Toggles whether hidden files (i.e. "dot files") are displayed.
-
-------------------------------------------------------------------------------
- *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-B*
-Default key: B
-Map option: NERDTreeMapToggleBookmarks
-Applies to: no restrictions.
-
-Toggles whether the bookmarks table is displayed.
-
-------------------------------------------------------------------------------
- *NERDTree-q*
-Default key: q
-Map option: NERDTreeMapQuit
-Applies to: no restrictions.
-
-Closes the NERDtree window.
-
-------------------------------------------------------------------------------
- *NERDTree-A*
-Default key: A
-Map option: NERDTreeMapToggleZoom
-Applies to: no restrictions.
-
-Maximize (zoom) and minimize the NERDtree window.
-
-------------------------------------------------------------------------------
- *NERDTree-?*
-Default key: ?
-Map option: NERDTreeMapHelp
-Applies to: no restrictions.
-
-Toggles whether the quickhelp is displayed.
-
-------------------------------------------------------------------------------
-2.3. The NERD tree menu *NERDTreeMenu*
-
-The NERD tree has a menu that can be programmed via the an API (see
-|NERDTreeMenuAPI|). The idea is to simulate the "right click" menus that most
-file explorers have.
-
-The script comes with two default menu plugins: exec_menuitem.vim and
-fs_menu.vim. fs_menu.vim adds some basic filesystem operations to the menu for
-creating/deleting/moving/copying files and dirs. exec_menuitem.vim provides a
-menu item to execute executable files.
-
-Related tags: |NERDTree-m| |NERDTreeApi|
-
-==============================================================================
-3. Customisation *NERDTreeOptions*
-
-
-------------------------------------------------------------------------------
-3.1. Customisation summary *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.
-
-|'NERDTreeHijackNetrw'| Tell the NERD tree whether to replace the netrw
- autocommands for exploring local directories.
-
-|'NERDTreeIgnore'| Tells the NERD tree which files to ignore.
-
-|'NERDTreeBookmarksFile'| Where the bookmarks are stored.
-
-|'NERDTreeMouseMode'| Tells the NERD tree how to handle mouse
- clicks.
-
-|'NERDTreeQuitOnOpen'| Closes the tree window after opening a file.
-
-|'NERDTreeShowBookmarks'| Tells the NERD tree whether to display the
- bookmarks table on startup.
-
-|'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.
-
-|'NERDTreeShowLineNumbers'| Tells the NERD tree whether to display line
- numbers in the tree window.
-
-|'NERDTreeSortOrder'| Tell the NERD tree how to sort the nodes in
- the tree.
-
-|'NERDTreeStatusline'| Set a statusline for NERD tree windows.
-
-|'NERDTreeWinPos'| Tells the script where to put the NERD tree
- window.
-
-|'NERDTreeWinSize'| Sets the window size when the NERD tree is
- opened.
-
-|'NERDTreeMinimalUI'| Disables display of the 'Bookmarks' label and
- 'Press ? for help' text.
-
-|'NERDTreeDirArrows'| Tells the NERD tree to use arrows instead of
- + ~ chars when displaying directories.
-
-------------------------------------------------------------------------------
-3.2. Customisation details *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: 0.
-
-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.
-
-------------------------------------------------------------------------------
- *'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.
-
-------------------------------------------------------------------------------
- *'NERDTreeHijackNetrw'*
-Values: 0 or 1.
-Default: 1.
-
-If set to 1, doing a >
- :edit <some directory>
-<
-will open up a "secondary" NERD tree instead of a netrw in the target window.
-
-Secondary NERD trees behaves slighly different from a regular trees in the
-following respects:
- 1. 'o' will open the selected file in the same window as the tree,
- replacing it.
- 2. you can have as many secondary tree as you want in the same tab.
-
-------------------------------------------------------------------------------
- *'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.
-
-------------------------------------------------------------------------------
- *'NERDTreeBookmarksFile'*
-Values: a path
-Default: $HOME/.NERDTreeBookmarks
-
-This is where bookmarks are saved. See |NERDTreeBookmarkCommands|.
-
-------------------------------------------------------------------------------
- *'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'.
-
-------------------------------------------------------------------------------
- *'NERDTreeQuitOnOpen'*
-
-Values: 0 or 1.
-Default: 0
-
-If set to 1, the NERD tree window will close after opening a file with the
-|NERDTree-o|, |NERDTree-i|, |NERDTree-t| and |NERDTree-T| mappings.
-
-------------------------------------------------------------------------------
- *'NERDTreeShowBookmarks'*
-Values: 0 or 1.
-Default: 0.
-
-If this option is set to 1 then the bookmarks table will be displayed.
-
-This option can be toggled dynamically, per tree, with the |NERDTree-B|
-mapping.
-
-------------------------------------------------------------------------------
- *'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, per tree, 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, per tree, with the |NERDTree-I| mapping. Use one
-of the follow lines to set this option: >
- let NERDTreeShowHidden=0
- let NERDTreeShowHidden=1
-<
-
-------------------------------------------------------------------------------
- *'NERDTreeShowLineNumbers'*
-Values: 0 or 1.
-Default: 0.
-
-This option tells vim whether to display line numbers for the NERD tree
-window. Use one of the follow lines to set this option: >
- let NERDTreeShowLineNumbers=0
- let NERDTreeShowLineNumbers=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. Everything 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.
-
-------------------------------------------------------------------------------
- *'NERDTreeStatusline'*
-Values: Any valid statusline setting.
-Default: %{b:NERDTreeRoot.path.strForOS(0)}
-
-Tells the script what to use as the |'statusline'| setting for NERD tree
-windows.
-
-Note that the statusline is set using |:let-&| not |:set| so escaping spaces
-isn't necessary.
-
-Setting this option to -1 will will deactivate it so that your global
-statusline setting is used instead.
-
-------------------------------------------------------------------------------
- *'NERDTreeWinPos'*
-Values: "left" or "right"
-Default: "left".
-
-This option is used to determine where NERD tree window is placed on the
-screen.
-
-This option makes it possible to use two different explorer 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.
-
-------------------------------------------------------------------------------
- *'NERDTreeMinimalUI'*
-Values: 0 or 1
-Default: 0
-
-This options disables the 'Bookmarks' label 'Press ? for help' text. Use one
-of the following lines to set this option: >
- let NERDTreeMinimalUI=0
- let NERDTreeMinimalUI=1
-<
-
-------------------------------------------------------------------------------
- *'NERDTreeDirArrows'*
-Values: 0 or 1
-Default: 0.
-
-This option is used to change the default look of directory nodes displayed in
-the tree. When set to 0 it shows old-school bars (|), + and ~ chars. If set to
-1 it shows right and down arrows. Use one of the follow lines to set this
-option: >
- let NERDTreeDirArrows=0
- let NERDTreeDirArrows=1
-<
-
-==============================================================================
-4. The NERD tree API *NERDTreeAPI*
-
-The NERD tree script allows you to add custom key mappings and menu items via
-a set of API calls. Any scripts that use this API should be placed in
-~/.vim/nerdtree_plugin/ (*nix) or ~/vimfiles/nerdtree_plugin (windows).
-
-The script exposes some prototype objects that can be used to manipulate the
-tree and/or get information from it: >
- g:NERDTreePath
- g:NERDTreeDirNode
- g:NERDTreeFileNode
- g:NERDTreeBookmark
-<
-See the code/comments in NERD_tree.vim to find how to use these objects. The
-following code conventions are used:
- * class members start with a capital letter
- * instance members start with a lower case letter
- * private members start with an underscore
-
-See this blog post for more details:
- http://got-ravings.blogspot.com/2008/09/vim-pr0n-prototype-based-objects.html
-
-------------------------------------------------------------------------------
-4.1. Key map API *NERDTreeKeymapAPI*
-
-NERDTreeAddKeyMap({options}) *NERDTreeAddKeyMap()*
- Adds a new keymapping for all NERD tree buffers.
- {options} must be a dictionary, and must contain the following keys:
- "key" - the trigger key for the new mapping
- "callback" - the function the new mapping will be bound to
- "quickhelpText" - the text that will appear in the quickhelp (see
- |NERDTree-?|)
-
- Example: >
- call NERDTreeAddKeyMap({
- \ 'key': 'b',
- \ 'callback': 'NERDTreeEchoCurrentNode',
- \ 'quickhelpText': 'echo full path of current node' })
-
- function! NERDTreeEchoCurrentNode()
- let n = g:NERDTreeFileNode.GetSelected()
- if n != {}
- echomsg 'Current node: ' . n.path.str()
- endif
- endfunction
-<
- This code should sit in a file like ~/.vim/nerdtree_plugin/mymapping.vim.
- It adds a (rather useless) mapping on 'b' which echos the full path to the
- current node.
-
-------------------------------------------------------------------------------
-4.2. Menu API *NERDTreeMenuAPI*
-
-NERDTreeAddSubmenu({options}) *NERDTreeAddSubmenu()*
- Creates and returns a new submenu.
-
- {options} must be a dictionary and must contain the following keys:
- "text" - the text of the submenu that the user will see
- "shortcut" - a shortcut key for the submenu (need not be unique)
-
- The following keys are optional:
- "isActiveCallback" - a function that will be called to determine whether
- this submenu item will be displayed or not. The callback function must return
- 0 or 1.
- "parent" - the parent submenu of the new submenu (returned from a previous
- invocation of NERDTreeAddSubmenu()). If this key is left out then the new
- submenu will sit under the top level menu.
-
- See below for an example.
-
-NERDTreeAddMenuItem({options}) *NERDTreeAddMenuItem()*
- Adds a new menu item to the NERD tree menu (see |NERDTreeMenu|).
-
- {options} must be a dictionary and must contain the
- following keys:
- "text" - the text of the menu item which the user will see
- "shortcut" - a shortcut key for the menu item (need not be unique)
- "callback" - the function that will be called when the user activates the
- menu item.
-
- The following keys are optional:
- "isActiveCallback" - a function that will be called to determine whether
- this menu item will be displayed or not. The callback function must return
- 0 or 1.
- "parent" - if the menu item belongs under a submenu then this key must be
- specified. This value for this key will be the object that
- was returned when the submenu was created with |NERDTreeAddSubmenu()|.
-
- See below for an example.
-
-NERDTreeAddMenuSeparator([{options}]) *NERDTreeAddMenuSeparator()*
- Adds a menu separator (a row of dashes).
-
- {options} is an optional dictionary that may contain the following keys:
- "isActiveCallback" - see description in |NERDTreeAddMenuItem()|.
-
-Below is an example of the menu API in action. >
- call NERDTreeAddMenuSeparator()
-
- call NERDTreeAddMenuItem({
- \ 'text': 'a (t)op level menu item',
- \ 'shortcut': 't',
- \ 'callback': 'SomeFunction' })
-
- let submenu = NERDTreeAddSubmenu({
- \ 'text': 'a (s)ub menu',
- \ 'shortcut': 's' })
-
- call NERDTreeAddMenuItem({
- \ 'text': '(n)ested item 1',
- \ 'shortcut': 'n',
- \ 'callback': 'SomeFunction',
- \ 'parent': submenu })
-
- call NERDTreeAddMenuItem({
- \ 'text': '(n)ested item 2',
- \ 'shortcut': 'n',
- \ 'callback': 'SomeFunction',
- \ 'parent': submenu })
-<
-This will create the following menu: >
- --------------------
- a (t)op level menu item
- a (s)ub menu
-<
-Where selecting "a (s)ub menu" will lead to a second menu: >
- (n)ested item 1
- (n)ested item 2
-<
-When any of the 3 concrete menu items are selected the function "SomeFunction"
-will be called.
-
-------------------------------------------------------------------------------
-NERDTreeRender() *NERDTreeRender()*
- Re-renders the NERD tree buffer. Useful if you change the state of the
- tree and you want to it to be reflected in the UI.
-
-==============================================================================
-5. About *NERDTreeAbout*
-
-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 can be reached at martin.grenfell at gmail dot 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 ;)
-
-The latest stable versions can be found at
- http://www.vim.org/scripts/script.php?script_id=1658
-
-The latest dev versions are on github
- http://github.com/scrooloose/nerdtree
-
-
-==============================================================================
-6. Changelog *NERDTreeChangelog*
-
-4.2.0
- - Add NERDTreeDirArrows option to make the UI use pretty arrow chars
- instead of the old +~| chars to define the tree structure (sickill)
- - shift the syntax highlighting out into its own syntax file (gnap)
- - add some mac specific options to the filesystem menu - for macvim
- only (andersonfreitas)
- - Add NERDTreeMinimalUI option to remove some non functional parts of the
- nerdtree ui (camthompson)
- - tweak the behaviour of :NERDTreeFind - see :help :NERDTreeFind for the
- new behaviour (benjamingeiger)
- - if no name is given to :Bookmark, make it default to the name of the
- target file/dir (minyoung)
- - use 'file' completion when doing copying, create, and move
- operations (EvanDotPro)
- - lots of misc bug fixes (paddyoloughlin, sdewald, camthompson, Vitaly
- Bogdanov, AndrewRadev, mathias, scottstvnsn, kml, wycats, me RAWR!)
-
-4.1.0
- features:
- - NERDTreeFind to reveal the node for the current buffer in the tree,
- see |NERDTreeFind|. This effectively merges the FindInNERDTree plugin (by
- Doug McInnes) into the script.
- - make NERDTreeQuitOnOpen apply to the t/T keymaps too. Thanks to Stefan
- Ritter and Rémi Prévost.
- - truncate the root node if wider than the tree window. Thanks to Victor
- Gonzalez.
-
- bugfixes:
- - really fix window state restoring
- - fix some win32 path escaping issues. Thanks to Stephan Baumeister, Ricky,
- jfilip1024, and Chris Chambers
-
-4.0.0
- - add a new programmable menu system (see :help NERDTreeMenu).
- - add new APIs to add menus/menu-items to the menu system as well as
- custom key mappings to the NERD tree buffer (see :help NERDTreeAPI).
- - removed the old API functions
- - added a mapping to maximize/restore the size of nerd tree window, thanks
- to Guillaume Duranceau for the patch. See :help NERDTree-A for details.
-
- - fix a bug where secondary nerd trees (netrw hijacked trees) and
- NERDTreeQuitOnOpen didnt play nicely, thanks to Curtis Harvey.
- - fix a bug where the script ignored directories whose name ended in a dot,
- thanks to Aggelos Orfanakos for the patch.
- - fix a bug when using the x mapping on the tree root, thanks to Bryan
- Venteicher for the patch.
- - fix a bug where the cursor position/window size of the nerd tree buffer
- wasnt being stored on closing the window, thanks to Richard Hart.
- - fix a bug where NERDTreeMirror would mirror the wrong tree
-
-3.1.1
- - fix a bug where a non-listed no-name buffer was getting created every
- time the tree windows was created, thanks to Derek Wyatt and owen1
- - make <CR> behave the same as the 'o' mapping
- - some helptag fixes in the doc, thanks strull
- - fix a bug when using :set nohidden and opening a file where the previous
- buf was modified. Thanks iElectric
- - other minor fixes
-
-3.1.0
- New features:
- - add mappings to open files in a vsplit, see :help NERDTree-s and :help
- NERDTree-gs
- - make the statusline for the nerd tree window default to something
- hopefully more useful. See :help 'NERDTreeStatusline'
- Bugfixes:
- - make the hijack netrw functionality work when vim is started with "vim
- <some dir>" (thanks to Alf Mikula for the patch).
- - fix a bug where the CWD wasnt being changed for some operations even when
- NERDTreeChDirMode==2 (thanks to Lucas S. Buchala)
- - add -bar to all the nerd tree :commands so they can chain with other
- :commands (thanks to tpope)
- - fix bugs when ignorecase was set (thanks to nach)
- - fix a bug with the relative path code (thanks to nach)
- - fix a bug where doing a :cd would cause :NERDTreeToggle to fail (thanks nach)
-
-
-3.0.1
- Bugfixes:
- - fix bugs with :NERDTreeToggle and :NERDTreeMirror when 'hidden
- was not set
- - fix a bug where :NERDTree <path> would fail if <path> was relative and
- didnt start with a ./ or ../ Thanks to James Kanze.
- - make the q mapping work with secondary (:e <dir> style) trees,
- thanks to jamessan
- - fix a bunch of small bugs with secondary trees
-
- More insane refactoring.
-
-3.0.0
- - hijack netrw so that doing an :edit <directory> will put a NERD tree in
- the window rather than a netrw browser. See :help 'NERDTreeHijackNetrw'
- - allow sharing of trees across tabs, see :help :NERDTreeMirror
- - remove "top" and "bottom" as valid settings for NERDTreeWinPos
- - change the '<tab>' mapping to 'i'
- - change the 'H' mapping to 'I'
- - lots of refactoring
-
-==============================================================================
-7. Credits *NERDTreeCredits*
-
-Thanks to the following people for testing, bug reports, ideas etc. Without
-you I probably would have got bored of the hacking the NERD tree and
-just downloaded pr0n instead.
-
- Tim Carey-Smith (halorgium)
- Vigil
- Nick Brettell
- Thomas Scott Urban
- Terrance Cohen
- Yegappan Lakshmanan
- Jason Mills
- Michael Geddes (frogonwheels)
- Yu Jun
- Michael Madsen
- AOYAMA Shotaro
- Zhang Weiwu
- Niels Aan de Brugh
- Olivier Yiptong
- Zhang Shuhan
- Cory Echols
- Piotr Czachur
- Yuan Jiang
- Matan Nassau
- Maxim Kim
- Charlton Wang
- Matt Wozniski (godlygeek)
- knekk
- Sean Chou
- Ryan Penn
- Simon Peter Nicholls
- Michael Foobar
- Tomasz Chomiuk
- Denis Pokataev
- Tim Pope (tpope)
- James Kanze
- James Vega (jamessan)
- Frederic Chanal (nach)
- Alf Mikula
- Lucas S. Buchala
- Curtis Harvey
- Guillaume Duranceau
- Richard Hart (hates)
- Doug McInnes
- Stefan Ritter
- Rémi Prévost
- Victor Gonzalez
- Stephan Baumeister
- Ricky
- jfilip1024
- Chris Chambers
- Vitaly Bogdanov
- Patrick O'Loughlin (paddyoloughlin)
- Cam Thompson (camthompson)
- Marcin Kulik (sickill)
- Steve DeWald (sdewald)
- Ivan Necas (iNecas)
- George Ang (gnap)
- Evan Coury (EvanDotPro)
- Andrew Radev (AndrewRadev)
- Matt Gauger (mathias)
- Scott Stevenson (scottstvnsn)
- Anderson Freitas (andersonfreitas)
- Kamil K. Lemański (kml)
- Yehuda Katz (wycats)
- Min-Young Wu (minyoung)
- Benjamin Geiger (benjamingeiger)
-
-==============================================================================
-8. License *NERDTreeLicense*
-
-The NERD tree is released under the wtfpl.
-See http://sam.zoy.org/wtfpl/COPYING.
+++ /dev/null
-" ============================================================================
-" File: exec_menuitem.vim
-" Description: plugin for NERD Tree that provides an execute file menu item
-" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
-" Last Change: 22 July, 2009
-" License: This program is free software. It comes without any warranty,
-" to the extent permitted by applicable law. You can redistribute
-" it and/or modify it under the terms of the Do What The Fuck You
-" Want To Public License, Version 2, as published by Sam Hocevar.
-" See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-" ============================================================================
-if exists("g:loaded_nerdtree_exec_menuitem")
- finish
-endif
-let g:loaded_nerdtree_exec_menuitem = 1
-
-call NERDTreeAddMenuItem({
- \ 'text': '(!)Execute file',
- \ 'shortcut': '!',
- \ 'callback': 'NERDTreeExecFile',
- \ 'isActiveCallback': 'NERDTreeExecFileActive' })
-
-function! NERDTreeExecFileActive()
- let node = g:NERDTreeFileNode.GetSelected()
- return !node.path.isDirectory && node.path.isExecutable
-endfunction
-
-function! NERDTreeExecFile()
- let treenode = g:NERDTreeFileNode.GetSelected()
- echo "==========================================================\n"
- echo "Complete the command to execute (add arguments etc):\n"
- let cmd = treenode.path.str({'escape': 1})
- let cmd = input(':!', cmd . ' ')
-
- if cmd != ''
- exec ':!' . cmd
- else
- echo "Aborted"
- endif
-endfunction
+++ /dev/null
-" ============================================================================
-" File: fs_menu.vim
-" Description: plugin for the NERD Tree that provides a file system menu
-" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
-" Last Change: 17 July, 2009
-" License: This program is free software. It comes without any warranty,
-" to the extent permitted by applicable law. You can redistribute
-" it and/or modify it under the terms of the Do What The Fuck You
-" Want To Public License, Version 2, as published by Sam Hocevar.
-" See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-" ============================================================================
-if exists("g:loaded_nerdtree_fs_menu")
- finish
-endif
-let g:loaded_nerdtree_fs_menu = 1
-
-call NERDTreeAddMenuItem({'text': '(a)dd a childnode', 'shortcut': 'a', 'callback': 'NERDTreeAddNode'})
-call NERDTreeAddMenuItem({'text': '(m)ove the current node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'})
-call NERDTreeAddMenuItem({'text': '(d)elete the current node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'})
-
-if has("gui_mac") || has("gui_macvim")
- call NERDTreeAddMenuItem({'text': '(r)eveal in Finder the current node', 'shortcut': 'r', 'callback': 'NERDTreeRevealInFinder'})
- call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFile'})
- call NERDTreeAddMenuItem({'text': '(q)uicklook the current node', 'shortcut': 'q', 'callback': 'NERDTreeQuickLook'})
-endif
-
-if g:NERDTreePath.CopyingSupported()
- call NERDTreeAddMenuItem({'text': '(c)copy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'})
-endif
-
-"FUNCTION: s:echo(msg){{{1
-function! s:echo(msg)
- redraw
- echomsg "NERDTree: " . a:msg
-endfunction
-
-"FUNCTION: s:echoWarning(msg){{{1
-function! s:echoWarning(msg)
- echohl warningmsg
- call s:echo(a:msg)
- echohl normal
-endfunction
-
-"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{1
-"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: NERDTreeAddNode(){{{1
-function! NERDTreeAddNode()
- let curDirNode = g:NERDTreeDirNode.GetSelected()
-
- let newNodeName = input("Add a childnode\n".
- \ "==========================================================\n".
- \ "Enter the dir/file name to be created. Dirs end with a '/'\n" .
- \ "", curDirNode.path.str() . g:NERDTreePath.Slash(), "file")
-
- if newNodeName ==# ''
- call s:echo("Node Creation Aborted.")
- return
- endif
-
- try
- let newPath = g:NERDTreePath.Create(newNodeName)
- let parentNode = b:NERDTreeRoot.findNode(newPath.getParent())
-
- let newTreeNode = g:NERDTreeFileNode.New(newPath)
- if parentNode.isOpen || !empty(parentNode.children)
- call parentNode.addChild(newTreeNode, 1)
- call NERDTreeRender()
- call newTreeNode.putCursorHere(1, 0)
- endif
- catch /^NERDTree/
- call s:echoWarning("Node Not Created.")
- endtry
-endfunction
-
-"FUNCTION: NERDTreeMoveNode(){{{1
-function! NERDTreeMoveNode()
- let curNode = g:NERDTreeFileNode.GetSelected()
- let newNodePath = input("Rename the current node\n" .
- \ "==========================================================\n" .
- \ "Enter the new path for the node: \n" .
- \ "", curNode.path.str(), "file")
-
- if newNodePath ==# ''
- call s:echo("Node Renaming Aborted.")
- return
- endif
-
- try
- let bufnum = bufnr(curNode.path.str())
-
- call curNode.rename(newNodePath)
- call NERDTreeRender()
-
- "if the node is open in a buffer, ask the user if they want to
- "close that buffer
- if bufnum != -1
- let prompt = "\nNode renamed.\n\nThe old file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
- call s:promptToDelBuffer(bufnum, prompt)
- endif
-
- call curNode.putCursorHere(1, 0)
-
- redraw
- catch /^NERDTree/
- call s:echoWarning("Node Not Renamed.")
- endtry
-endfunction
-
-" FUNCTION: NERDTreeDeleteNode() {{{1
-function! NERDTreeDeleteNode()
- let currentNode = g:NERDTreeFileNode.GetSelected()
- 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.str() . ": ")
- let confirmed = choice ==# 'yes'
- else
- echo "Delete the current node\n" .
- \ "==========================================================\n".
- \ "Are you sure you wish to delete the node:\n" .
- \ "" . currentNode.path.str() . " (yN):"
- let choice = nr2char(getchar())
- let confirmed = choice ==# 'y'
- endif
-
-
- if confirmed
- try
- call currentNode.delete()
- call NERDTreeRender()
-
- "if the node is open in a buffer, ask the user if they want to
- "close that buffer
- let bufnum = bufnr(currentNode.path.str())
- 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: NERDTreeCopyNode() {{{1
-function! NERDTreeCopyNode()
- let currentNode = g:NERDTreeFileNode.GetSelected()
- let newNodePath = input("Copy the current node\n" .
- \ "==========================================================\n" .
- \ "Enter the new path to copy the node to: \n" .
- \ "", currentNode.path.str(), "file")
-
- if newNodePath != ""
- "strip trailing slash
- let newNodePath = substitute(newNodePath, '\/$', '', '')
-
- let confirmed = 1
- if currentNode.path.copyingWillOverwrite(newNodePath)
- call s:echo("Warning: copying may overwrite files! Continue? (yN)")
- let choice = nr2char(getchar())
- let confirmed = choice ==# 'y'
- endif
-
- if confirmed
- try
- let newNode = currentNode.copy(newNodePath)
- if !empty(newNode)
- call NERDTreeRender()
- call newNode.putCursorHere(0, 0)
- endif
- catch /^NERDTree/
- call s:echoWarning("Could not copy node")
- endtry
- endif
- else
- call s:echo("Copy aborted.")
- endif
- redraw
-endfunction
-
-function! NERDTreeQuickLook()
- let treenode = g:NERDTreeFileNode.GetSelected()
- if treenode != {}
- call system("qlmanage -p 2>/dev/null '" . treenode.path.str() . "'")
- endif
-endfunction
-
-function! NERDTreeRevealInFinder()
- let treenode = g:NERDTreeFileNode.GetSelected()
- if treenode != {}
- let x = system("open -R '" . treenode.path.str() . "'")
- endif
-endfunction
-
-function! NERDTreeExecuteFile()
- let treenode = g:NERDTreeFileNode.GetSelected()
- if treenode != {}
- let x = system("open '" . treenode.path.str() . "'")
- endif
-endfunction
-
-" vim: set sw=4 sts=4 et fdm=marker:
+++ /dev/null
-" ============================================================================
-" File: NERD_tree.vim
-" Description: vim global plugin that provides a nice tree explorer
-" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
-" Last Change: 28 December, 2011
-" License: This program is free software. It comes without any warranty,
-" to the extent permitted by applicable law. You can redistribute
-" it and/or modify it under the terms of the Do What The Fuck You
-" Want To Public License, Version 2, as published by Sam Hocevar.
-" See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-" ============================================================================
-let s:NERD_tree_version = '4.2.0'
-
-" 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
-
-"for line continuation - i.e dont want C in &cpo
-let s:old_cpo = &cpo
-set cpo&vim
-
-let s:running_windows = has("win16") || has("win32") || has("win64")
-
-"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 . ' = ' . "'" . substitute(a:value, "'", "''", "g") . "'"
- 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", 0)
-call s:initVariable("g:NERDTreeMinimalUI", 0)
-if !exists("g:NERDTreeIgnore")
- let g:NERDTreeIgnore = ['\~$']
-endif
-call s:initVariable("g:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks')
-call s:initVariable("g:NERDTreeHighlightCursorline", 1)
-call s:initVariable("g:NERDTreeHijackNetrw", 1)
-call s:initVariable("g:NERDTreeMouseMode", 1)
-call s:initVariable("g:NERDTreeNotificationThreshold", 100)
-call s:initVariable("g:NERDTreeQuitOnOpen", 0)
-call s:initVariable("g:NERDTreeShowBookmarks", 0)
-call s:initVariable("g:NERDTreeShowFiles", 1)
-call s:initVariable("g:NERDTreeShowHidden", 0)
-call s:initVariable("g:NERDTreeShowLineNumbers", 0)
-call s:initVariable("g:NERDTreeSortDirs", 1)
-call s:initVariable("g:NERDTreeDirArrows", !s:running_windows)
-
-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 s:NERDTreeSortStarIndex = index(g:NERDTreeSortOrder, '*')
-
-if !exists('g:NERDTreeStatusline')
-
- "the exists() crap here is a hack to stop vim spazzing out when
- "loading a session that was created with an open nerd tree. It spazzes
- "because it doesnt store b:NERDTreeRoot (its a b: var, and its a hash)
- let g:NERDTreeStatusline = "%{exists('b:NERDTreeRoot')?b:NERDTreeRoot.path.str():''}"
-
-endif
-call s:initVariable("g:NERDTreeWinPos", "left")
-call s:initVariable("g:NERDTreeWinSize", 31)
-
-"init the shell commands that will be used to copy nodes, and 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 ')
- call s:initVariable("g:NERDTreeCopyCmd", 'cp -r ')
-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:NERDTreeMapDeleteBookmark", "D")
-call s:initVariable("g:NERDTreeMapMenu", "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", "i")
-call s:initVariable("g:NERDTreeMapOpenVSplit", "s")
-call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
-call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
-call s:initVariable("g:NERDTreeMapPreviewVSplit", "g" . NERDTreeMapOpenVSplit)
-call s:initVariable("g:NERDTreeMapQuit", "q")
-call s:initVariable("g:NERDTreeMapRefresh", "r")
-call s:initVariable("g:NERDTreeMapRefreshRoot", "R")
-call s:initVariable("g:NERDTreeMapToggleBookmarks", "B")
-call s:initVariable("g:NERDTreeMapToggleFiles", "F")
-call s:initVariable("g:NERDTreeMapToggleFilters", "f")
-call s:initVariable("g:NERDTreeMapToggleHidden", "I")
-call s:initVariable("g:NERDTreeMapToggleZoom", "A")
-call s:initVariable("g:NERDTreeMapUpdir", "u")
-call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U")
-
-"SECTION: Script level variable declaration{{{2
-if s:running_windows
- let s:escape_chars = " `\|\"#%&,?()\*^<>"
-else
- let s:escape_chars = " \\`\|\"#%&,?()\*^<>[]"
-endif
-let s:NERDTreeBufName = 'NERD_tree_'
-
-let s:tree_wid = 2
-let s:tree_markup_reg = '^[ `|]*[\-+~▾▸ ]\+'
-let s:tree_up_dir_line = '.. (up a dir)'
-
-"the number to add to the nerd tree buffer name to make the buf name unique
-let s:next_buffer_number = 1
-
-" SECTION: Commands {{{1
-"============================================================
-"init the command that users start the nerd tree with
-command! -n=? -complete=dir -bar NERDTree :call s:initNerdTree('<args>')
-command! -n=? -complete=dir -bar NERDTreeToggle :call s:toggle('<args>')
-command! -n=0 -bar NERDTreeClose :call s:closeTreeIfOpen()
-command! -n=1 -complete=customlist,s:completeBookmarks -bar NERDTreeFromBookmark call s:initNerdTree('<args>')
-command! -n=0 -bar NERDTreeMirror call s:initNerdTreeMirror()
-command! -n=0 -bar NERDTreeFind call s:findAndRevealPath()
-" SECTION: Auto commands {{{1
-"============================================================
-augroup NERDTree
- "Save the cursor position whenever we close the nerd tree
- exec "autocmd BufWinLeave ". s:NERDTreeBufName ."* call <SID>saveScreenState()"
-
- "disallow insert mode in the NERDTree
- exec "autocmd BufEnter ". s:NERDTreeBufName ."* stopinsert"
-
- "cache bookmarks when vim loads
- autocmd VimEnter * call s:Bookmark.CacheBookmarks(0)
-
- "load all nerdtree plugins after vim starts
- autocmd VimEnter * runtime! nerdtree_plugin/**/*.vim
-augroup END
-
-if g:NERDTreeHijackNetrw
- augroup NERDTreeHijackNetrw
- autocmd VimEnter * silent! autocmd! FileExplorer
- au BufEnter,VimEnter * call s:checkForBrowse(expand("<amatch>"))
- augroup END
-endif
-
-"SECTION: Classes {{{1
-"============================================================
-"CLASS: Bookmark {{{2
-"============================================================
-let s:Bookmark = {}
-" FUNCTION: Bookmark.activate() {{{3
-function! s:Bookmark.activate()
- if self.path.isDirectory
- call self.toRoot()
- else
- if self.validate()
- let n = s:TreeFileNode.New(self.path)
- call n.open()
- call s:closeTreeIfQuitOnOpen()
- endif
- endif
-endfunction
-" FUNCTION: Bookmark.AddBookmark(name, path) {{{3
-" Class method to add a new bookmark to the list, if a previous bookmark exists
-" with the same name, just update the path for that bookmark
-function! s:Bookmark.AddBookmark(name, path)
- for i in s:Bookmark.Bookmarks()
- if i.name ==# a:name
- let i.path = a:path
- return
- endif
- endfor
- call add(s:Bookmark.Bookmarks(), s:Bookmark.New(a:name, a:path))
- call s:Bookmark.Sort()
-endfunction
-" Function: Bookmark.Bookmarks() {{{3
-" Class method to get all bookmarks. Lazily initializes the bookmarks global
-" variable
-function! s:Bookmark.Bookmarks()
- if !exists("g:NERDTreeBookmarks")
- let g:NERDTreeBookmarks = []
- endif
- return g:NERDTreeBookmarks
-endfunction
-" Function: Bookmark.BookmarkExistsFor(name) {{{3
-" class method that returns 1 if a bookmark with the given name is found, 0
-" otherwise
-function! s:Bookmark.BookmarkExistsFor(name)
- try
- call s:Bookmark.BookmarkFor(a:name)
- return 1
- catch /^NERDTree.BookmarkNotFoundError/
- return 0
- endtry
-endfunction
-" Function: Bookmark.BookmarkFor(name) {{{3
-" Class method to get the bookmark that has the given name. {} is return if no
-" bookmark is found
-function! s:Bookmark.BookmarkFor(name)
- for i in s:Bookmark.Bookmarks()
- if i.name ==# a:name
- return i
- endif
- endfor
- throw "NERDTree.BookmarkNotFoundError: no bookmark found for name: \"". a:name .'"'
-endfunction
-" Function: Bookmark.BookmarkNames() {{{3
-" Class method to return an array of all bookmark names
-function! s:Bookmark.BookmarkNames()
- let names = []
- for i in s:Bookmark.Bookmarks()
- call add(names, i.name)
- endfor
- return names
-endfunction
-" FUNCTION: Bookmark.CacheBookmarks(silent) {{{3
-" Class method to read all bookmarks from the bookmarks file intialize
-" bookmark objects for each one.
-"
-" Args:
-" silent - dont echo an error msg if invalid bookmarks are found
-function! s:Bookmark.CacheBookmarks(silent)
- if filereadable(g:NERDTreeBookmarksFile)
- let g:NERDTreeBookmarks = []
- let g:NERDTreeInvalidBookmarks = []
- let bookmarkStrings = readfile(g:NERDTreeBookmarksFile)
- let invalidBookmarksFound = 0
- for i in bookmarkStrings
-
- "ignore blank lines
- if i != ''
-
- let name = substitute(i, '^\(.\{-}\) .*$', '\1', '')
- let path = substitute(i, '^.\{-} \(.*\)$', '\1', '')
-
- try
- let bookmark = s:Bookmark.New(name, s:Path.New(path))
- call add(g:NERDTreeBookmarks, bookmark)
- catch /^NERDTree.InvalidArgumentsError/
- call add(g:NERDTreeInvalidBookmarks, i)
- let invalidBookmarksFound += 1
- endtry
- endif
- endfor
- if invalidBookmarksFound
- call s:Bookmark.Write()
- if !a:silent
- call s:echo(invalidBookmarksFound . " invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.")
- endif
- endif
- call s:Bookmark.Sort()
- endif
-endfunction
-" FUNCTION: Bookmark.compareTo(otherbookmark) {{{3
-" Compare these two bookmarks for sorting purposes
-function! s:Bookmark.compareTo(otherbookmark)
- return a:otherbookmark.name < self.name
-endfunction
-" FUNCTION: Bookmark.ClearAll() {{{3
-" Class method to delete all bookmarks.
-function! s:Bookmark.ClearAll()
- for i in s:Bookmark.Bookmarks()
- call i.delete()
- endfor
- call s:Bookmark.Write()
-endfunction
-" FUNCTION: Bookmark.delete() {{{3
-" Delete this bookmark. If the node for this bookmark is under the current
-" root, then recache bookmarks for its Path object
-function! s:Bookmark.delete()
- let node = {}
- try
- let node = self.getNode(1)
- catch /^NERDTree.BookmarkedNodeNotFoundError/
- endtry
- call remove(s:Bookmark.Bookmarks(), index(s:Bookmark.Bookmarks(), self))
- if !empty(node)
- call node.path.cacheDisplayString()
- endif
- call s:Bookmark.Write()
-endfunction
-" FUNCTION: Bookmark.getNode(searchFromAbsoluteRoot) {{{3
-" Gets the treenode for this bookmark
-"
-" Args:
-" searchFromAbsoluteRoot: specifies whether we should search from the current
-" tree root, or the highest cached node
-function! s:Bookmark.getNode(searchFromAbsoluteRoot)
- let searchRoot = a:searchFromAbsoluteRoot ? s:TreeDirNode.AbsoluteTreeRoot() : b:NERDTreeRoot
- let targetNode = searchRoot.findNode(self.path)
- if empty(targetNode)
- throw "NERDTree.BookmarkedNodeNotFoundError: no node was found for bookmark: " . self.name
- endif
- return targetNode
-endfunction
-" FUNCTION: Bookmark.GetNodeForName(name, searchFromAbsoluteRoot) {{{3
-" Class method that finds the bookmark with the given name and returns the
-" treenode for it.
-function! s:Bookmark.GetNodeForName(name, searchFromAbsoluteRoot)
- let bookmark = s:Bookmark.BookmarkFor(a:name)
- return bookmark.getNode(a:searchFromAbsoluteRoot)
-endfunction
-" FUNCTION: Bookmark.GetSelected() {{{3
-" returns the Bookmark the cursor is over, or {}
-function! s:Bookmark.GetSelected()
- let line = getline(".")
- let name = substitute(line, '^>\(.\{-}\) .\+$', '\1', '')
- if name != line
- try
- return s:Bookmark.BookmarkFor(name)
- catch /^NERDTree.BookmarkNotFoundError/
- return {}
- endtry
- endif
- return {}
-endfunction
-
-" Function: Bookmark.InvalidBookmarks() {{{3
-" Class method to get all invalid bookmark strings read from the bookmarks
-" file
-function! s:Bookmark.InvalidBookmarks()
- if !exists("g:NERDTreeInvalidBookmarks")
- let g:NERDTreeInvalidBookmarks = []
- endif
- return g:NERDTreeInvalidBookmarks
-endfunction
-" FUNCTION: Bookmark.mustExist() {{{3
-function! s:Bookmark.mustExist()
- if !self.path.exists()
- call s:Bookmark.CacheBookmarks(1)
- throw "NERDTree.BookmarkPointsToInvalidLocationError: the bookmark \"".
- \ self.name ."\" points to a non existing location: \"". self.path.str()
- endif
-endfunction
-" FUNCTION: Bookmark.New(name, path) {{{3
-" Create a new bookmark object with the given name and path object
-function! s:Bookmark.New(name, path)
- if a:name =~# ' '
- throw "NERDTree.IllegalBookmarkNameError: illegal name:" . a:name
- endif
-
- let newBookmark = copy(self)
- let newBookmark.name = a:name
- let newBookmark.path = a:path
- return newBookmark
-endfunction
-" FUNCTION: Bookmark.openInNewTab(options) {{{3
-" Create a new bookmark object with the given name and path object
-function! s:Bookmark.openInNewTab(options)
- let currentTab = tabpagenr()
- if self.path.isDirectory
- tabnew
- call s:initNerdTree(self.name)
- else
- exec "tabedit " . self.path.str({'format': 'Edit'})
- endif
-
- if has_key(a:options, 'stayInCurrentTab')
- exec "tabnext " . currentTab
- endif
-endfunction
-" Function: Bookmark.setPath(path) {{{3
-" makes this bookmark point to the given path
-function! s:Bookmark.setPath(path)
- let self.path = a:path
-endfunction
-" Function: Bookmark.Sort() {{{3
-" Class method that sorts all bookmarks
-function! s:Bookmark.Sort()
- let CompareFunc = function("s:compareBookmarks")
- call sort(s:Bookmark.Bookmarks(), CompareFunc)
-endfunction
-" Function: Bookmark.str() {{{3
-" Get the string that should be rendered in the view for this bookmark
-function! s:Bookmark.str()
- let pathStrMaxLen = winwidth(s:getTreeWinNum()) - 4 - len(self.name)
- if &nu
- let pathStrMaxLen = pathStrMaxLen - &numberwidth
- endif
-
- let pathStr = self.path.str({'format': 'UI'})
- if len(pathStr) > pathStrMaxLen
- let pathStr = '<' . strpart(pathStr, len(pathStr) - pathStrMaxLen)
- endif
- return '>' . self.name . ' ' . pathStr
-endfunction
-" FUNCTION: Bookmark.toRoot() {{{3
-" Make the node for this bookmark the new tree root
-function! s:Bookmark.toRoot()
- if self.validate()
- try
- let targetNode = self.getNode(1)
- catch /^NERDTree.BookmarkedNodeNotFoundError/
- let targetNode = s:TreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path)
- endtry
- call targetNode.makeRoot()
- call s:renderView()
- call targetNode.putCursorHere(0, 0)
- endif
-endfunction
-" FUNCTION: Bookmark.ToRoot(name) {{{3
-" Make the node for this bookmark the new tree root
-function! s:Bookmark.ToRoot(name)
- let bookmark = s:Bookmark.BookmarkFor(a:name)
- call bookmark.toRoot()
-endfunction
-
-
-"FUNCTION: Bookmark.validate() {{{3
-function! s:Bookmark.validate()
- if self.path.exists()
- return 1
- else
- call s:Bookmark.CacheBookmarks(1)
- call s:renderView()
- call s:echo(self.name . "now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.")
- return 0
- endif
-endfunction
-
-" Function: Bookmark.Write() {{{3
-" Class method to write all bookmarks to the bookmarks file
-function! s:Bookmark.Write()
- let bookmarkStrings = []
- for i in s:Bookmark.Bookmarks()
- call add(bookmarkStrings, i.name . ' ' . i.path.str())
- endfor
-
- "add a blank line before the invalid ones
- call add(bookmarkStrings, "")
-
- for j in s:Bookmark.InvalidBookmarks()
- call add(bookmarkStrings, j)
- endfor
- call writefile(bookmarkStrings, g:NERDTreeBookmarksFile)
-endfunction
-"CLASS: KeyMap {{{2
-"============================================================
-let s:KeyMap = {}
-"FUNCTION: KeyMap.All() {{{3
-function! s:KeyMap.All()
- if !exists("s:keyMaps")
- let s:keyMaps = []
- endif
- return s:keyMaps
-endfunction
-
-"FUNCTION: KeyMap.BindAll() {{{3
-function! s:KeyMap.BindAll()
- for i in s:KeyMap.All()
- call i.bind()
- endfor
-endfunction
-
-"FUNCTION: KeyMap.bind() {{{3
-function! s:KeyMap.bind()
- exec "nnoremap <silent> <buffer> ". self.key ." :call ". self.callback ."()<cr>"
-endfunction
-
-"FUNCTION: KeyMap.Create(options) {{{3
-function! s:KeyMap.Create(options)
- let newKeyMap = copy(self)
- let newKeyMap.key = a:options['key']
- let newKeyMap.quickhelpText = a:options['quickhelpText']
- let newKeyMap.callback = a:options['callback']
- call add(s:KeyMap.All(), newKeyMap)
-endfunction
-"CLASS: MenuController {{{2
-"============================================================
-let s:MenuController = {}
-"FUNCTION: MenuController.New(menuItems) {{{3
-"create a new menu controller that operates on the given menu items
-function! s:MenuController.New(menuItems)
- let newMenuController = copy(self)
- if a:menuItems[0].isSeparator()
- let newMenuController.menuItems = a:menuItems[1:-1]
- else
- let newMenuController.menuItems = a:menuItems
- endif
- return newMenuController
-endfunction
-
-"FUNCTION: MenuController.showMenu() {{{3
-"start the main loop of the menu and get the user to choose/execute a menu
-"item
-function! s:MenuController.showMenu()
- call self._saveOptions()
-
- try
- let self.selection = 0
-
- let done = 0
- while !done
- redraw!
- call self._echoPrompt()
- let key = nr2char(getchar())
- let done = self._handleKeypress(key)
- endwhile
- finally
- call self._restoreOptions()
- endtry
-
- if self.selection != -1
- let m = self._current()
- call m.execute()
- endif
-endfunction
-
-"FUNCTION: MenuController._echoPrompt() {{{3
-function! s:MenuController._echoPrompt()
- echo "NERDTree Menu. Use j/k/enter and the shortcuts indicated"
- echo "=========================================================="
-
- for i in range(0, len(self.menuItems)-1)
- if self.selection == i
- echo "> " . self.menuItems[i].text
- else
- echo " " . self.menuItems[i].text
- endif
- endfor
-endfunction
-
-"FUNCTION: MenuController._current(key) {{{3
-"get the MenuItem that is currently selected
-function! s:MenuController._current()
- return self.menuItems[self.selection]
-endfunction
-
-"FUNCTION: MenuController._handleKeypress(key) {{{3
-"change the selection (if appropriate) and return 1 if the user has made
-"their choice, 0 otherwise
-function! s:MenuController._handleKeypress(key)
- if a:key == 'j'
- call self._cursorDown()
- elseif a:key == 'k'
- call self._cursorUp()
- elseif a:key == nr2char(27) "escape
- let self.selection = -1
- return 1
- elseif a:key == "\r" || a:key == "\n" "enter and ctrl-j
- return 1
- else
- let index = self._nextIndexFor(a:key)
- if index != -1
- let self.selection = index
- if len(self._allIndexesFor(a:key)) == 1
- return 1
- endif
- endif
- endif
-
- return 0
-endfunction
-
-"FUNCTION: MenuController._allIndexesFor(shortcut) {{{3
-"get indexes to all menu items with the given shortcut
-function! s:MenuController._allIndexesFor(shortcut)
- let toReturn = []
-
- for i in range(0, len(self.menuItems)-1)
- if self.menuItems[i].shortcut == a:shortcut
- call add(toReturn, i)
- endif
- endfor
-
- return toReturn
-endfunction
-
-"FUNCTION: MenuController._nextIndexFor(shortcut) {{{3
-"get the index to the next menu item with the given shortcut, starts from the
-"current cursor location and wraps around to the top again if need be
-function! s:MenuController._nextIndexFor(shortcut)
- for i in range(self.selection+1, len(self.menuItems)-1)
- if self.menuItems[i].shortcut == a:shortcut
- return i
- endif
- endfor
-
- for i in range(0, self.selection)
- if self.menuItems[i].shortcut == a:shortcut
- return i
- endif
- endfor
-
- return -1
-endfunction
-
-"FUNCTION: MenuController._setCmdheight() {{{3
-"sets &cmdheight to whatever is needed to display the menu
-function! s:MenuController._setCmdheight()
- let &cmdheight = len(self.menuItems) + 3
-endfunction
-
-"FUNCTION: MenuController._saveOptions() {{{3
-"set any vim options that are required to make the menu work (saving their old
-"values)
-function! s:MenuController._saveOptions()
- let self._oldLazyredraw = &lazyredraw
- let self._oldCmdheight = &cmdheight
- set nolazyredraw
- call self._setCmdheight()
-endfunction
-
-"FUNCTION: MenuController._restoreOptions() {{{3
-"restore the options we saved in _saveOptions()
-function! s:MenuController._restoreOptions()
- let &cmdheight = self._oldCmdheight
- let &lazyredraw = self._oldLazyredraw
-endfunction
-
-"FUNCTION: MenuController._cursorDown() {{{3
-"move the cursor to the next menu item, skipping separators
-function! s:MenuController._cursorDown()
- let done = 0
- while !done
- if self.selection < len(self.menuItems)-1
- let self.selection += 1
- else
- let self.selection = 0
- endif
-
- if !self._current().isSeparator()
- let done = 1
- endif
- endwhile
-endfunction
-
-"FUNCTION: MenuController._cursorUp() {{{3
-"move the cursor to the previous menu item, skipping separators
-function! s:MenuController._cursorUp()
- let done = 0
- while !done
- if self.selection > 0
- let self.selection -= 1
- else
- let self.selection = len(self.menuItems)-1
- endif
-
- if !self._current().isSeparator()
- let done = 1
- endif
- endwhile
-endfunction
-
-"CLASS: MenuItem {{{2
-"============================================================
-let s:MenuItem = {}
-"FUNCTION: MenuItem.All() {{{3
-"get all top level menu items
-function! s:MenuItem.All()
- if !exists("s:menuItems")
- let s:menuItems = []
- endif
- return s:menuItems
-endfunction
-
-"FUNCTION: MenuItem.AllEnabled() {{{3
-"get all top level menu items that are currently enabled
-function! s:MenuItem.AllEnabled()
- let toReturn = []
- for i in s:MenuItem.All()
- if i.enabled()
- call add(toReturn, i)
- endif
- endfor
- return toReturn
-endfunction
-
-"FUNCTION: MenuItem.Create(options) {{{3
-"make a new menu item and add it to the global list
-function! s:MenuItem.Create(options)
- let newMenuItem = copy(self)
-
- let newMenuItem.text = a:options['text']
- let newMenuItem.shortcut = a:options['shortcut']
- let newMenuItem.children = []
-
- let newMenuItem.isActiveCallback = -1
- if has_key(a:options, 'isActiveCallback')
- let newMenuItem.isActiveCallback = a:options['isActiveCallback']
- endif
-
- let newMenuItem.callback = -1
- if has_key(a:options, 'callback')
- let newMenuItem.callback = a:options['callback']
- endif
-
- if has_key(a:options, 'parent')
- call add(a:options['parent'].children, newMenuItem)
- else
- call add(s:MenuItem.All(), newMenuItem)
- endif
-
- return newMenuItem
-endfunction
-
-"FUNCTION: MenuItem.CreateSeparator(options) {{{3
-"make a new separator menu item and add it to the global list
-function! s:MenuItem.CreateSeparator(options)
- let standard_options = { 'text': '--------------------',
- \ 'shortcut': -1,
- \ 'callback': -1 }
- let options = extend(a:options, standard_options, "force")
-
- return s:MenuItem.Create(options)
-endfunction
-
-"FUNCTION: MenuItem.CreateSubmenu(options) {{{3
-"make a new submenu and add it to global list
-function! s:MenuItem.CreateSubmenu(options)
- let standard_options = { 'callback': -1 }
- let options = extend(a:options, standard_options, "force")
-
- return s:MenuItem.Create(options)
-endfunction
-
-"FUNCTION: MenuItem.enabled() {{{3
-"return 1 if this menu item should be displayed
-"
-"delegates off to the isActiveCallback, and defaults to 1 if no callback was
-"specified
-function! s:MenuItem.enabled()
- if self.isActiveCallback != -1
- return {self.isActiveCallback}()
- endif
- return 1
-endfunction
-
-"FUNCTION: MenuItem.execute() {{{3
-"perform the action behind this menu item, if this menuitem has children then
-"display a new menu for them, otherwise deletegate off to the menuitem's
-"callback
-function! s:MenuItem.execute()
- if len(self.children)
- let mc = s:MenuController.New(self.children)
- call mc.showMenu()
- else
- if self.callback != -1
- call {self.callback}()
- endif
- endif
-endfunction
-
-"FUNCTION: MenuItem.isSeparator() {{{3
-"return 1 if this menuitem is a separator
-function! s:MenuItem.isSeparator()
- return self.callback == -1 && self.children == []
-endfunction
-
-"FUNCTION: MenuItem.isSubmenu() {{{3
-"return 1 if this menuitem is a submenu
-function! s:MenuItem.isSubmenu()
- return self.callback == -1 && !empty(self.children)
-endfunction
-
-"CLASS: TreeFileNode {{{2
-"This class is the parent of the TreeDirNode class and constitures the
-"'Component' part of the composite design pattern between the treenode
-"classes.
-"============================================================
-let s:TreeFileNode = {}
-"FUNCTION: TreeFileNode.activate(forceKeepWinOpen) {{{3
-function! s:TreeFileNode.activate(forceKeepWinOpen)
- call self.open()
- if !a:forceKeepWinOpen
- call s:closeTreeIfQuitOnOpen()
- end
-endfunction
-"FUNCTION: TreeFileNode.bookmark(name) {{{3
-"bookmark this node with a:name
-function! s:TreeFileNode.bookmark(name)
-
- "if a bookmark exists with the same name and the node is cached then save
- "it so we can update its display string
- let oldMarkedNode = {}
- try
- let oldMarkedNode = s:Bookmark.GetNodeForName(a:name, 1)
- catch /^NERDTree.BookmarkNotFoundError/
- catch /^NERDTree.BookmarkedNodeNotFoundError/
- endtry
-
- call s:Bookmark.AddBookmark(a:name, self.path)
- call self.path.cacheDisplayString()
- call s:Bookmark.Write()
-
- if !empty(oldMarkedNode)
- call oldMarkedNode.path.cacheDisplayString()
- endif
-endfunction
-"FUNCTION: TreeFileNode.cacheParent() {{{3
-"initializes self.parent if it isnt already
-function! s:TreeFileNode.cacheParent()
- if empty(self.parent)
- let parentPath = self.path.getParent()
- if parentPath.equals(self.path)
- throw "NERDTree.CannotCacheParentError: already at root"
- endif
- let self.parent = s:TreeFileNode.New(parentPath)
- endif
-endfunction
-"FUNCTION: TreeFileNode.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: TreeFileNode.clearBoomarks() {{{3
-function! s:TreeFileNode.clearBoomarks()
- for i in s:Bookmark.Bookmarks()
- if i.path.equals(self.path)
- call i.delete()
- end
- endfor
- call self.path.cacheDisplayString()
-endfunction
-"FUNCTION: TreeFileNode.copy(dest) {{{3
-function! s:TreeFileNode.copy(dest)
- call self.path.copy(a:dest)
- let newPath = s:Path.New(a:dest)
- let parent = b:NERDTreeRoot.findNode(newPath.getParent())
- if !empty(parent)
- call parent.refresh()
- return parent.findNode(newPath)
- else
- return {}
- endif
-endfunction
-
-"FUNCTION: TreeFileNode.delete {{{3
-"Removes this node from the tree and calls the Delete method for its path obj
-function! s:TreeFileNode.delete()
- call self.path.delete()
- call self.parent.removeChild(self)
-endfunction
-
-"FUNCTION: TreeFileNode.displayString() {{{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:TreeFileNode.displayString()
- return self.path.displayString()
-endfunction
-
-"FUNCTION: TreeFileNode.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:TreeFileNode.equals(treenode)
- return self.path.str() ==# a:treenode.path.str()
-endfunction
-
-"FUNCTION: TreeFileNode.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:TreeFileNode.findNode(path)
- if a:path.equals(self.path)
- return self
- endif
- return {}
-endfunction
-"FUNCTION: TreeFileNode.findOpenDirSiblingWithVisibleChildren(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:TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction)
- "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: TreeFileNode.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:TreeFileNode.findSibling(direction)
- "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: TreeFileNode.getLineNum(){{{3
-"returns the line number this node is rendered on, or -1 if it isnt rendered
-function! s:TreeFileNode.getLineNum()
- "if the node is the root then return the root line no.
- if self.isRoot()
- return s:TreeFileNode.GetRootLineNum()
- endif
-
- let totalLines = line("$")
-
- "the path components we have matched so far
- let pathcomponents = [substitute(b:NERDTreeRoot.path.str({'format': 'UI'}), '/ *$', '', '')]
- "the index of the component we are searching for
- let curPathComponent = 1
-
- let fullpath = self.path.str({'format': 'UI'})
-
-
- let lnum = s:TreeFileNode.GetRootLineNum()
- 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 = s:indentLevelFor(curLine)
- 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: TreeFileNode.GetRootForTab(){{{3
-"get the root node for this tab
-function! s:TreeFileNode.GetRootForTab()
- if s:treeExistsForTab()
- return getbufvar(t:NERDTreeBufName, 'NERDTreeRoot')
- end
- return {}
-endfunction
-"FUNCTION: TreeFileNode.GetRootLineNum(){{{3
-"gets the line number of the root node
-function! s:TreeFileNode.GetRootLineNum()
- let rootLine = 1
- while getline(rootLine) !~# '^\(/\|<\)'
- let rootLine = rootLine + 1
- endwhile
- return rootLine
-endfunction
-
-"FUNCTION: TreeFileNode.GetSelected() {{{3
-"gets the treenode that the cursor is currently over
-function! s:TreeFileNode.GetSelected()
- try
- let path = s:getPath(line("."))
- if path ==# {}
- return {}
- endif
- return b:NERDTreeRoot.findNode(path)
- catch /NERDTree/
- return {}
- endtry
-endfunction
-"FUNCTION: TreeFileNode.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:TreeFileNode.isVisible()
- return !self.path.ignore()
-endfunction
-"FUNCTION: TreeFileNode.isRoot() {{{3
-"returns 1 if this node is b:NERDTreeRoot
-function! s:TreeFileNode.isRoot()
- if !s:treeExistsForBuf()
- throw "NERDTree.NoTreeError: No tree exists for the current buffer"
- endif
-
- return self.equals(b:NERDTreeRoot)
-endfunction
-
-"FUNCTION: TreeFileNode.makeRoot() {{{3
-"Make this node the root of the tree
-function! s:TreeFileNode.makeRoot()
- if self.path.isDirectory
- let b:NERDTreeRoot = self
- else
- call self.cacheParent()
- let b:NERDTreeRoot = self.parent
- endif
-
- call b:NERDTreeRoot.open()
-
- "change dir to the dir of the new root if instructed to
- if g:NERDTreeChDirMode ==# 2
- exec "cd " . b:NERDTreeRoot.path.str({'format': 'Edit'})
- endif
-endfunction
-"FUNCTION: TreeFileNode.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:TreeFileNode.New(path)
- if a:path.isDirectory
- return s:TreeDirNode.New(a:path)
- else
- let newTreeNode = copy(self)
- let newTreeNode.path = a:path
- let newTreeNode.parent = {}
- return newTreeNode
- endif
-endfunction
-
-"FUNCTION: TreeFileNode.open() {{{3
-"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:TreeFileNode.open()
- if b:NERDTreeType ==# "secondary"
- exec 'edit ' . self.path.str({'format': 'Edit'})
- return
- endif
-
- "if the file is already open in this tab then just stick the cursor in it
- let winnr = bufwinnr('^' . self.path.str() . '$')
- if winnr != -1
- call s:exec(winnr . "wincmd w")
-
- else
- if !s:isWindowUsable(winnr("#")) && s:firstUsableWindow() ==# -1
- call self.openSplit()
- else
- try
- if !s:isWindowUsable(winnr("#"))
- call s:exec(s:firstUsableWindow() . "wincmd w")
- else
- call s:exec('wincmd p')
- endif
- exec ("edit " . self.path.str({'format': 'Edit'}))
- catch /^Vim\%((\a\+)\)\=:E37/
- call s:putCursorInTreeWin()
- throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self.path.str() ." is already open and modified."
- catch /^Vim\%((\a\+)\)\=:/
- echo v:exception
- endtry
- endif
- endif
-endfunction
-"FUNCTION: TreeFileNode.openSplit() {{{3
-"Open this node in a new window
-function! s:TreeFileNode.openSplit()
-
- if b:NERDTreeType ==# "secondary"
- exec "split " . self.path.str({'format': 'Edit'})
- return
- endif
-
- " Save the user's settings for splitbelow and splitright
- let savesplitbelow=&splitbelow
- let savesplitright=&splitright
-
- " '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.
- "
- let there= g:NERDTreeWinPos ==# "left" ? "wincmd h" : "wincmd l"
- let back = g:NERDTreeWinPos ==# "left" ? "wincmd l" : "wincmd h"
- let right= g:NERDTreeWinPos ==# "left"
- let below=0
-
- " Attempt to go to adjacent window
- call s:exec(back)
-
- let onlyOneWin = (winnr("$") ==# 1)
-
- " 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
-
- let splitMode = onlyOneWin ? "vertical" : ""
-
- " Open the new window
- try
- exec(splitMode." sp " . self.path.str({'format': 'Edit'}))
- catch /^Vim\%((\a\+)\)\=:E37/
- call s:putCursorInTreeWin()
- throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self.path.str() ." is already open and modified."
- catch /^Vim\%((\a\+)\)\=:/
- "do nothing
- endtry
-
- "resize the tree window if no other window was open before
- if onlyOneWin
- let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
- call s:exec(there)
- exec("silent ". splitMode ." resize ". size)
- call s:exec('wincmd p')
- endif
-
- " Restore splitmode settings
- let &splitbelow=savesplitbelow
- let &splitright=savesplitright
-endfunction
-"FUNCTION: TreeFileNode.openVSplit() {{{3
-"Open this node in a new vertical window
-function! s:TreeFileNode.openVSplit()
- if b:NERDTreeType ==# "secondary"
- exec "vnew " . self.path.str({'format': 'Edit'})
- return
- endif
-
- let winwidth = winwidth(".")
- if winnr("$")==#1
- let winwidth = g:NERDTreeWinSize
- endif
-
- call s:exec("wincmd p")
- exec "vnew " . self.path.str({'format': 'Edit'})
-
- "resize the nerd tree back to the original size
- call s:putCursorInTreeWin()
- exec("silent vertical resize ". winwidth)
- call s:exec('wincmd p')
-endfunction
-"FUNCTION: TreeFileNode.openInNewTab(options) {{{3
-function! s:TreeFileNode.openInNewTab(options)
- let currentTab = tabpagenr()
-
- if !has_key(a:options, 'keepTreeOpen')
- call s:closeTreeIfQuitOnOpen()
- endif
-
- exec "tabedit " . self.path.str({'format': 'Edit'})
-
- if has_key(a:options, 'stayInCurrentTab') && a:options['stayInCurrentTab']
- exec "tabnext " . currentTab
- endif
-
-endfunction
-"FUNCTION: TreeFileNode.putCursorHere(isJump, recurseUpward){{{3
-"Places the cursor on the line number this node is rendered on
-"
-"Args:
-"isJump: 1 if this cursor movement should be counted as a jump by vim
-"recurseUpward: try to put the cursor on the parent if the this node isnt
-"visible
-function! s:TreeFileNode.putCursorHere(isJump, recurseUpward)
- let ln = self.getLineNum()
- if ln != -1
- if a:isJump
- mark '
- endif
- call cursor(ln, col("."))
- else
- if a:recurseUpward
- let node = self
- while node != {} && node.getLineNum() ==# -1
- let node = node.parent
- call node.open()
- endwhile
- call s:renderView()
- call node.putCursorHere(a:isJump, 0)
- endif
- endif
-endfunction
-
-"FUNCTION: TreeFileNode.refresh() {{{3
-function! s:TreeFileNode.refresh()
- call self.path.refresh()
-endfunction
-"FUNCTION: TreeFileNode.rename() {{{3
-"Calls the rename method for this nodes path obj
-function! s:TreeFileNode.rename(newName)
- let newName = substitute(a:newName, '\(\\\|\/\)$', '', '')
- call self.path.rename(newName)
- call self.parent.removeChild(self)
-
- let parentPath = self.path.getParent()
- let newParent = b:NERDTreeRoot.findNode(parentPath)
-
- if newParent != {}
- call newParent.createChild(self.path, 1)
- call newParent.refresh()
- endif
-endfunction
-"FUNCTION: TreeFileNode.renderToString {{{3
-"returns a string representation for this tree to be rendered in the view
-function! s:TreeFileNode.renderToString()
- return self._renderToString(0, 0, [], self.getChildCount() ==# 1)
-endfunction
-
-
-"Args:
-"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:TreeFileNode._renderToString(depth, drawText, vertMap, isLastChild)
- let output = ""
- 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 g:NERDTreeDirArrows
- let treeParts = treeParts . ' '
- else
- if j ==# 1
- let treeParts = treeParts . '| '
- else
- let treeParts = treeParts . ' '
- endif
- 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 !g:NERDTreeDirArrows
- if a:isLastChild
- let treeParts = treeParts . '`'
- else
- let treeParts = treeParts . '|'
- endif
- endif
-
- "smack the appropriate dir/file symbol on the line before the file/dir
- "name itself
- if self.path.isDirectory
- if self.isOpen
- if g:NERDTreeDirArrows
- let treeParts = treeParts . '▾ '
- else
- let treeParts = treeParts . '~'
- endif
- else
- if g:NERDTreeDirArrows
- let treeParts = treeParts . '▸ '
- else
- let treeParts = treeParts . '+'
- endif
- endif
- else
- if g:NERDTreeDirArrows
- let treeParts = treeParts . ' '
- else
- let treeParts = treeParts . '-'
- endif
- endif
- let line = treeParts . self.displayString()
-
- let output = output . line . "\n"
- endif
-
- "if the node is an open dir, draw its children
- if self.path.isDirectory ==# 1 && self.isOpen ==# 1
-
- let childNodesToDraw = self.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]
- let output = output . i._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 1), 0)
- endfor
- endif
-
- "draw the last child, indicating that it IS the last
- let output = output . childNodesToDraw[lastIndx]._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 0), 1)
- endif
- endif
-
- return output
-endfunction
-"CLASS: TreeDirNode {{{2
-"This class is a child of the TreeFileNode class and constitutes the
-"'Composite' part of the composite design pattern between the treenode
-"classes.
-"============================================================
-let s:TreeDirNode = copy(s:TreeFileNode)
-"FUNCTION: TreeDirNode.AbsoluteTreeRoot(){{{3
-"class method that returns the highest cached ancestor of the current root
-function! s:TreeDirNode.AbsoluteTreeRoot()
- let currentNode = b:NERDTreeRoot
- while currentNode.parent != {}
- let currentNode = currentNode.parent
- endwhile
- return currentNode
-endfunction
-"FUNCTION: TreeDirNode.activate(forceKeepWinOpen) {{{3
-unlet s:TreeDirNode.activate
-function! s:TreeDirNode.activate(forceKeepWinOpen)
- call self.toggleOpen()
- call s:renderView()
- call self.putCursorHere(0, 0)
-endfunction
-"FUNCTION: TreeDirNode.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:TreeDirNode.addChild(treenode, inOrder)
- call add(self.children, a:treenode)
- let a:treenode.parent = self
-
- if a:inOrder
- call self.sortChildren()
- endif
-endfunction
-
-"FUNCTION: TreeDirNode.close() {{{3
-"Closes this directory
-function! s:TreeDirNode.close()
- let self.isOpen = 0
-endfunction
-
-"FUNCTION: TreeDirNode.closeChildren() {{{3
-"Closes all the child dir nodes of this node
-function! s:TreeDirNode.closeChildren()
- for i in self.children
- if i.path.isDirectory
- call i.close()
- call i.closeChildren()
- endif
- endfor
-endfunction
-
-"FUNCTION: TreeDirNode.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:TreeDirNode.createChild(path, inOrder)
- let newTreeNode = s:TreeFileNode.New(a:path)
- call self.addChild(newTreeNode, a:inOrder)
- return newTreeNode
-endfunction
-
-"FUNCTION: TreeDirNode.findNode(path) {{{3
-"Will find one of the children (recursively) that has the given path
-"
-"Args:
-"path: a path object
-unlet s:TreeDirNode.findNode
-function! s:TreeDirNode.findNode(path)
- if a:path.equals(self.path)
- return self
- endif
- if stridx(a:path.str(), self.path.str(), 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: TreeDirNode.getChildCount() {{{3
-"Returns the number of children this node has
-function! s:TreeDirNode.getChildCount()
- return len(self.children)
-endfunction
-
-"FUNCTION: TreeDirNode.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:TreeDirNode.getChild(path)
- if stridx(a:path.str(), self.path.str(), 0) ==# -1
- return {}
- endif
-
- let index = self.getChildIndex(a:path)
- if index ==# -1
- return {}
- else
- return self.children[index]
- endif
-
-endfunction
-
-"FUNCTION: TreeDirNode.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:TreeDirNode.getChildByIndex(indx, visible)
- let array_to_search = a:visible? self.getVisibleChildren() : self.children
- if a:indx > len(array_to_search)
- throw "NERDTree.InvalidArgumentsError: Index is out of bounds."
- endif
- return array_to_search[a:indx]
-endfunction
-
-"FUNCTION: TreeDirNode.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:TreeDirNode.getChildIndex(path)
- if stridx(a:path.str(), self.path.str(), 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: TreeDirNode.GetSelected() {{{3
-"Returns the current node if it is a dir node, or else returns the current
-"nodes parent
-unlet s:TreeDirNode.GetSelected
-function! s:TreeDirNode.GetSelected()
- let currentDir = s:TreeFileNode.GetSelected()
- if currentDir != {} && !currentDir.isRoot()
- if currentDir.path.isDirectory ==# 0
- let currentDir = currentDir.parent
- endif
- endif
- return currentDir
-endfunction
-"FUNCTION: TreeDirNode.getVisibleChildCount() {{{3
-"Returns the number of visible children this node has
-function! s:TreeDirNode.getVisibleChildCount()
- return len(self.getVisibleChildren())
-endfunction
-
-"FUNCTION: TreeDirNode.getVisibleChildren() {{{3
-"Returns a list of children to display for this node, in the correct order
-"
-"Return:
-"an array of treenodes
-function! s:TreeDirNode.getVisibleChildren()
- let toReturn = []
- for i in self.children
- if i.path.ignore() ==# 0
- call add(toReturn, i)
- endif
- endfor
- return toReturn
-endfunction
-
-"FUNCTION: TreeDirNode.hasVisibleChildren() {{{3
-"returns 1 if this node has any childre, 0 otherwise..
-function! s:TreeDirNode.hasVisibleChildren()
- return self.getVisibleChildCount() != 0
-endfunction
-
-"FUNCTION: TreeDirNode._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:TreeDirNode._initChildren(silent)
- "remove all the current child nodes
- let self.children = []
-
- "get an array of all the files in the nodes dir
- let dir = self.path
- let globDir = dir.str({'format': 'Glob'})
- let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*')
- 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
- "Note: we must match .. AND ../ cos sometimes the globpath returns
- "../ for path with strange chars (eg $)
- if i !~# '\/\.\.\/\?$' && i !~# '\/\.\/\?$'
-
- "put the next file in a new node and attach it
- try
- let path = s:Path.New(i)
- call self.createChild(path, 0)
- catch /^NERDTree.\(InvalidArguments\|InvalidFiletype\)Error/
- 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 ... DONE (". self.getChildCount() ." nodes cached).")
- endif
-
- if invalidFilesFound
- call s:echoWarning(invalidFilesFound . " file(s) could not be loaded into the NERD tree")
- endif
- return self.getChildCount()
-endfunction
-"FUNCTION: TreeDirNode.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:TreeDirNode.New
-function! s:TreeDirNode.New(path)
- if a:path.isDirectory != 1
- throw "NERDTree.InvalidArgumentsError: 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: TreeDirNode.open() {{{3
-"Reads in all this nodes children
-"
-"Return: the number of child nodes read
-unlet s:TreeDirNode.open
-function! s:TreeDirNode.open()
- let self.isOpen = 1
- if self.children ==# []
- return self._initChildren(0)
- else
- return 0
- endif
-endfunction
-
-" FUNCTION: TreeDirNode.openExplorer() {{{3
-" opens an explorer window for this node in the previous window (could be a
-" nerd tree or a netrw)
-function! s:TreeDirNode.openExplorer()
- let oldwin = winnr()
- call s:exec('wincmd p')
- if oldwin ==# winnr() || (&modified && s:bufInWindows(winbufnr(winnr())) < 2)
- call s:exec('wincmd p')
- call self.openSplit()
- else
- exec ("silent edit " . self.path.str({'format': 'Edit'}))
- endif
-endfunction
-"FUNCTION: TreeDirNode.openInNewTab(options) {{{3
-unlet s:TreeDirNode.openInNewTab
-function! s:TreeDirNode.openInNewTab(options)
- let currentTab = tabpagenr()
-
- if !has_key(a:options, 'keepTreeOpen') || !a:options['keepTreeOpen']
- call s:closeTreeIfQuitOnOpen()
- endif
-
- tabnew
- call s:initNerdTree(self.path.str())
-
- if has_key(a:options, 'stayInCurrentTab') && a:options['stayInCurrentTab']
- exec "tabnext " . currentTab
- endif
-endfunction
-"FUNCTION: TreeDirNode.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:TreeDirNode.openRecursively()
- call self._openRecursively2(1)
-endfunction
-
-"FUNCTION: TreeDirNode._openRecursively2() {{{3
-"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:TreeDirNode._openRecursively2(forceOpen)
- 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: TreeDirNode.refresh() {{{3
-unlet s:TreeDirNode.refresh
-function! s:TreeDirNode.refresh()
- call self.path.refresh()
-
- "if this node was ever opened, refresh its children
- if self.isOpen || !empty(self.children)
- "go thru all the files/dirs under this node
- let newChildNodes = []
- let invalidFilesFound = 0
- let dir = self.path
- let globDir = dir.str({'format': 'Glob'})
- let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*')
- let files = split(filesStr, "\n")
- for i in files
- "filter out the .. and . directories
- "Note: we must match .. AND ../ cos sometimes the globpath returns
- "../ for path with strange chars (eg $)
- if i !~# '\/\.\.\/\?$' && i !~# '\/\.\/\?$'
-
- try
- "create a new path and see if it exists in this nodes children
- let path = s:Path.New(i)
- let newNode = self.getChild(path)
- if newNode != {}
- call newNode.refresh()
- call add(newChildNodes, newNode)
-
- "the node doesnt exist so create it
- else
- let newNode = s:TreeFileNode.New(path)
- let newNode.parent = self
- call add(newChildNodes, newNode)
- endif
-
-
- catch /^NERDTree.InvalidArgumentsError/
- 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
- endif
-endfunction
-
-"FUNCTION: TreeDirNode.reveal(path) {{{3
-"reveal the given path, i.e. cache and open all treenodes needed to display it
-"in the UI
-function! s:TreeDirNode.reveal(path)
- if !a:path.isUnder(self.path)
- throw "NERDTree.InvalidArgumentsError: " . a:path.str() . " should be under " . self.path.str()
- endif
-
- call self.open()
-
- if self.path.equals(a:path.getParent())
- let n = self.findNode(a:path)
- call s:renderView()
- call n.putCursorHere(1,0)
- return
- endif
-
- let p = a:path
- while !p.getParent().equals(self.path)
- let p = p.getParent()
- endwhile
-
- let n = self.findNode(p)
- call n.reveal(a:path)
-endfunction
-"FUNCTION: TreeDirNode.removeChild(treenode) {{{3
-"
-"Removes the given treenode from this nodes set of children
-"
-"Args:
-"treenode: the node to remove
-"
-"Throws a NERDTree.ChildNotFoundError if the given treenode is not found
-function! s:TreeDirNode.removeChild(treenode)
- 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.ChildNotFoundError: child node was not found"
-endfunction
-
-"FUNCTION: TreeDirNode.sortChildren() {{{3
-"
-"Sorts the children of this node according to alphabetical order and the
-"directory priority.
-"
-function! s:TreeDirNode.sortChildren()
- let CompareFunc = function("s:compareNodes")
- call sort(self.children, CompareFunc)
-endfunction
-
-"FUNCTION: TreeDirNode.toggleOpen() {{{3
-"Opens this directory if it is closed and vice versa
-function! s:TreeDirNode.toggleOpen()
- if self.isOpen ==# 1
- call self.close()
- else
- call self.open()
- endif
-endfunction
-
-"FUNCTION: TreeDirNode.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:TreeDirNode.transplantChild(newNode)
- 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: Path {{{2
-"============================================================
-let s:Path = {}
-"FUNCTION: Path.AbsolutePathFor(str) {{{3
-function! s:Path.AbsolutePathFor(str)
- let prependCWD = 0
- if s:running_windows
- let prependCWD = a:str !~# '^.:\(\\\|\/\)'
- else
- let prependCWD = a:str !~# '^/'
- endif
-
- let toReturn = a:str
- if prependCWD
- let toReturn = getcwd() . s:Path.Slash() . a:str
- endif
-
- return toReturn
-endfunction
-"FUNCTION: Path.bookmarkNames() {{{3
-function! s:Path.bookmarkNames()
- if !exists("self._bookmarkNames")
- call self.cacheDisplayString()
- endif
- return self._bookmarkNames
-endfunction
-"FUNCTION: Path.cacheDisplayString() {{{3
-function! s:Path.cacheDisplayString()
- let self.cachedDisplayString = self.getLastPathComponent(1)
-
- if self.isExecutable
- let self.cachedDisplayString = self.cachedDisplayString . '*'
- endif
-
- let self._bookmarkNames = []
- for i in s:Bookmark.Bookmarks()
- if i.path.equals(self)
- call add(self._bookmarkNames, i.name)
- endif
- endfor
- if !empty(self._bookmarkNames)
- let self.cachedDisplayString .= ' {' . join(self._bookmarkNames) . '}'
- endif
-
- if self.isSymLink
- let self.cachedDisplayString .= ' -> ' . self.symLinkDest
- endif
-
- if self.isReadOnly
- let self.cachedDisplayString .= ' [RO]'
- endif
-endfunction
-"FUNCTION: Path.changeToDir() {{{3
-function! s:Path.changeToDir()
- let dir = self.str({'format': 'Cd'})
- if self.isDirectory ==# 0
- let dir = self.getParent().str({'format': 'Cd'})
- endif
-
- try
- execute "cd " . dir
- call s:echo("CWD is now: " . getcwd())
- catch
- throw "NERDTree.PathChangeError: cannot change CWD to " . dir
- endtry
-endfunction
-
-"FUNCTION: Path.compareTo() {{{3
-"
-"Compares this Path to the given path and returns 0 if they are equal, -1 if
-"this Path 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:Path.compareTo(path)
- 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: Path.Create(fullpath) {{{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:Path.Create(fullpath)
- "bail if the a:fullpath already exists
- if isdirectory(a:fullpath) || filereadable(a:fullpath)
- throw "NERDTree.CreatePathError: Directory Exists: '" . a:fullpath . "'"
- endif
-
- try
-
- "if it ends with a slash, assume its a dir create it
- if a:fullpath =~# '\(\\\|\/\)$'
- "whack the trailing slash off the end if it exists
- let fullpath = substitute(a:fullpath, '\(\\\|\/\)$', '', '')
-
- call mkdir(fullpath, 'p')
-
- "assume its a file and create
- else
- call writefile([], a:fullpath)
- endif
- catch
- throw "NERDTree.CreatePathError: Could not create path: '" . a:fullpath . "'"
- endtry
-
- return s:Path.New(a:fullpath)
-endfunction
-
-"FUNCTION: Path.copy(dest) {{{3
-"
-"Copies the file/dir represented by this Path to the given location
-"
-"Args:
-"dest: the location to copy this dir/file to
-function! s:Path.copy(dest)
- if !s:Path.CopyingSupported()
- throw "NERDTree.CopyingNotSupportedError: Copying is not supported on this OS"
- endif
-
- let dest = s:Path.WinToUnixPath(a:dest)
-
- let cmd = g:NERDTreeCopyCmd . " " . escape(self.str(), s:escape_chars) . " " . escape(dest, s:escape_chars)
- let success = system(cmd)
- if success != 0
- throw "NERDTree.CopyError: Could not copy ''". self.str() ."'' to: '" . a:dest . "'"
- endif
-endfunction
-
-"FUNCTION: Path.CopyingSupported() {{{3
-"
-"returns 1 if copying is supported for this OS
-function! s:Path.CopyingSupported()
- return exists('g:NERDTreeCopyCmd')
-endfunction
-
-
-"FUNCTION: Path.copyingWillOverwrite(dest) {{{3
-"
-"returns 1 if copy this path to the given location will cause files to
-"overwritten
-"
-"Args:
-"dest: the location this path will be copied to
-function! s:Path.copyingWillOverwrite(dest)
- if filereadable(a:dest)
- return 1
- endif
-
- if isdirectory(a:dest)
- let path = s:Path.JoinPathStrings(a:dest, self.getLastPathComponent(0))
- if filereadable(path)
- return 1
- endif
- endif
-endfunction
-
-"FUNCTION: Path.delete() {{{3
-"
-"Deletes the file represented by this path.
-"Deletion of directories is not supported
-"
-"Throws NERDTree.Path.Deletion exceptions
-function! s:Path.delete()
- if self.isDirectory
-
- let cmd = g:NERDTreeRemoveDirCmd . self.str({'escape': 1})
- let success = system(cmd)
-
- if v:shell_error != 0
- throw "NERDTree.PathDeletionError: Could not delete directory: '" . self.str() . "'"
- endif
- else
- let success = delete(self.str())
- if success != 0
- throw "NERDTree.PathDeletionError: Could not delete file: '" . self.str() . "'"
- endif
- endif
-
- "delete all bookmarks for this path
- for i in self.bookmarkNames()
- let bookmark = s:Bookmark.BookmarkFor(i)
- call bookmark.delete()
- endfor
-endfunction
-
-"FUNCTION: Path.displayString() {{{3
-"
-"Returns a string that specifies how the path should be represented as a
-"string
-function! s:Path.displayString()
- if self.cachedDisplayString ==# ""
- call self.cacheDisplayString()
- endif
-
- return self.cachedDisplayString
-endfunction
-"FUNCTION: Path.extractDriveLetter(fullpath) {{{3
-"
-"If running windows, cache the drive letter for this path
-function! s:Path.extractDriveLetter(fullpath)
- if s:running_windows
- let self.drive = substitute(a:fullpath, '\(^[a-zA-Z]:\).*', '\1', '')
- else
- let self.drive = ''
- endif
-
-endfunction
-"FUNCTION: Path.exists() {{{3
-"return 1 if this path points to a location that is readable or is a directory
-function! s:Path.exists()
- let p = self.str()
- return filereadable(p) || isdirectory(p)
-endfunction
-"FUNCTION: Path.getDir() {{{3
-"
-"Returns this path if it is a directory, else this paths parent.
-"
-"Return:
-"a Path object
-function! s:Path.getDir()
- if self.isDirectory
- return self
- else
- return self.getParent()
- endif
-endfunction
-"FUNCTION: Path.getParent() {{{3
-"
-"Returns a new path object for this paths parent
-"
-"Return:
-"a new Path object
-function! s:Path.getParent()
- if s:running_windows
- let path = self.drive . '\' . join(self.pathSegments[0:-2], '\')
- else
- let path = '/'. join(self.pathSegments[0:-2], '/')
- endif
-
- return s:Path.New(path)
-endfunction
-"FUNCTION: Path.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:Path.getLastPathComponent(dirSlash)
- if empty(self.pathSegments)
- return ''
- endif
- let toReturn = self.pathSegments[-1]
- if a:dirSlash && self.isDirectory
- let toReturn = toReturn . '/'
- endif
- return toReturn
-endfunction
-
-"FUNCTION: Path.getSortOrderIndex() {{{3
-"returns the index of the pattern in g:NERDTreeSortOrder that this path matches
-function! s:Path.getSortOrderIndex()
- let i = 0
- while i < len(g:NERDTreeSortOrder)
- if self.getLastPathComponent(1) =~# g:NERDTreeSortOrder[i]
- return i
- endif
- let i = i + 1
- endwhile
- return s:NERDTreeSortStarIndex
-endfunction
-
-"FUNCTION: Path.ignore() {{{3
-"returns true if this path should be ignored
-function! s:Path.ignore()
- let lastPathComponent = self.getLastPathComponent(0)
-
- "filter out the user specified paths to ignore
- if b:NERDTreeIgnoreEnabled
- for i in g:NERDTreeIgnore
- if lastPathComponent =~# i
- return 1
- endif
- endfor
- endif
-
- "dont show hidden files unless instructed to
- if b:NERDTreeShowHidden ==# 0 && lastPathComponent =~# '^\.'
- return 1
- endif
-
- if b:NERDTreeShowFiles ==# 0 && self.isDirectory ==# 0
- return 1
- endif
-
- return 0
-endfunction
-
-"FUNCTION: Path.isUnder(path) {{{3
-"return 1 if this path is somewhere under the given path in the filesystem.
-"
-"a:path should be a dir
-function! s:Path.isUnder(path)
- if a:path.isDirectory == 0
- return 0
- endif
-
- let this = self.str()
- let that = a:path.str()
- return stridx(this, that . s:Path.Slash()) == 0
-endfunction
-
-"FUNCTION: Path.JoinPathStrings(...) {{{3
-function! s:Path.JoinPathStrings(...)
- let components = []
- for i in a:000
- let components = extend(components, split(i, '/'))
- endfor
- return '/' . join(components, '/')
-endfunction
-
-"FUNCTION: Path.equals() {{{3
-"
-"Determines whether 2 path objects 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:Path.equals(path)
- return self.str() ==# a:path.str()
-endfunction
-
-"FUNCTION: Path.New() {{{3
-"The Constructor for the Path object
-function! s:Path.New(path)
- let newPath = copy(self)
-
- call newPath.readInfoFromDisk(s:Path.AbsolutePathFor(a:path))
-
- let newPath.cachedDisplayString = ""
-
- return newPath
-endfunction
-
-"FUNCTION: Path.Slash() {{{3
-"return the slash to use for the current OS
-function! s:Path.Slash()
- return s:running_windows ? '\' : '/'
-endfunction
-
-"FUNCTION: Path.readInfoFromDisk(fullpath) {{{3
-"
-"
-"Throws NERDTree.Path.InvalidArguments exception.
-function! s:Path.readInfoFromDisk(fullpath)
- call self.extractDriveLetter(a:fullpath)
-
- let fullpath = s:Path.WinToUnixPath(a:fullpath)
-
- if getftype(fullpath) ==# "fifo"
- throw "NERDTree.InvalidFiletypeError: Cant handle FIFO files: " . a:fullpath
- endif
-
- let self.pathSegments = split(fullpath, '/')
-
- let self.isReadOnly = 0
- if isdirectory(a:fullpath)
- let self.isDirectory = 1
- elseif filereadable(a:fullpath)
- let self.isDirectory = 0
- let self.isReadOnly = filewritable(a:fullpath) ==# 0
- else
- throw "NERDTree.InvalidArgumentsError: Invalid path = " . a:fullpath
- endif
-
- let self.isExecutable = 0
- if !self.isDirectory
- let self.isExecutable = getfperm(a:fullpath) =~# 'x'
- 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: Path.refresh() {{{3
-function! s:Path.refresh()
- call self.readInfoFromDisk(self.str())
- call self.cacheDisplayString()
-endfunction
-
-"FUNCTION: Path.rename() {{{3
-"
-"Renames this node on the filesystem
-function! s:Path.rename(newPath)
- if a:newPath ==# ''
- throw "NERDTree.InvalidArgumentsError: Invalid newPath for renaming = ". a:newPath
- endif
-
- let success = rename(self.str(), a:newPath)
- if success != 0
- throw "NERDTree.PathRenameError: Could not rename: '" . self.str() . "'" . 'to:' . a:newPath
- endif
- call self.readInfoFromDisk(a:newPath)
-
- for i in self.bookmarkNames()
- let b = s:Bookmark.BookmarkFor(i)
- call b.setPath(copy(self))
- endfor
- call s:Bookmark.Write()
-endfunction
-
-"FUNCTION: Path.str() {{{3
-"
-"Returns a string representation of this Path
-"
-"Takes an optional dictionary param to specify how the output should be
-"formatted.
-"
-"The dict may have the following keys:
-" 'format'
-" 'escape'
-" 'truncateTo'
-"
-"The 'format' key may have a value of:
-" 'Cd' - a string to be used with the :cd command
-" 'Edit' - a string to be used with :e :sp :new :tabedit etc
-" 'UI' - a string used in the NERD tree UI
-"
-"The 'escape' key, if specified will cause the output to be escaped with
-"shellescape()
-"
-"The 'truncateTo' key causes the resulting string to be truncated to the value
-"'truncateTo' maps to. A '<' char will be prepended.
-function! s:Path.str(...)
- let options = a:0 ? a:1 : {}
- let toReturn = ""
-
- if has_key(options, 'format')
- let format = options['format']
- if has_key(self, '_strFor' . format)
- exec 'let toReturn = self._strFor' . format . '()'
- else
- raise 'NERDTree.UnknownFormatError: unknown format "'. format .'"'
- endif
- else
- let toReturn = self._str()
- endif
-
- if has_key(options, 'escape') && options['escape']
- let toReturn = shellescape(toReturn)
- endif
-
- if has_key(options, 'truncateTo')
- let limit = options['truncateTo']
- if len(toReturn) > limit
- let toReturn = "<" . strpart(toReturn, len(toReturn) - limit + 1)
- endif
- endif
-
- return toReturn
-endfunction
-
-"FUNCTION: Path._strForUI() {{{3
-function! s:Path._strForUI()
- let toReturn = '/' . join(self.pathSegments, '/')
- if self.isDirectory && toReturn != '/'
- let toReturn = toReturn . '/'
- endif
- return toReturn
-endfunction
-
-"FUNCTION: Path._strForCd() {{{3
-"
-" returns a string that can be used with :cd
-function! s:Path._strForCd()
- return escape(self.str(), s:escape_chars)
-endfunction
-"FUNCTION: Path._strForEdit() {{{3
-"
-"Return: the string for this path that is suitable to be used with the :edit
-"command
-function! s:Path._strForEdit()
- let p = self.str({'format': 'UI'})
- let cwd = getcwd()
-
- if s:running_windows
- let p = tolower(self.str())
- let cwd = tolower(getcwd())
- endif
-
- let p = escape(p, s:escape_chars)
-
- let cwd = cwd . s:Path.Slash()
-
- "return a relative path if we can
- if stridx(p, cwd) ==# 0
- let p = strpart(p, strlen(cwd))
- endif
-
- if p ==# ''
- let p = '.'
- endif
-
- return p
-
-endfunction
-"FUNCTION: Path._strForGlob() {{{3
-function! s:Path._strForGlob()
- let lead = s:Path.Slash()
-
- "if we are running windows then slap a drive letter on the front
- if s:running_windows
- let lead = self.drive . '\'
- endif
-
- let toReturn = lead . join(self.pathSegments, s:Path.Slash())
-
- if !s:running_windows
- let toReturn = escape(toReturn, s:escape_chars)
- endif
- return toReturn
-endfunction
-"FUNCTION: Path._str() {{{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
-function! s:Path._str()
- let lead = s:Path.Slash()
-
- "if we are running windows then slap a drive letter on the front
- if s:running_windows
- let lead = self.drive . '\'
- endif
-
- return lead . join(self.pathSegments, s:Path.Slash())
-endfunction
-
-"FUNCTION: Path.strTrunk() {{{3
-"Gets the path without the last segment on the end.
-function! s:Path.strTrunk()
- return self.drive . '/' . join(self.pathSegments[0:-2], '/')
-endfunction
-
-"FUNCTION: Path.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:Path.WinToUnixPath(pathstr)
- if !s:running_windows
- return a:pathstr
- endif
-
- 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: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:checkForBrowse(dir) {{{2
-"inits a secondary nerd tree in the current buffer if appropriate
-function! s:checkForBrowse(dir)
- if a:dir != '' && isdirectory(a:dir)
- call s:initNerdTreeInPlace(a:dir)
- endif
-endfunction
-"FUNCTION: s:compareBookmarks(first, second) {{{2
-"Compares two bookmarks
-function! s:compareBookmarks(first, second)
- return a:first.compareTo(a:second)
-endfunction
-
-" FUNCTION: s:completeBookmarks(A,L,P) {{{2
-" completion function for the bookmark commands
-function! s:completeBookmarks(A,L,P)
- return filter(s:Bookmark.BookmarkNames(), 'v:val =~# "^' . a:A . '"')
-endfunction
-" FUNCTION: s:exec(cmd) {{{2
-" same as :exec cmd but eventignore=all is set for the duration
-function! s:exec(cmd)
- let old_ei = &ei
- set ei=all
- exec a:cmd
- let &ei = old_ei
-endfunction
-" FUNCTION: s:findAndRevealPath() {{{2
-function! s:findAndRevealPath()
- try
- let p = s:Path.New(expand("%:p"))
- catch /^NERDTree.InvalidArgumentsError/
- call s:echo("no file for the current buffer")
- return
- endtry
-
- if !s:treeExistsForTab()
- try
- let cwd = s:Path.New(getcwd())
- catch /^NERDTree.InvalidArgumentsError/
- call s:echo("current directory does not exist.")
- let cwd = p.getParent()
- endtry
-
- if p.isUnder(cwd)
- call s:initNerdTree(cwd.str())
- else
- call s:initNerdTree(p.getParent().str())
- endif
- else
- if !p.isUnder(s:TreeFileNode.GetRootForTab().path)
- call s:initNerdTree(p.getParent().str())
- else
- if !s:isTreeOpen()
- call s:toggle("")
- endif
- endif
- endif
- call s:putCursorInTreeWin()
- call b:NERDTreeRoot.reveal(p)
-endfunction
-"FUNCTION: s:initNerdTree(name) {{{2
-"Initialise the nerd tree for this tab. The tree will start in either the
-"given directory, or the directory associated with the given bookmark
-"
-"Args:
-"name: the name of a bookmark or a directory
-function! s:initNerdTree(name)
- let path = {}
- if s:Bookmark.BookmarkExistsFor(a:name)
- let path = s:Bookmark.BookmarkFor(a:name).path
- else
- let dir = a:name ==# '' ? getcwd() : a:name
-
- "hack to get an absolute path if a relative path is given
- if dir =~# '^\.'
- let dir = getcwd() . s:Path.Slash() . dir
- endif
- let dir = resolve(dir)
-
- try
- let path = s:Path.New(dir)
- catch /^NERDTree.InvalidArgumentsError/
- call s:echo("No bookmark or directory found for: " . a:name)
- return
- endtry
- endif
- if !path.isDirectory
- let path = path.getParent()
- endif
-
- "if instructed to, then change the vim CWD to the dir the NERDTree is
- "inited in
- if g:NERDTreeChDirMode != 0
- call path.changeToDir()
- endif
-
- if s:treeExistsForTab()
- if s:isTreeOpen()
- call s:closeTree()
- endif
- unlet t:NERDTreeBufName
- endif
-
- let newRoot = s:TreeDirNode.New(path)
- call newRoot.open()
-
- call s:createTreeWin()
- let b:treeShowHelp = 0
- let b:NERDTreeIgnoreEnabled = 1
- let b:NERDTreeShowFiles = g:NERDTreeShowFiles
- let b:NERDTreeShowHidden = g:NERDTreeShowHidden
- let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
- let b:NERDTreeRoot = newRoot
-
- let b:NERDTreeType = "primary"
-
- call s:renderView()
- call b:NERDTreeRoot.putCursorHere(0, 0)
-endfunction
-
-"FUNCTION: s:initNerdTreeInPlace(dir) {{{2
-function! s:initNerdTreeInPlace(dir)
- try
- let path = s:Path.New(a:dir)
- catch /^NERDTree.InvalidArgumentsError/
- call s:echo("Invalid directory name:" . a:name)
- return
- endtry
-
- "we want the directory buffer to disappear when we do the :edit below
- setlocal bufhidden=wipe
-
- let previousBuf = expand("#")
-
- "we need a unique name for each secondary tree buffer to ensure they are
- "all independent
- exec "silent edit " . s:nextBufferName()
-
- let b:NERDTreePreviousBuf = bufnr(previousBuf)
-
- let b:NERDTreeRoot = s:TreeDirNode.New(path)
- call b:NERDTreeRoot.open()
-
- call s:setCommonBufOptions()
- let b:NERDTreeType = "secondary"
-
- call s:renderView()
-endfunction
-" FUNCTION: s:initNerdTreeMirror() {{{2
-function! s:initNerdTreeMirror()
-
- "get the names off all the nerd tree buffers
- let treeBufNames = []
- for i in range(1, tabpagenr("$"))
- let nextName = s:tabpagevar(i, 'NERDTreeBufName')
- if nextName != -1 && (!exists("t:NERDTreeBufName") || nextName != t:NERDTreeBufName)
- call add(treeBufNames, nextName)
- endif
- endfor
- let treeBufNames = s:unique(treeBufNames)
-
- "map the option names (that the user will be prompted with) to the nerd
- "tree buffer names
- let options = {}
- let i = 0
- while i < len(treeBufNames)
- let bufName = treeBufNames[i]
- let treeRoot = getbufvar(bufName, "NERDTreeRoot")
- let options[i+1 . '. ' . treeRoot.path.str() . ' (buf name: ' . bufName . ')'] = bufName
- let i = i + 1
- endwhile
-
- "work out which tree to mirror, if there is more than 1 then ask the user
- let bufferName = ''
- if len(keys(options)) > 1
- let choices = ["Choose a tree to mirror"]
- let choices = extend(choices, sort(keys(options)))
- let choice = inputlist(choices)
- if choice < 1 || choice > len(options) || choice ==# ''
- return
- endif
-
- let bufferName = options[sort(keys(options))[choice-1]]
- elseif len(keys(options)) ==# 1
- let bufferName = values(options)[0]
- else
- call s:echo("No trees to mirror")
- return
- endif
-
- if s:treeExistsForTab() && s:isTreeOpen()
- call s:closeTree()
- endif
-
- let t:NERDTreeBufName = bufferName
- call s:createTreeWin()
- exec 'buffer ' . bufferName
- if !&hidden
- call s:renderView()
- endif
-endfunction
-" FUNCTION: s:nextBufferName() {{{2
-" returns the buffer name for the next nerd tree
-function! s:nextBufferName()
- let name = s:NERDTreeBufName . s:next_buffer_number
- let s:next_buffer_number += 1
- return name
-endfunction
-" FUNCTION: s:tabpagevar(tabnr, var) {{{2
-function! s:tabpagevar(tabnr, var)
- let currentTab = tabpagenr()
- let old_ei = &ei
- set ei=all
-
- exec "tabnext " . a:tabnr
- let v = -1
- if exists('t:' . a:var)
- exec 'let v = t:' . a:var
- endif
- exec "tabnext " . currentTab
-
- let &ei = old_ei
-
- return v
-endfunction
-" Function: s:treeExistsForBuffer() {{{2
-" Returns 1 if a nerd tree root exists in the current buffer
-function! s:treeExistsForBuf()
- return exists("b:NERDTreeRoot")
-endfunction
-" Function: s:treeExistsForTab() {{{2
-" Returns 1 if a nerd tree root exists in the current tab
-function! s:treeExistsForTab()
- return exists("t:NERDTreeBufName")
-endfunction
-" Function: s:unique(list) {{{2
-" returns a:list without duplicates
-function! s:unique(list)
- let uniqlist = []
- for elem in a:list
- if index(uniqlist, elem) ==# -1
- let uniqlist += [elem]
- endif
- endfor
- return uniqlist
-endfunction
-" SECTION: Public API {{{1
-"============================================================
-let g:NERDTreePath = s:Path
-let g:NERDTreeDirNode = s:TreeDirNode
-let g:NERDTreeFileNode = s:TreeFileNode
-let g:NERDTreeBookmark = s:Bookmark
-
-function! NERDTreeAddMenuItem(options)
- call s:MenuItem.Create(a:options)
-endfunction
-
-function! NERDTreeAddMenuSeparator(...)
- let opts = a:0 ? a:1 : {}
- call s:MenuItem.CreateSeparator(opts)
-endfunction
-
-function! NERDTreeAddSubmenu(options)
- return s:MenuItem.Create(a:options)
-endfunction
-
-function! NERDTreeAddKeyMap(options)
- call s:KeyMap.Create(a:options)
-endfunction
-
-function! NERDTreeRender()
- call s:renderView()
-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 primary NERD tree window for this tab
-function! s:closeTree()
- if !s:isTreeOpen()
- throw "NERDTree.NoTreeFoundError: no NERDTree is open"
- endif
-
- if winnr("$") != 1
- if winnr() == s:getTreeWinNum()
- wincmd p
- let bufnr = bufnr("")
- wincmd p
- else
- let bufnr = bufnr("")
- endif
-
- call s:exec(s:getTreeWinNum() . " wincmd w")
- close
- call s:exec(bufwinnr(bufnr) . " wincmd w")
- else
- close
- endif
-endfunction
-
-"FUNCTION: s:closeTreeIfOpen() {{{2
-"Closes the NERD tree window if it is open
-function! s:closeTreeIfOpen()
- if s:isTreeOpen()
- call s:closeTree()
- endif
-endfunction
-"FUNCTION: s:closeTreeIfQuitOnOpen() {{{2
-"Closes the NERD tree window if the close on open option is set
-function! s:closeTreeIfQuitOnOpen()
- if g:NERDTreeQuitOnOpen && s:isTreeOpen()
- call s:closeTree()
- 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 ==# "left" ? "topleft " : "botright "
- let splitSize = g:NERDTreeWinSize
-
- if !exists('t:NERDTreeBufName')
- let t:NERDTreeBufName = s:nextBufferName()
- silent! exec splitLocation . 'vertical ' . splitSize . ' new'
- silent! exec "edit " . t:NERDTreeBufName
- else
- silent! exec splitLocation . 'vertical ' . splitSize . ' split'
- silent! exec "buffer " . t:NERDTreeBufName
- endif
-
- setlocal winfixwidth
- call s:setCommonBufOptions()
-endfunction
-
-"FUNCTION: s:dumpHelp {{{2
-"prints out the quick help
-function! s:dumpHelp()
- let old_h = @h
- if b: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."\" <CR>,\n"
- if b:NERDTreeType ==# "primary"
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n"
- else
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in current window\n"
- endif
- if b:NERDTreeType ==# "primary"
- let @h=@h."\" ". g:NERDTreeMapPreview .": preview\n"
- endif
- 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:NERDTreeMapOpenVSplit .": open vsplit\n"
- let @h=@h."\" ". g:NERDTreeMapPreviewVSplit .": preview vsplit\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.": explore selected dir\n"
-
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Bookmark table mappings~\n"
- let @h=@h."\" double-click,\n"
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open bookmark\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."\" ". g:NERDTreeMapDeleteBookmark .": delete bookmark\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:NERDTreeMapMenu .": Show 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 (" . (b:NERDTreeShowHidden ? "on" : "off") . ")\n"
- let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (b:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n"
- let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (b:NERDTreeShowFiles ? "on" : "off") . ")\n"
- let @h=@h."\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (b:NERDTreeShowBookmarks ? "on" : "off") . ")\n"
-
- "add quickhelp entries for each custom key map
- if len(s:KeyMap.All())
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Custom mappings~\n"
- for i in s:KeyMap.All()
- let @h=@h."\" ". i.key .": ". i.quickhelpText ."\n"
- endfor
- endif
-
- 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:NERDTreeMapToggleZoom .": Zoom (maximize-minimize)\n"
- let @h=@h."\" the NERDTree window\n"
- let @h=@h."\" ". g:NERDTreeMapHelp .": toggle help\n"
- let @h=@h."\"\n\" ----------------------------\n"
- let @h=@h."\" Bookmark commands~\n"
- let @h=@h."\" :Bookmark <name>\n"
- let @h=@h."\" :BookmarkToRoot <name>\n"
- let @h=@h."\" :RevealBookmark <name>\n"
- let @h=@h."\" :OpenBookmark <name>\n"
- let @h=@h."\" :ClearBookmarks [<names>]\n"
- let @h=@h."\" :ClearAllBookmarks\n"
- silent! put h
- elseif g:NERDTreeMinimalUI == 0
- let @h="\" Press ". g:NERDTreeMapHelp ." for help\n"
- silent! put h
- endif
-
- 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
- echomsg "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:firstUsableWindow(){{{2
-"find the window number of the first normal window
-function! s:firstUsableWindow()
- let i = 1
- while i <= winnr("$")
- let bnum = winbufnr(i)
- if bnum != -1 && getbufvar(bnum, '&buftype') ==# ''
- \ && !getwinvar(i, '&previewwindow')
- \ && (!getbufvar(bnum, '&modified') || &hidden)
- return i
- endif
-
- let i += 1
- endwhile
- return -1
-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)
-
- let rootLine = s:TreeFileNode.GetRootLineNum()
-
- "check to see if we have the root node
- if a:ln == rootLine
- return b:NERDTreeRoot.path
- endif
-
- if !g:NERDTreeDirArrows
- " in case called from outside the tree
- if line !~# '^ *[|`▸▾ ]' || line =~# '^$'
- return {}
- endif
- endif
-
- if line ==# s:tree_up_dir_line
- return b:NERDTreeRoot.path.getParent()
- endif
-
- let indent = s:indentLevelFor(line)
-
- "remove the tree parts and the leading space
- let curFile = s:stripMarkupFromLine(line, 0)
-
- let wasdir = 0
- if curFile =~# '/$'
- let wasdir = 1
- let curFile = substitute(curFile, '/\?$', '/', "")
- endif
-
- let dir = ""
- let lnum = a:ln
- while lnum > 0
- let lnum = lnum - 1
- let curLine = getline(lnum)
- let curLineStripped = s:stripMarkupFromLine(curLine, 1)
-
- "have we reached the top of the tree?
- if lnum == rootLine
- let dir = b:NERDTreeRoot.path.str({'format': 'UI'}) . dir
- break
- endif
- if curLineStripped =~# '/$'
- let lpindent = s:indentLevelFor(curLine)
- if lpindent < indent
- let indent = indent - 1
-
- let dir = substitute (curLineStripped,'^\\', "", "") . dir
- continue
- endif
- endif
- endwhile
- let curFile = b:NERDTreeRoot.path.drive . dir . curFile
- let toReturn = s:Path.New(curFile)
- return toReturn
-endfunction
-
-"FUNCTION: s:getTreeWinNum() {{{2
-"gets the nerd tree window number for this tab
-function! s:getTreeWinNum()
- if exists("t:NERDTreeBufName")
- return bufwinnr(t:NERDTreeBufName)
- else
- return -1
- endif
-endfunction
-"FUNCTION: s:indentLevelFor(line) {{{2
-function! s:indentLevelFor(line)
- let level = match(a:line, '[^ \-+~▸▾`|]') / s:tree_wid
- " check if line includes arrows
- if match(a:line, '[▸▾]') > -1
- " decrement level as arrow uses 3 ascii chars
- let level = level - 1
- endif
- return level
-endfunction
-"FUNCTION: s:isTreeOpen() {{{2
-function! s:isTreeOpen()
- return s:getTreeWinNum() != -1
-endfunction
-"FUNCTION: s:isWindowUsable(winnumber) {{{2
-"Returns 0 if opening a file from the tree in the given window requires it to
-"be split, 1 otherwise
-"
-"Args:
-"winnumber: the number of the window in question
-function! s:isWindowUsable(winnumber)
- "gotta split if theres only one window (i.e. the NERD tree)
- if winnr("$") ==# 1
- return 0
- endif
-
- let oldwinnr = winnr()
- call s:exec(a:winnumber . "wincmd p")
- let specialWindow = getbufvar("%", '&buftype') != '' || getwinvar('%', '&previewwindow')
- let modified = &modified
- call s:exec(oldwinnr . "wincmd p")
-
- "if its a special window e.g. quickfix or another explorer plugin then we
- "have to split
- if specialWindow
- return 0
- endif
-
- if &hidden
- return 1
- endif
-
- return !modified || s:bufInWindows(winbufnr(a:winnumber)) >= 2
-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:TreeFileNode.GetSelected()
- 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.findOpenDirSiblingWithVisibleChildren(a:direction)
- if siblingDir != {}
- let indx = a:direction ? siblingDir.getVisibleChildCount()-1 : 0
- let targetNode = siblingDir.getChildByIndex(indx, 1)
- endif
- endif
-
- call targetNode.putCursorHere(1, 0)
-
- call s:centerView()
-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:putCursorOnBookmarkTable(){{{2
-"Places the cursor at the top of the bookmarks table
-function! s:putCursorOnBookmarkTable()
- if !b:NERDTreeShowBookmarks
- throw "NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active"
- endif
-
- if g:NERDTreeMinimalUI
- return cursor(1, 2)
- endif
-
- let rootNodeLine = s:TreeFileNode.GetRootLineNum()
-
- let line = 1
- while getline(line) !~# '^>-\+Bookmarks-\+$'
- let line = line + 1
- if line >= rootNodeLine
- throw "NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table"
- endif
- endwhile
- call cursor(line, 2)
-endfunction
-
-"FUNCTION: s:putCursorInTreeWin(){{{2
-"Places the cursor in the nerd tree window
-function! s:putCursorInTreeWin()
- if !s:isTreeOpen()
- throw "NERDTree.InvalidOperationError: cant put cursor in NERD tree window, no window exists"
- endif
-
- call s:exec(s:getTreeWinNum() . "wincmd w")
-endfunction
-
-"FUNCTION: s:renderBookmarks {{{2
-function! s:renderBookmarks()
-
- if g:NERDTreeMinimalUI == 0
- call setline(line(".")+1, ">----------Bookmarks----------")
- call cursor(line(".")+1, col("."))
- endif
-
- for i in s:Bookmark.Bookmarks()
- call setline(line(".")+1, i.str())
- call cursor(line(".")+1, col("."))
- endfor
-
- call setline(line(".")+1, '')
- call cursor(line(".")+1, col("."))
-endfunction
-"FUNCTION: s:renderView {{{2
-"The entry function for rendering the tree
-function! s:renderView()
- 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
- if g:NERDTreeMinimalUI == 0
- call setline(line(".")+1, "")
- call cursor(line(".")+1, col("."))
- endif
-
- if b:NERDTreeShowBookmarks
- call s:renderBookmarks()
- endif
-
- "add the 'up a dir' line
- if !g:NERDTreeMinimalUI
- call setline(line(".")+1, s:tree_up_dir_line)
- call cursor(line(".")+1, col("."))
- endif
-
- "draw the header line
- let header = b:NERDTreeRoot.path.str({'format': 'UI', 'truncateTo': winwidth(0)})
- call setline(line(".")+1, header)
- call cursor(line(".")+1, col("."))
-
- "draw the tree
- let old_o = @o
- let @o = b:NERDTreeRoot.renderToString()
- silent put o
- let @o = old_o
-
- "delete the blank line at the top of the buffer
- silent 1,1delete _
-
- "restore the view
- let old_scrolloff=&scrolloff
- let &scrolloff=0
- call cursor(topLine, 1)
- normal! zt
- call cursor(curLine, curCol)
- let &scrolloff = old_scrolloff
-
- 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:TreeFileNode.GetSelected()
-
- "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 currentNode.putCursorHere(0, 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("b:NERDTreeOldTopLine") || !exists("b:NERDTreeOldPos") || !exists("b:NERDTreeOldWindowSize")
- return
- endif
- exec("silent vertical resize ".b:NERDTreeOldWindowSize)
-
- let old_scrolloff=&scrolloff
- let &scrolloff=0
- call cursor(b:NERDTreeOldTopLine, 0)
- normal! zt
- call setpos(".", b:NERDTreeOldPos)
- let &scrolloff=old_scrolloff
-endfunction
-
-"FUNCTION: s:saveScreenState() {{{2
-"Saves the current cursor position in the current buffer and the window
-"scroll position
-function! s:saveScreenState()
- let win = winnr()
- try
- call s:putCursorInTreeWin()
- let b:NERDTreeOldPos = getpos(".")
- let b:NERDTreeOldTopLine = line("w0")
- let b:NERDTreeOldWindowSize = winwidth("")
- call s:exec(win . "wincmd w")
- catch /^NERDTree.InvalidOperationError/
- endtry
-endfunction
-
-"FUNCTION: s:setCommonBufOptions() {{{2
-function! s:setCommonBufOptions()
- "throwaway buffer options
- setlocal noswapfile
- setlocal buftype=nofile
- setlocal bufhidden=hide
- setlocal nowrap
- setlocal foldcolumn=0
- setlocal nobuflisted
- setlocal nospell
- if g:NERDTreeShowLineNumbers
- setlocal nu
- else
- setlocal nonu
- if v:version >= 703
- setlocal nornu
- endif
- endif
-
- iabc <buffer>
-
- if g:NERDTreeHighlightCursorline
- setlocal cursorline
- endif
-
- call s:setupStatusline()
-
-
- let b:treeShowHelp = 0
- let b:NERDTreeIgnoreEnabled = 1
- let b:NERDTreeShowFiles = g:NERDTreeShowFiles
- let b:NERDTreeShowHidden = g:NERDTreeShowHidden
- let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
- setfiletype nerdtree
- call s:bindMappings()
-endfunction
-
-"FUNCTION: s:setupStatusline() {{{2
-function! s:setupStatusline()
- if g:NERDTreeStatusline != -1
- let &l:statusline = g:NERDTreeStatusline
- endif
-endfunction
-"FUNCTION: s:stripMarkupFromLine(line, removeLeadingSpaces){{{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, ' \[RO\]', "","")
-
- "strip off any bookmark flags
- let line = substitute (line, ' {[^}]*}', "","")
-
- "strip off any executable flags
- let line = substitute (line, '*\ze\($\| \)', "","")
-
- 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()
- if !&hidden
- call s:renderView()
- endif
- call s:restoreScreenState()
- else
- call s:closeTree()
- endif
- else
- call s:initNerdTree(a:dir)
- endif
-endfunction
-"SECTION: Interface bindings {{{1
-"============================================================
-"FUNCTION: s:activateNode(forceKeepWindowOpen) {{{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.
-"
-"args:
-"forceKeepWindowOpen - dont close the window even if NERDTreeQuitOnOpen is set
-function! s:activateNode(forceKeepWindowOpen)
- if getline(".") ==# s:tree_up_dir_line
- return s:upDir(0)
- endif
-
- let treenode = s:TreeFileNode.GetSelected()
- if treenode != {}
- call treenode.activate(a:forceKeepWindowOpen)
- else
- let bookmark = s:Bookmark.GetSelected()
- if !empty(bookmark)
- call bookmark.activate()
- endif
- 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(0)<cr>
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapActivateNode . " :call <SID>activateNode(0)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenSplit ." :call <SID>openEntrySplit(0,0)<cr>"
- exec "nnoremap <silent> <buffer> <cr> :call <SID>activateNode(0)<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:NERDTreeMapOpenVSplit ." :call <SID>openEntrySplit(1,0)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreviewVSplit ." :call <SID>previewNode(2)<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 ." :call <SID>closeTreeWindow()<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:NERDTreeMapToggleZoom ." :call <SID>toggleZoom()<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:NERDTreeMapToggleBookmarks ." :call <SID>toggleShowBookmarks()<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:NERDTreeMapMenu ." :call <SID>showMenu()<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>openInNewTab(0)<cr>"
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTabSilent ." :call <SID>openInNewTab(1)<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenExpl ." :call <SID>openExplorer()<cr>"
-
- exec "nnoremap <silent> <buffer> ". g:NERDTreeMapDeleteBookmark ." :call <SID>deleteBookmark()<cr>"
-
- "bind all the user custom maps
- call s:KeyMap.BindAll()
-
- command! -buffer -nargs=? Bookmark :call <SID>bookmarkNode('<args>')
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=1 RevealBookmark :call <SID>revealBookmark('<args>')
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=1 OpenBookmark :call <SID>openBookmark('<args>')
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=* ClearBookmarks call <SID>clearBookmarks('<args>')
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=+ BookmarkToRoot call s:Bookmark.ToRoot('<args>')
- command! -buffer -nargs=0 ClearAllBookmarks call s:Bookmark.ClearAll() <bar> call <SID>renderView()
- command! -buffer -nargs=0 ReadBookmarks call s:Bookmark.CacheBookmarks(0) <bar> call <SID>renderView()
- command! -buffer -nargs=0 WriteBookmarks call s:Bookmark.Write()
-endfunction
-
-" FUNCTION: s:bookmarkNode(name) {{{2
-" Associate the current node with the given name
-function! s:bookmarkNode(...)
- let currentNode = s:TreeFileNode.GetSelected()
- if currentNode != {}
- let name = a:1
- if empty(name)
- let name = currentNode.path.getLastPathComponent(0)
- endif
- try
- call currentNode.bookmark(name)
- call s:renderView()
- catch /^NERDTree.IllegalBookmarkNameError/
- call s:echo("bookmark names must not contain spaces")
- endtry
- else
- call s:echo("select a node first")
- endif
-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:TreeFileNode.GetSelected()
- if currentNode != {}
- let startToCur = strpart(getline(line(".")), 0, col("."))
-
- if currentNode.path.isDirectory
- if startToCur =~# s:tree_markup_reg . '$' && startToCur =~# '[+~▾▸]$'
- call s:activateNode(0)
- return
- endif
- endif
-
- if (g:NERDTreeMouseMode ==# 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode ==# 3
- let char = strpart(startToCur, strlen(startToCur)-1, 1)
- if char !~# s:tree_markup_reg
- call s:activateNode(0)
- return
- endif
- endif
- endif
-endfunction
-
-" FUNCTION: s:chCwd() {{{2
-function! s:chCwd()
- let treenode = s:TreeFileNode.GetSelected()
- if treenode ==# {}
- call s:echo("Select a node first")
- return
- endif
-
- try
- call treenode.path.changeToDir()
- catch /^NERDTree.PathChangeError/
- 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:TreeFileNode.GetSelected()
- if treenode ==# {}
- call s:echo("Select a node first")
- return
- endif
-
- call treenode.makeRoot()
- call s:renderView()
- call b:NERDTreeRoot.putCursorHere(0, 0)
-endfunction
-
-" FUNCTION: s:clearBookmarks(bookmarks) {{{2
-function! s:clearBookmarks(bookmarks)
- if a:bookmarks ==# ''
- let currentNode = s:TreeFileNode.GetSelected()
- if currentNode != {}
- call currentNode.clearBoomarks()
- endif
- else
- for name in split(a:bookmarks, ' ')
- let bookmark = s:Bookmark.BookmarkFor(name)
- call bookmark.delete()
- endfor
- endif
- call s:renderView()
-endfunction
-" FUNCTION: s:closeChildren() {{{2
-" closes all childnodes of the current node
-function! s:closeChildren()
- let currentNode = s:TreeDirNode.GetSelected()
- if currentNode ==# {}
- call s:echo("Select a node first")
- return
- endif
-
- call currentNode.closeChildren()
- call s:renderView()
- call currentNode.putCursorHere(0, 0)
-endfunction
-" FUNCTION: s:closeCurrentDir() {{{2
-" closes the parent dir of the current node
-function! s:closeCurrentDir()
- let treenode = s:TreeFileNode.GetSelected()
- if treenode ==# {}
- call s:echo("Select a node first")
- return
- endif
-
- let parent = treenode.parent
- if parent ==# {} || parent.isRoot()
- call s:echo("cannot close tree root")
- else
- call treenode.parent.close()
- call s:renderView()
- call treenode.parent.putCursorHere(0, 0)
- endif
-endfunction
-" FUNCTION: s:closeTreeWindow() {{{2
-" close the tree window
-function! s:closeTreeWindow()
- if b:NERDTreeType ==# "secondary" && b:NERDTreePreviousBuf != -1
- exec "buffer " . b:NERDTreePreviousBuf
- else
- if winnr("$") > 1
- call s:closeTree()
- else
- call s:echo("Cannot close last window")
- endif
- endif
-endfunction
-" FUNCTION: s:deleteBookmark() {{{2
-" if the cursor is on a bookmark, prompt to delete
-function! s:deleteBookmark()
- let bookmark = s:Bookmark.GetSelected()
- if bookmark ==# {}
- call s:echo("Put the cursor on a bookmark")
- return
- endif
-
- echo "Are you sure you wish to delete the bookmark:\n\"" . bookmark.name . "\" (yN):"
-
- if nr2char(getchar()) ==# 'y'
- try
- call bookmark.delete()
- call s:renderView()
- redraw
- catch /^NERDTree/
- call s:echoWarning("Could not remove bookmark")
- endtry
- else
- call s:echo("delete aborted" )
- endif
-
-endfunction
-
-" FUNCTION: s:displayHelp() {{{2
-" toggles the help display
-function! s:displayHelp()
- let b:treeShowHelp = b:treeShowHelp ? 0 : 1
- call s:renderView()
- call s:centerView()
-endfunction
-
-" FUNCTION: s:handleMiddleMouse() {{{2
-function! s:handleMiddleMouse()
- let curNode = s:TreeFileNode.GetSelected()
- 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(0,0)
- endif
-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:TreeFileNode.GetSelected()
- if !empty(currentNode)
- if !empty(currentNode.parent)
- call currentNode.parent.putCursorHere(1, 0)
- 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 b:NERDTreeRoot.putCursorHere(1, 0)
- 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:TreeFileNode.GetSelected()
- if !empty(currentNode)
- let sibling = currentNode.findSibling(a:forward)
-
- if !empty(sibling)
- call sibling.putCursorHere(1, 0)
- call s:centerView()
- endif
- else
- call s:echo("put the cursor on a node first")
- endif
-endfunction
-
-" FUNCTION: s:openBookmark(name) {{{2
-" put the cursor on the given bookmark and, if its a file, open it
-function! s:openBookmark(name)
- try
- let targetNode = s:Bookmark.GetNodeForName(a:name, 0)
- call targetNode.putCursorHere(0, 1)
- redraw!
- catch /^NERDTree.BookmarkedNodeNotFoundError/
- call s:echo("note - target node is not cached")
- let bookmark = s:Bookmark.BookmarkFor(a:name)
- let targetNode = s:TreeFileNode.New(bookmark.path)
- endtry
- if targetNode.path.isDirectory
- call targetNode.openExplorer()
- else
- call targetNode.open()
- endif
-endfunction
-" FUNCTION: s:openEntrySplit(vertical, forceKeepWindowOpen) {{{2
-"Opens the currently selected file from the explorer in a
-"new window
-"
-"args:
-"forceKeepWindowOpen - dont close the window even if NERDTreeQuitOnOpen is set
-function! s:openEntrySplit(vertical, forceKeepWindowOpen)
- let treenode = s:TreeFileNode.GetSelected()
- if treenode != {}
- if a:vertical
- call treenode.openVSplit()
- else
- call treenode.openSplit()
- endif
- if !a:forceKeepWindowOpen
- call s:closeTreeIfQuitOnOpen()
- endif
- else
- call s:echo("select a node first")
- endif
-endfunction
-
-" FUNCTION: s:openExplorer() {{{2
-function! s:openExplorer()
- let treenode = s:TreeDirNode.GetSelected()
- if treenode != {}
- call treenode.openExplorer()
- else
- call s:echo("select a node first")
- endif
-endfunction
-
-" FUNCTION: s:openInNewTab(stayCurrentTab) {{{2
-" Opens the selected node or bookmark 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:openInNewTab(stayCurrentTab)
- let target = s:TreeFileNode.GetSelected()
- if target == {}
- let target = s:Bookmark.GetSelected()
- endif
-
- if target != {}
- call target.openInNewTab({'stayInCurrentTab': a:stayCurrentTab})
- endif
-endfunction
-
-" FUNCTION: s:openNodeRecursively() {{{2
-function! s:openNodeRecursively()
- let treenode = s:TreeFileNode.GetSelected()
- 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
-"Args:
-" openNewWin: if 0, use the previous window, if 1 open in new split, if 2
-" open in a vsplit
-function! s:previewNode(openNewWin)
- let currentBuf = bufnr("")
- if a:openNewWin > 0
- call s:openEntrySplit(a:openNewWin ==# 2,1)
- else
- call s:activateNode(1)
- end
- call s:exec(bufwinnr(currentBuf) . "wincmd w")
-endfunction
-
-" FUNCTION: s:revealBookmark(name) {{{2
-" put the cursor on the node associate with the given name
-function! s:revealBookmark(name)
- try
- let targetNode = s:Bookmark.GetNodeForName(a:name, 0)
- call targetNode.putCursorHere(0, 1)
- catch /^NERDTree.BookmarkNotFoundError/
- call s:echo("Bookmark isnt cached under the current root")
- endtry
-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 b: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:TreeDirNode.GetSelected()
- 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:showMenu() {{{2
-function! s:showMenu()
- let curNode = s:TreeFileNode.GetSelected()
- if curNode ==# {}
- call s:echo("Put the cursor on a node first" )
- return
- endif
-
- let mc = s:MenuController.New(s:MenuItem.AllEnabled())
- call mc.showMenu()
-endfunction
-
-" FUNCTION: s:toggleIgnoreFilter() {{{2
-" toggles the use of the NERDTreeIgnore option
-function! s:toggleIgnoreFilter()
- let b:NERDTreeIgnoreEnabled = !b:NERDTreeIgnoreEnabled
- call s:renderViewSavingPosition()
- call s:centerView()
-endfunction
-
-" FUNCTION: s:toggleShowBookmarks() {{{2
-" toggles the display of bookmarks
-function! s:toggleShowBookmarks()
- let b:NERDTreeShowBookmarks = !b:NERDTreeShowBookmarks
- if b:NERDTreeShowBookmarks
- call s:renderView()
- call s:putCursorOnBookmarkTable()
- else
- call s:renderViewSavingPosition()
- endif
- call s:centerView()
-endfunction
-" FUNCTION: s:toggleShowFiles() {{{2
-" toggles the display of hidden files
-function! s:toggleShowFiles()
- let b:NERDTreeShowFiles = !b:NERDTreeShowFiles
- call s:renderViewSavingPosition()
- call s:centerView()
-endfunction
-
-" FUNCTION: s:toggleShowHidden() {{{2
-" toggles the display of hidden files
-function! s:toggleShowHidden()
- let b:NERDTreeShowHidden = !b:NERDTreeShowHidden
- call s:renderViewSavingPosition()
- call s:centerView()
-endfunction
-
-" FUNCTION: s:toggleZoom() {{2
-" zoom (maximize/minimize) the NERDTree window
-function! s:toggleZoom()
- if exists("b:NERDTreeZoomed") && b:NERDTreeZoomed
- let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
- exec "silent vertical resize ". size
- let b:NERDTreeZoomed = 0
- else
- exec "vertical resize"
- let b:NERDTreeZoomed = 1
- endif
-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 = b:NERDTreeRoot.path.str({'format': 'UI'})
- if cwd ==# "/" || cwd =~# '^[^/]..$'
- call s:echo("already at top dir")
- else
- if !a:keepState
- call b:NERDTreeRoot.close()
- endif
-
- let oldRoot = b:NERDTreeRoot
-
- if empty(b:NERDTreeRoot.parent)
- let path = b:NERDTreeRoot.path.getParent()
- let newRoot = s:TreeDirNode.New(path)
- call newRoot.open()
- call newRoot.transplantChild(b:NERDTreeRoot)
- let b:NERDTreeRoot = newRoot
- else
- let b:NERDTreeRoot = b:NERDTreeRoot.parent
- endif
-
- if g:NERDTreeChDirMode ==# 2
- call b:NERDTreeRoot.path.changeToDir()
- endif
-
- call s:renderView()
- call oldRoot.putCursorHere(0, 0)
- endif
-endfunction
-
-
-"reset &cpo back to users setting
-let &cpo = s:old_cpo
-
-" vim: set sw=4 sts=4 et fdm=marker:
+++ /dev/null
-"here is a more exotic version of my original Kwbd script
-"delete the buffer; keep windows; create a scratch buffer if no buffers left
-function s:Kwbd(kwbdStage)
- if(a:kwbdStage == 1)
- if(!buflisted(winbufnr(0)))
- bd!
- return
- endif
- let s:kwbdBufNum = bufnr("%")
- let s:kwbdWinNum = winnr()
- windo call s:Kwbd(2)
- execute s:kwbdWinNum . 'wincmd w'
- let s:buflistedLeft = 0
- let s:bufFinalJump = 0
- let l:nBufs = bufnr("$")
- let l:i = 1
- while(l:i <= l:nBufs)
- if(l:i != s:kwbdBufNum)
- if(buflisted(l:i))
- let s:buflistedLeft = s:buflistedLeft + 1
- else
- if(bufexists(l:i) && !strlen(bufname(l:i)) && !s:bufFinalJump)
- let s:bufFinalJump = l:i
- endif
- endif
- endif
- let l:i = l:i + 1
- endwhile
- if(!s:buflistedLeft)
- if(s:bufFinalJump)
- windo if(buflisted(winbufnr(0))) | execute "b! " . s:bufFinalJump | endif
- else
- enew
- let l:newBuf = bufnr("%")
- windo if(buflisted(winbufnr(0))) | execute "b! " . l:newBuf | endif
- endif
- execute s:kwbdWinNum . 'wincmd w'
- endif
- if(buflisted(s:kwbdBufNum) || s:kwbdBufNum == bufnr("%"))
- execute "bd! " . s:kwbdBufNum
- endif
- if(!s:buflistedLeft)
- set buflisted
- set bufhidden=delete
- set buftype=nofile
- setlocal noswapfile
- endif
- else
- if(bufnr("%") == s:kwbdBufNum)
- let prevbufvar = bufnr("#")
- if(prevbufvar > 0 && buflisted(prevbufvar) && prevbufvar != s:kwbdBufNum)
- b #
- else
- bn
- endif
- endif
- endif
-endfunction
-
-command! Kwbd call <SID>Kwbd(1)
-nnoremap <silent> <Plug>Kwbd :<C-u>Kwbd<CR>
-
-" Create a mapping (e.g. in your .vimrc) like this:
-"nmap <C-W>! <Plug>Kwbd
+++ /dev/null
-" Mini Buffer Explorer <minibufexpl.vim>
-"
-" HINT: Type zR if you don't know how to use folds
-"
-" Script Info and Documentation {{{
-"=============================================================================
-" Copyright: Copyright (C) 2002 & 2003 Bindu Wavell
-" Permission is hereby granted to use and distribute this code,
-" with or without modifications, provided that this copyright
-" notice is copied with it. Like anything else that's free,
-" minibufexplorer.vim is provided *as is* and comes with no
-" warranty of any kind, either expressed or implied. In no
-" event will the copyright holder be liable for any damamges
-" resulting from the use of this software.
-"
-" Name Of File: minibufexpl.vim
-" Description: Mini Buffer Explorer Vim Plugin
-" Maintainer: Bindu Wavell <bindu@wavell.net>
-" URL: http://vim.sourceforge.net/scripts/script.php?script_id=159
-" Last Change: Sunday, June 21, 2004
-" Version: 6.3.2
-" Derived from Jeff Lanzarotta's bufexplorer.vim version 6.0.7
-" Jeff can be reached at (jefflanzarotta@yahoo.com) and the
-" original plugin can be found at:
-" http://lanzarotta.tripod.com/vim/plugin/6/bufexplorer.vim.zip
-"
-" Usage: Normally, this file should reside in the plugins
-" directory and be automatically sourced. If not, you must
-" manually source this file using ':source minibufexplorer.vim'.
-"
-" You may use the default keymappings of
-"
-" <Leader>mbe - Opens MiniBufExplorer
-"
-" or you may want to add something like the following
-" key mapping to your _vimrc/.vimrc file.
-"
-" map <Leader>b :MiniBufExplorer<cr>
-"
-" However, in most cases you won't need any key-bindings at all.
-"
-" <Leader> is usually backslash so type "\mbe" (quickly) to open
-" the -MiniBufExplorer- window.
-"
-" Other keymappings include: <Leader>mbc to close the Explorer
-" window, <Leader>mbu to force the Explorer to Update and
-" <Leader>mbt to toggle the Explorer window; it will open if
-" closed or close if open. Each of these key bindings can be
-" overridden (see the notes on <Leader>mbe above.)
-"
-" You can map these additional commands as follows:
-"
-" map <Leader>c :CMiniBufExplorer<cr>
-" map <Leader>u :UMiniBufExplorer<cr>
-" map <Leader>t :TMiniBufExplorer<cr>
-"
-" NOTE: you can change the key binding used in these mappings
-" so that they fit with your configuration of vim.
-"
-" You can also call each of these features by typing the
-" following in command mode:
-"
-" :MiniBufExplorer " Open and/or goto Explorer
-" :CMiniBufExplorer " Close the Explorer if it's open
-" :UMiniBufExplorer " Update Explorer without navigating
-" :TMiniBufExplorer " Toggle the Explorer window open and
-" closed.
-"
-" To control where the new split window goes relative to the
-" current window, use the setting:
-"
-" let g:miniBufExplSplitBelow=0 " Put new window above
-" " current or on the
-" " left for vertical split
-" let g:miniBufExplSplitBelow=1 " Put new window below
-" " current or on the
-" " right for vertical split
-"
-" The default for this is read from the &splitbelow VIM option.
-"
-" By default we are now (as of 6.0.2) forcing the -MiniBufExplorer-
-" window to open up at the edge of the screen. You can turn this
-" off by setting the following variable in your .vimrc:
-"
-" let g:miniBufExplSplitToEdge = 0
-"
-" If you would like a vertical explorer you can assign the column
-" width (in characters) you want for your explorer window with the
-" following .vimrc variable (this was introduced in 6.3.0):
-"
-" let g:miniBufExplVSplit = 20 " column width in chars
-"
-" IN HORIZONTAL MODE:
-" It is now (as of 6.1.1) possible to set a maximum height for
-" the -MiniBufExplorer- window. You can set the max height by
-" letting the following variable in your .vimrc:
-"
-" let g:miniBufExplMaxSize = <max lines: defualt 0>
-"
-" setting this to 0 will mean the window gets as big as
-" needed to fit all your buffers.
-"
-" NOTE: This was g:miniBufExplMaxHeight before 6.3.0; the old
-" setting is backwards compatible if you don't use MaxSize.
-"
-" As of 6.2.2 it is possible to set a minimum height for the
-" -MiniBufExplorer- window. You can set the min height by
-" letting the following variable in your .vimrc:
-"
-" let g:miniBufExplMinSize = <min height: default 1>
-"
-" NOTE: This was g:miniBufExplMinHeight before 6.3.0; the old
-" setting is backwards compatible if you don't use MinSize.
-"
-" IN VERTICAL MODE: (as of 6.3.0)
-" By default the vertical explorer has a fixed width. If you put:
-"
-" let g:miniBufExplMaxSize = <max width: default 0>
-"
-" into your .vimrc then MBE will attempt to set the width of the
-" MBE window to be as wide as your widest tab. The width will not
-" exceed MaxSize even if you have wider tabs.
-"
-" Accepting the default value of 0 for this will give you a fixed
-" width MBE window.
-"
-" You can specify a MinSize for the vertical explorer window by
-" putting the following in your .vimrc:
-"
-" let g:miniBufExplMinSize = <min width: default 1>
-"
-" This will have no effect unless you also specivy MaxSize.
-"
-" By default we are now (as of 6.0.1) turning on the MoreThanOne
-" option. This stops the -MiniBufExplorer- from opening
-" automatically until more than one eligible buffer is available.
-" You can turn this feature off by setting the following variable
-" in your .vimrc:
-"
-" let g:miniBufExplorerMoreThanOne=1
-"
-" (The following enhancement is as of 6.2.2)
-" Setting this to 0 will cause the MBE window to be loaded even
-" if no buffers are available. Setting it to 1 causes the MBE
-" window to be loaded as soon as an eligible buffer is read. You
-" can also set it to larger numbers. So if you set it to 4 for
-" example the MBE window wouldn't auto-open until 4 eligibles
-" buffers had been loaded. This is nice for folks that don't
-" want an MBE window unless they are editing more than two or
-" three buffers.
-"
-" To enable the optional mapping of Control + Vim Direction Keys
-" [hjkl] to window movement commands, you can put the following into
-" your .vimrc:
-"
-" let g:miniBufExplMapWindowNavVim = 1
-"
-" To enable the optional mapping of Control + Arrow Keys to window
-" movement commands, you can put the following into your .vimrc:
-"
-" let g:miniBufExplMapWindowNavArrows = 1
-"
-" To enable the optional mapping of <C-TAB> and <C-S-TAB> to a
-" function that will bring up the next or previous buffer in the
-" current window, you can put the following into your .vimrc:
-"
-" let g:miniBufExplMapCTabSwitchBufs = 1
-"
-" To enable the optional mapping of <C-TAB> and <C-S-TAB> to mappings
-" that will move to the next and previous (respectively) window, you
-" can put the following into your .vimrc:
-"
-" let g:miniBufExplMapCTabSwitchWindows = 1
-"
-"
-" NOTE: If you set the ...TabSwitchBufs AND ...TabSwitchWindows,
-" ...TabSwitchBufs will be enabled and ...TabSwitchWindows
-" will not.
-"
-" As of MBE 6.3.0, you can put the following into your .vimrc:
-"
-" let g:miniBufExplUseSingleClick = 1
-"
-" If you would like to single click on tabs rather than double
-" clicking on them to goto the selected buffer.
-"
-" NOTE: If you use the single click option in taglist.vim you may
-" need to get an updated version that includes a patch I
-" provided to allow both explorers to provide single click
-" buffer selection.
-"
-" It is possible to customize the the highlighting for the tabs in
-" the MBE by configuring the following highlighting groups:
-"
-" MBENormal - for buffers that have NOT CHANGED and
-" are NOT VISIBLE.
-" MBEChanged - for buffers that HAVE CHANGED and are
-" NOT VISIBLE
-" MBEVisibleNormal - buffers that have NOT CHANGED and are
-" VISIBLE
-" MBEVisibleChanged - buffers that have CHANGED and are VISIBLE
-"
-" You can either link to an existing highlighting group by
-" adding a command like:
-"
-" hi link MBEVisibleChanged Error
-"
-" to your .vimrc or you can specify exact foreground and background
-" colors using the following syntax:
-"
-" hi MBEChanged guibg=darkblue ctermbg=darkblue termbg=white
-"
-" NOTE: If you set a colorscheme in your .vimrc you should do it
-" BEFORE updating the MBE highlighting groups.
-"
-" If you use other explorers like TagList you can (As of 6.2.8) put:
-"
-" let g:miniBufExplModSelTarget = 1
-"
-" into your .vimrc in order to force MBE to try to place selected
-" buffers into a window that does not have a nonmodifiable buffer.
-" The upshot of this should be that if you go into MBE and select
-" a buffer, the buffer should not show up in a window that is
-" hosting an explorer.
-"
-" There is a VIM bug that can cause buffers to show up without
-" their highlighting. The following setting will cause MBE to
-" try and turn highlighting back on (introduced in 6.3.1):
-"
-" let g:miniBufExplForceSyntaxEnable = 1
-"
-" MBE has had a basic debugging capability for quite some time.
-" However, it has not been very friendly in the past. As of 6.0.8,
-" you can put one of each of the following into your .vimrc:
-"
-" let g:miniBufExplorerDebugLevel = 0 " MBE serious errors output
-" let g:miniBufExplorerDebugLevel = 4 " MBE all errors output
-" let g:miniBufExplorerDebugLevel = 10 " MBE reports everything
-"
-" You can also set a DebugMode to cause output to be target as
-" follows (default is mode 3):
-"
-" let g:miniBufExplorerDebugMode = 0 " Errors will show up in
-" " a vim window
-" let g:miniBufExplorerDebugMode = 1 " Uses VIM's echo function
-" " to display on the screen
-" let g:miniBufExplorerDebugMode = 2 " Writes to a file
-" " MiniBufExplorer.DBG
-" let g:miniBufExplorerDebugMode = 3 " Store output in global:
-" " g:miniBufExplorerDebugOutput
-"
-" Or if you are able to start VIM, you might just perform these
-" at a command prompt right before you do the operation that is
-" failing.
-"
-" History: Moved to end of file
-"
-" Known Issues: When debugging is turned on and set to output to a window, there
-" are some cases where the window is opened more than once, there
-" are other cases where an old debug window can be lost.
-"
-" Several MBE commands can break the window history so <C-W>[pnw]
-" might not take you to the expected window.
-"
-" Todo: Add the ability to specify a regexp for eligible buffers
-" allowing the ability to filter out certain buffers that
-" you don't want to control from MBE
-"
-"=============================================================================
-" }}}
-
-" Startup Check
-"
-" Has this plugin already been loaded? {{{
-"
-if exists('loaded_minibufexplorer')
- finish
-endif
-let loaded_minibufexplorer = 1
-" }}}
-
-" Mappings and Commands
-"
-" MBE Keyboard Mappings {{{
-" If we don't already have keyboard mappings for MBE then create them
-"
-if !hasmapto('<Plug>MiniBufExplorer')
- map <unique> <Leader>mbe <Plug>MiniBufExplorer
-endif
-if !hasmapto('<Plug>CMiniBufExplorer')
- map <unique> <Leader>mbc <Plug>CMiniBufExplorer
-endif
-if !hasmapto('<Plug>UMiniBufExplorer')
- map <unique> <Leader>mbu <Plug>UMiniBufExplorer
-endif
-if !hasmapto('<Plug>TMiniBufExplorer')
- map <unique> <Leader>mbt <Plug>TMiniBufExplorer
-endif
-
-" }}}
-" MBE <Script> internal map {{{
-"
-noremap <unique> <script> <Plug>MiniBufExplorer :call <SID>StartExplorer(1, -1)<CR>:<BS>
-noremap <unique> <script> <Plug>CMiniBufExplorer :call <SID>StopExplorer(1)<CR>:<BS>
-noremap <unique> <script> <Plug>UMiniBufExplorer :call <SID>AutoUpdate(-1)<CR>:<BS>
-noremap <unique> <script> <Plug>TMiniBufExplorer :call <SID>ToggleExplorer()<CR>:<BS>
-
-" }}}
-" MBE commands {{{
-"
-if !exists(':MiniBufExplorer')
- command! MiniBufExplorer call <SID>StartExplorer(1, -1)
-endif
-if !exists(':CMiniBufExplorer')
- command! CMiniBufExplorer call <SID>StopExplorer(1)
-endif
-if !exists(':UMiniBufExplorer')
- command! UMiniBufExplorer call <SID>AutoUpdate(-1)
-endif
-if !exists(':TMiniBufExplorer')
- command! TMiniBufExplorer call <SID>ToggleExplorer()
-endif
-if !exists(':MBEbn')
- command! MBEbn call <SID>CycleBuffer(1)
-endif
-if !exists(':MBEbp')
- command! MBEbp call <SID>CycleBuffer(0)
-endif " }}}
-
-" Global Configuration Variables
-"
-" Debug Level {{{
-"
-" 0 = no logging
-" 1=5 = errors ; 1 is the most important
-" 5-9 = info ; 5 is the most important
-" 10 = Entry/Exit
-if !exists('g:miniBufExplorerDebugLevel')
- let g:miniBufExplorerDebugLevel = 0
-endif
-
-" }}}
-" Debug Mode {{{
-"
-" 0 = debug to a window
-" 1 = use vim's echo facility
-" 2 = write to a file named MiniBufExplorer.DBG
-" in the directory where vim was started
-" THIS IS VERY SLOW
-" 3 = Write into g:miniBufExplorerDebugOutput
-" global variable [This is the default]
-if !exists('g:miniBufExplorerDebugMode')
- let g:miniBufExplorerDebugMode = 3
-endif
-
-" }}}
-" Allow auto update? {{{
-"
-" We start out with this off for startup, but once vim is running we
-" turn this on.
-if !exists('g:miniBufExplorerAutoUpdate')
- let g:miniBufExplorerAutoUpdate = 0
-endif
-
-" }}}
-" MoreThanOne? {{{
-" Display Mini Buf Explorer when there are 'More Than One' eligible buffers
-"
-if !exists('g:miniBufExplorerMoreThanOne')
- let g:miniBufExplorerMoreThanOne = 2
-endif
-
-" }}}
-" Split below/above/left/right? {{{
-" When opening a new -MiniBufExplorer- window, split the new windows below or
-" above the current window? 1 = below, 0 = above.
-"
-if !exists('g:miniBufExplSplitBelow')
- let g:miniBufExplSplitBelow = &splitbelow
-endif
-
-" }}}
-" Split to edge? {{{
-" When opening a new -MiniBufExplorer- window, split the new windows to the
-" full edge? 1 = yes, 0 = no.
-"
-if !exists('g:miniBufExplSplitToEdge')
- let g:miniBufExplSplitToEdge = 1
-endif
-
-" }}}
-" MaxHeight (depreciated) {{{
-" When sizing the -MiniBufExplorer- window, assign a maximum window height.
-" 0 = size to fit all buffers, otherwise the value is number of lines for
-" buffer. [Depreciated use g:miniBufExplMaxSize]
-"
-if !exists('g:miniBufExplMaxHeight')
- let g:miniBufExplMaxHeight = 0
-endif
-
-" }}}
-" MaxSize {{{
-" Same as MaxHeight but also works for vertical splits if specified with a
-" vertical split then vertical resizing will be performed. If left at 0
-" then the number of columns in g:miniBufExplVSplit will be used as a
-" static window width.
-if !exists('g:miniBufExplMaxSize')
- let g:miniBufExplMaxSize = g:miniBufExplMaxHeight
-endif
-
-" }}}
-" MinHeight (depreciated) {{{
-" When sizing the -MiniBufExplorer- window, assign a minumum window height.
-" the value is minimum number of lines for buffer. Setting this to zero can
-" cause strange height behavior. The default value is 1 [Depreciated use
-" g:miniBufExplMinSize]
-"
-if !exists('g:miniBufExplMinHeight')
- let g:miniBufExplMinHeight = 1
-endif
-
-" }}}
-" MinSize {{{
-" Same as MinHeight but also works for vertical splits. For vertical splits,
-" this is ignored unless g:miniBufExplMax(Size|Height) are specified.
-if !exists('g:miniBufExplMinSize')
- let g:miniBufExplMinSize = g:miniBufExplMinHeight
-endif
-
-" }}}
-" Horizontal or Vertical explorer? {{{
-" For folks that like vertical explorers, I'm caving in and providing for
-" veritcal splits. If this is set to 0 then the current horizontal
-" splitting logic will be run. If however you want a vertical split,
-" assign the width (in characters) you wish to assign to the MBE window.
-"
-if !exists('g:miniBufExplVSplit')
- let g:miniBufExplVSplit = 0
-endif
-
-" }}}
-" TabWrap? {{{
-" By default line wrap is used (possibly breaking a tab name between two
-" lines.) Turning this option on (setting it to 1) can take more screen
-" space, but will make sure that each tab is on one and only one line.
-"
-if !exists('g:miniBufExplTabWrap')
- let g:miniBufExplTabWrap = 0
-endif
-
-" }}}
-" Extended window navigation commands? {{{
-" Global flag to turn extended window navigation commands on or off
-" enabled = 1, dissabled = 0
-"
-if !exists('g:miniBufExplMapWindowNav')
- " This is for backwards compatibility and may be removed in a
- " later release, please use the ...NavVim and/or ...NavArrows
- " settings.
- let g:miniBufExplMapWindowNav = 0
-endif
-if !exists('g:miniBufExplMapWindowNavVim')
- let g:miniBufExplMapWindowNavVim = 0
-endif
-if !exists('g:miniBufExplMapWindowNavArrows')
- let g:miniBufExplMapWindowNavArrows = 0
-endif
-if !exists('g:miniBufExplMapCTabSwitchBufs')
- let g:miniBufExplMapCTabSwitchBufs = 0
-endif
-" Notice: that if CTabSwitchBufs is turned on then
-" we turn off CTabSwitchWindows.
-if g:miniBufExplMapCTabSwitchBufs == 1 || !exists('g:miniBufExplMapCTabSwitchWindows')
- let g:miniBufExplMapCTabSwitchWindows = 0
-endif
-
-"
-" If we have enabled control + vim direction key remapping
-" then perform the remapping
-"
-" Notice: I left g:miniBufExplMapWindowNav in for backward
-" compatibility. Eventually this mapping will be removed so
-" please use the newer g:miniBufExplMapWindowNavVim setting.
-if g:miniBufExplMapWindowNavVim || g:miniBufExplMapWindowNav
- noremap <C-J> <C-W>j
- noremap <C-K> <C-W>k
- noremap <C-H> <C-W>h
- noremap <C-L> <C-W>l
-endif
-
-"
-" If we have enabled control + arrow key remapping
-" then perform the remapping
-"
-if g:miniBufExplMapWindowNavArrows
- noremap <C-Down> <C-W>j
- noremap <C-Up> <C-W>k
- noremap <C-Left> <C-W>h
- noremap <C-Right> <C-W>l
-endif
-
-" If we have enabled <C-TAB> and <C-S-TAB> to switch buffers
-" in the current window then perform the remapping
-"
-if g:miniBufExplMapCTabSwitchBufs
- noremap <C-TAB> :call <SID>CycleBuffer(1)<CR>:<BS>
- noremap <C-S-TAB> :call <SID>CycleBuffer(0)<CR>:<BS>
-endif
-
-"
-" If we have enabled <C-TAB> and <C-S-TAB> to switch windows
-" then perform the remapping
-"
-if g:miniBufExplMapCTabSwitchWindows
- noremap <C-TAB> <C-W>w
- noremap <C-S-TAB> <C-W>W
-endif
-
-" }}}
-" Modifiable Select Target {{{
-"
-if !exists('g:miniBufExplModSelTarget')
- let g:miniBufExplModSelTarget = 0
-endif
-
-"}}}
-" Force Syntax Enable {{{
-"
-if !exists('g:miniBufExplForceSyntaxEnable')
- let g:miniBufExplForceSyntaxEnable = 0
-endif
-
-" }}}
-" Single/Double Click? {{{
-" flag that can be set to 1 in a users .vimrc to allow
-" single click switching of tabs. By default we use
-" double click for tab selection.
-"
-if !exists('g:miniBufExplUseSingleClick')
- let g:miniBufExplUseSingleClick = 0
-endif
-
-"
-" attempt to perform single click mapping, it would be much
-" nicer if we could nnoremap <buffer> ... however vim does
-" not fire the <buffer> <leftmouse> when you use the mouse
-" to enter a buffer.
-"
-if g:miniBufExplUseSingleClick == 1
- let s:clickmap = ':if bufname("%") == "-MiniBufExplorer-" <bar> call <SID>MBEClick() <bar> endif <CR>'
- if maparg('<LEFTMOUSE>', 'n') == ''
- " no mapping for leftmouse
- exec ':nnoremap <silent> <LEFTMOUSE> <LEFTMOUSE>' . s:clickmap
- else
- " we have a mapping
- let g:miniBufExplDoneClickSave = 1
- let s:m = ':nnoremap <silent> <LEFTMOUSE> <LEFTMOUSE>'
- let s:m = s:m . substitute(substitute(maparg('<LEFTMOUSE>', 'n'), '|', '<bar>', 'g'), '\c^<LEFTMOUSE>', '', '')
- let s:m = s:m . s:clickmap
- exec s:m
- endif
-endif " }}}
-
-" Variables used internally
-"
-" Script/Global variables {{{
-" Global used to store the buffer list so we don't update the
-" UI unless the list has changed.
-if !exists('g:miniBufExplBufList')
- let g:miniBufExplBufList = ''
-endif
-
-" Variable used as a mutex so that we don't do lots
-" of AutoUpdates at the same time.
-if !exists('g:miniBufExplInAutoUpdate')
- let g:miniBufExplInAutoUpdate = 0
-endif
-
-" In debug mode 3 this variable will hold the debug output
-if !exists('g:miniBufExplorerDebugOutput')
- let g:miniBufExplorerDebugOutput = ''
-endif
-
-" In debug mode 3 this variable will hold the debug output
-if !exists('g:miniBufExplForceDisplay')
- let g:miniBufExplForceDisplay = 0
-endif
-
-" Variable used to pass maxTabWidth info between functions
-let s:maxTabWidth = 0
-
-" Variable used to count debug output lines
-let s:debugIndex = 0
-
-
-" }}}
-" Setup an autocommand group and some autocommands {{{
-" that keep our explorer updated automatically.
-"
-augroup MiniBufExplorer
-autocmd MiniBufExplorer BufDelete * call <SID>DEBUG('-=> BufDelete AutoCmd', 10) |call <SID>AutoUpdate(expand('<abuf>'))
-autocmd MiniBufExplorer BufEnter * call <SID>DEBUG('-=> BufEnter AutoCmd', 10) |call <SID>AutoUpdate(-1)
-autocmd MiniBufExplorer VimEnter * call <SID>DEBUG('-=> VimEnter AutoCmd', 10) |let g:miniBufExplorerAutoUpdate = 1 |call <SID>AutoUpdate(-1)
-" }}}
-
-" Functions
-"
-" StartExplorer - Sets up our explorer and causes it to be displayed {{{
-"
-function! <SID>StartExplorer(sticky, delBufNum)
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Entering StartExplorer()' ,10)
- call <SID>DEBUG('===========================',10)
-
- if a:sticky == 1
- let g:miniBufExplorerAutoUpdate = 1
- endif
-
- " Store the current buffer
- let l:curBuf = bufnr('%')
-
- " Prevent a report of our actions from showing up.
- let l:save_rep = &report
- let l:save_sc = &showcmd
- let &report = 10000
- set noshowcmd
-
- call <SID>FindCreateWindow('-MiniBufExplorer-', -1, 1, 1)
-
- " Make sure we are in our window
- if bufname('%') != '-MiniBufExplorer-'
- call <SID>DEBUG('StartExplorer called in invalid window',1)
- let &report = l:save_rep
- let &showcmd = l:save_sc
- return
- endif
-
- " !!! We may want to make the following optional -- Bindu
- " New windows don't cause all windows to be resized to equal sizes
- set noequalalways
- " !!! We may want to make the following optional -- Bindu
- " We don't want the mouse to change focus without a click
- set nomousefocus
-
- " If folks turn numbering and columns on by default we will turn
- " them off for the MBE window
- setlocal foldcolumn=0
- setlocal nonumber
-
- if has("syntax")
- syn clear
- syn match MBENormal '\[[^\]]*\]'
- syn match MBEChanged '\[[^\]]*\]+'
- syn match MBEVisibleNormal '\[[^\]]*\]\*+\='
- syn match MBEVisibleChanged '\[[^\]]*\]\*+'
-
- if !exists("g:did_minibufexplorer_syntax_inits")
- let g:did_minibufexplorer_syntax_inits = 1
- hi def link MBENormal Comment
- hi def link MBEChanged String
- hi def link MBEVisibleNormal Special
- hi def link MBEVisibleChanged Special
- endif
- endif
-
- " If you press return in the -MiniBufExplorer- then try
- " to open the selected buffer in the previous window.
- nnoremap <buffer> <CR> :call <SID>MBESelectBuffer()<CR>:<BS>
- " If you DoubleClick in the -MiniBufExplorer- then try
- " to open the selected buffer in the previous window.
- nnoremap <buffer> <2-LEFTMOUSE> :call <SID>MBEDoubleClick()<CR>:<BS>
- " If you press d in the -MiniBufExplorer- then try to
- " delete the selected buffer.
- nnoremap <buffer> d :call <SID>MBEDeleteBuffer()<CR>:<BS>
- " If you press w in the -MiniBufExplorer- then switch back
- " to the previous window.
- nnoremap <buffer> p :wincmd p<CR>:<BS>
- " The following allow us to use regular movement keys to
- " scroll in a wrapped single line buffer
- nnoremap <buffer> j gj
- nnoremap <buffer> k gk
- nnoremap <buffer> <down> gj
- nnoremap <buffer> <up> gk
- " The following allows for quicker moving between buffer
- " names in the [MBE] window it also saves the last-pattern
- " and restores it.
- nnoremap <buffer> <TAB> :call search('\[[0-9]*:[^\]]*\]')<CR>:<BS>
- nnoremap <buffer> <S-TAB> :call search('\[[0-9]*:[^\]]*\]','b')<CR>:<BS>
-
- call <SID>DisplayBuffers(a:delBufNum)
-
- if (l:curBuf != -1)
- call search('\['.l:curBuf.':'.expand('#'.l:curBuf.':t').'\]')
- else
- call <SID>DEBUG('No current buffer to search for',9)
- endif
-
- let &report = l:save_rep
- let &showcmd = l:save_sc
-
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Completed StartExplorer()' ,10)
- call <SID>DEBUG('===========================',10)
-
-endfunction
-
-" }}}
-" StopExplorer - Looks for our explorer and closes the window if it is open {{{
-"
-function! <SID>StopExplorer(sticky)
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Entering StopExplorer()' ,10)
- call <SID>DEBUG('===========================',10)
-
- if a:sticky == 1
- let g:miniBufExplorerAutoUpdate = 0
- endif
-
- let l:winNum = <SID>FindWindow('-MiniBufExplorer-', 1)
-
- if l:winNum != -1
- exec l:winNum.' wincmd w'
- silent! close
- wincmd p
- endif
-
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Completed StopExplorer()' ,10)
- call <SID>DEBUG('===========================',10)
-
-endfunction
-
-" }}}
-" ToggleExplorer - Looks for our explorer and opens/closes the window {{{
-"
-function! <SID>ToggleExplorer()
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Entering ToggleExplorer()' ,10)
- call <SID>DEBUG('===========================',10)
-
- let g:miniBufExplorerAutoUpdate = 0
-
- let l:winNum = <SID>FindWindow('-MiniBufExplorer-', 1)
-
- if l:winNum != -1
- call <SID>StopExplorer(1)
- else
- call <SID>StartExplorer(1, -1)
- wincmd p
- endif
-
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Completed ToggleExplorer()' ,10)
- call <SID>DEBUG('===========================',10)
-
-endfunction
-
-" }}}
-" FindWindow - Return the window number of a named buffer {{{
-" If none is found then returns -1.
-"
-function! <SID>FindWindow(bufName, doDebug)
- if a:doDebug
- call <SID>DEBUG('Entering FindWindow()',10)
- endif
-
- " Try to find an existing window that contains
- " our buffer.
- let l:bufNum = bufnr(a:bufName)
- if l:bufNum != -1
- if a:doDebug
- call <SID>DEBUG('Found buffer ('.a:bufName.'): '.l:bufNum,9)
- endif
- let l:winNum = bufwinnr(l:bufNum)
- else
- let l:winNum = -1
- endif
-
- return l:winNum
-
-endfunction
-
-" }}}
-" FindCreateWindow - Attempts to find a window for a named buffer. {{{
-"
-" If it is found then moves there. Otherwise creates a new window and
-" configures it and moves there.
-"
-" forceEdge, -1 use defaults, 0 below, 1 above
-" isExplorer, 0 no, 1 yes
-" doDebug, 0 no, 1 yes
-"
-function! <SID>FindCreateWindow(bufName, forceEdge, isExplorer, doDebug)
- if a:doDebug
- call <SID>DEBUG('Entering FindCreateWindow('.a:bufName.')',10)
- endif
-
- " Save the user's split setting.
- let l:saveSplitBelow = &splitbelow
-
- " Set to our new values.
- let &splitbelow = g:miniBufExplSplitBelow
-
- " Try to find an existing explorer window
- let l:winNum = <SID>FindWindow(a:bufName, a:doDebug)
-
- " If found goto the existing window, otherwise
- " split open a new window.
- if l:winNum != -1
- if a:doDebug
- call <SID>DEBUG('Found window ('.a:bufName.'): '.l:winNum,9)
- endif
- exec l:winNum.' wincmd w'
- let l:winFound = 1
- else
-
- if g:miniBufExplSplitToEdge == 1 || a:forceEdge >= 0
-
- let l:edge = &splitbelow
- if a:forceEdge >= 0
- let l:edge = a:forceEdge
- endif
-
- if l:edge
- if g:miniBufExplVSplit == 0
- exec 'bo sp '.a:bufName
- else
- exec 'bo vsp '.a:bufName
- endif
- else
- if g:miniBufExplVSplit == 0
- exec 'to sp '.a:bufName
- else
- exec 'to vsp '.a:bufName
- endif
- endif
- else
- if g:miniBufExplVSplit == 0
- exec 'sp '.a:bufName
- else
- " &splitbelow doesn't affect vertical splits
- " so we have to do this explicitly.. ugh.
- if &splitbelow
- exec 'rightb vsp '.a:bufName
- else
- exec 'vsp '.a:bufName
- endif
- endif
- endif
-
- let g:miniBufExplForceDisplay = 1
-
- " Try to find an existing explorer window
- let l:winNum = <SID>FindWindow(a:bufName, a:doDebug)
- if l:winNum != -1
- if a:doDebug
- call <SID>DEBUG('Created and then found window ('.a:bufName.'): '.l:winNum,9)
- endif
- exec l:winNum.' wincmd w'
- else
- if a:doDebug
- call <SID>DEBUG('FindCreateWindow failed to create window ('.a:bufName.').',1)
- endif
- return
- endif
-
- if a:isExplorer
- " Turn off the swapfile, set the buffer type so that it won't get written,
- " and so that it will get deleted when it gets hidden and turn on word wrap.
- setlocal noswapfile
- setlocal buftype=nofile
- setlocal bufhidden=delete
- if g:miniBufExplVSplit == 0
- setlocal wrap
- else
- setlocal nowrap
- exec('setlocal winwidth='.g:miniBufExplMinSize)
- endif
- endif
-
- if a:doDebug
- call <SID>DEBUG('Window ('.a:bufName.') created: '.winnr(),9)
- endif
-
- endif
-
- " Restore the user's split setting.
- let &splitbelow = l:saveSplitBelow
-
-endfunction
-
-" }}}
-" DisplayBuffers - Wrapper for getting MBE window shown {{{
-"
-" Makes sure we are in our explorer, then erases the current buffer and turns
-" it into a mini buffer explorer window.
-"
-function! <SID>DisplayBuffers(delBufNum)
- call <SID>DEBUG('Entering DisplayBuffers()',10)
-
- " Make sure we are in our window
- if bufname('%') != '-MiniBufExplorer-'
- call <SID>DEBUG('DisplayBuffers called in invalid window',1)
- return
- endif
-
- " We need to be able to modify the buffer
- setlocal modifiable
-
- call <SID>ShowBuffers(a:delBufNum)
- call <SID>ResizeWindow()
-
- normal! zz
-
- " Prevent the buffer from being modified.
- setlocal nomodifiable
- set nobuflisted
-
-endfunction
-
-" }}}
-" Resize Window - Set width/height of MBE window {{{
-"
-" Makes sure we are in our explorer, then sets the height/width for our explorer
-" window so that we can fit all of our information without taking extra lines.
-"
-function! <SID>ResizeWindow()
- call <SID>DEBUG('Entering ResizeWindow()',10)
-
- " Make sure we are in our window
- if bufname('%') != '-MiniBufExplorer-'
- call <SID>DEBUG('ResizeWindow called in invalid window',1)
- return
- endif
-
- let l:width = winwidth('.')
-
- " Horizontal Resize
- if g:miniBufExplVSplit == 0
-
- if g:miniBufExplTabWrap == 0
- let l:length = strlen(getline('.'))
- let l:height = 0
- if (l:width == 0)
- let l:height = winheight('.')
- else
- let l:height = (l:length / l:width)
- " handle truncation from div
- if (l:length % l:width) != 0
- let l:height = l:height + 1
- endif
- endif
- else
- exec("setlocal textwidth=".l:width)
- normal gg
- normal gq}
- normal G
- let l:height = line('.')
- normal gg
- endif
-
- " enforce max window height
- if g:miniBufExplMaxSize != 0
- if g:miniBufExplMaxSize < l:height
- let l:height = g:miniBufExplMaxSize
- endif
- endif
-
- " enfore min window height
- if l:height < g:miniBufExplMinSize || l:height == 0
- let l:height = g:miniBufExplMinSize
- endif
-
- call <SID>DEBUG('ResizeWindow to '.l:height.' lines',9)
-
- exec('resize '.l:height)
-
- " Vertical Resize
- else
-
- if g:miniBufExplMaxSize != 0
- let l:newWidth = s:maxTabWidth
- if l:newWidth > g:miniBufExplMaxSize
- let l:newWidth = g:miniBufExplMaxSize
- endif
- if l:newWidth < g:miniBufExplMinSize
- let l:newWidth = g:miniBufExplMinSize
- endif
- else
- let l:newWidth = g:miniBufExplVSplit
- endif
-
- if l:width != l:newWidth
- call <SID>DEBUG('ResizeWindow to '.l:newWidth.' columns',9)
- exec('vertical resize '.l:newWidth)
- endif
-
- endif
-
-endfunction
-
-" }}}
-" ShowBuffers - Clear current buffer and put the MBE text into it {{{
-"
-" Makes sure we are in our explorer, then adds a list of all modifiable
-" buffers to the current buffer. Special marks are added for buffers that
-" are in one or more windows (*) and buffers that have been modified (+)
-"
-function! <SID>ShowBuffers(delBufNum)
- call <SID>DEBUG('Entering ShowBuffers()',10)
-
- let l:ListChanged = <SID>BuildBufferList(a:delBufNum, 1)
-
- if (l:ListChanged == 1 || g:miniBufExplForceDisplay)
- let l:save_rep = &report
- let l:save_sc = &showcmd
- let &report = 10000
- set noshowcmd
-
- " Delete all lines in buffer.
- 1,$d _
-
- " Goto the end of the buffer put the buffer list
- " and then delete the extra trailing blank line
- $
- put! =g:miniBufExplBufList
- $ d _
-
- let g:miniBufExplForceDisplay = 0
-
- let &report = l:save_rep
- let &showcmd = l:save_sc
- else
- call <SID>DEBUG('Buffer list not update since there was no change',9)
- endif
-
-endfunction
-
-" }}}
-" Max - Returns the max of two numbers {{{
-"
-function! <SID>Max(argOne, argTwo)
- if a:argOne > a:argTwo
- return a:argOne
- else
- return a:argTwo
- endif
-endfunction
-
-" }}}
-" BuildBufferList - Build the text for the MBE window {{{
-"
-" Creates the buffer list string and returns 1 if it is different than
-" last time this was called and 0 otherwise.
-"
-function! <SID>BuildBufferList(delBufNum, updateBufList)
- call <SID>DEBUG('Entering BuildBufferList()',10)
-
- let l:NBuffers = bufnr('$') " Get the number of the last buffer.
- let l:i = 0 " Set the buffer index to zero.
-
- let l:fileNames = ''
- let l:maxTabWidth = 0
-
- " Loop through every buffer less than the total number of buffers.
- while(l:i <= l:NBuffers)
- let l:i = l:i + 1
-
- " If we have a delBufNum and it is the current
- " buffer then ignore the current buffer.
- " Otherwise, continue.
- if (a:delBufNum == -1 || l:i != a:delBufNum)
- " Make sure the buffer in question is listed.
- if(getbufvar(l:i, '&buflisted') == 1)
- " Get the name of the buffer.
- let l:BufName = bufname(l:i)
- " Check to see if the buffer is a blank or not. If the buffer does have
- " a name, process it.
- if(strlen(l:BufName))
- " Only show modifiable buffers (The idea is that we don't
- " want to show Explorers)
- if (getbufvar(l:i, '&modifiable') == 1 && BufName != '-MiniBufExplorer-')
-
- " Get filename & Remove []'s & ()'s
- let l:shortBufName = fnamemodify(l:BufName, ":t")
- let l:shortBufName = substitute(l:shortBufName, '[][()]', '', 'g')
- let l:tab = '['.l:i.':'.l:shortBufName.']'
-
- " If the buffer is open in a window mark it
- if bufwinnr(l:i) != -1
- let l:tab = l:tab . '*'
- endif
-
- " If the buffer is modified then mark it
- if(getbufvar(l:i, '&modified') == 1)
- let l:tab = l:tab . '+'
- endif
-
- let l:maxTabWidth = <SID>Max(strlen(l:tab), l:maxTabWidth)
- let l:fileNames = l:fileNames.l:tab
-
- " If horizontal and tab wrap is turned on we need to add spaces
- if g:miniBufExplVSplit == 0
- if g:miniBufExplTabWrap != 0
- let l:fileNames = l:fileNames.' '
- endif
- " If not horizontal we need a newline
- else
- let l:fileNames = l:fileNames . "\n"
- endif
- endif
- endif
- endif
- endif
- endwhile
-
- if (g:miniBufExplBufList != l:fileNames)
- if (a:updateBufList)
- let g:miniBufExplBufList = l:fileNames
- let s:maxTabWidth = l:maxTabWidth
- endif
- return 1
- else
- return 0
- endif
-
-endfunction
-
-" }}}
-" HasEligibleBuffers - Are there enough MBE eligible buffers to open the MBE window? {{{
-"
-" Returns 1 if there are any buffers that can be displayed in a
-" mini buffer explorer. Otherwise returns 0. If delBufNum is
-" any non -1 value then don't include that buffer in the list
-" of eligible buffers.
-"
-function! <SID>HasEligibleBuffers(delBufNum)
- call <SID>DEBUG('Entering HasEligibleBuffers()',10)
-
- let l:save_rep = &report
- let l:save_sc = &showcmd
- let &report = 10000
- set noshowcmd
-
- let l:NBuffers = bufnr('$') " Get the number of the last buffer.
- let l:i = 0 " Set the buffer index to zero.
- let l:found = 0 " No buffer found
-
- if (g:miniBufExplorerMoreThanOne > 1)
- call <SID>DEBUG('More Than One mode turned on',6)
- endif
- let l:needed = g:miniBufExplorerMoreThanOne
-
- " Loop through every buffer less than the total number of buffers.
- while(l:i <= l:NBuffers && l:found < l:needed)
- let l:i = l:i + 1
-
- " If we have a delBufNum and it is the current
- " buffer then ignore the current buffer.
- " Otherwise, continue.
- if (a:delBufNum == -1 || l:i != a:delBufNum)
- " Make sure the buffer in question is listed.
- if (getbufvar(l:i, '&buflisted') == 1)
- " Get the name of the buffer.
- let l:BufName = bufname(l:i)
- " Check to see if the buffer is a blank or not. If the buffer does have
- " a name, process it.
- if (strlen(l:BufName))
- " Only show modifiable buffers (The idea is that we don't
- " want to show Explorers)
- if ((getbufvar(l:i, '&modifiable') == 1) && (BufName != '-MiniBufExplorer-'))
-
- let l:found = l:found + 1
-
- endif
- endif
- endif
- endif
- endwhile
-
- let &report = l:save_rep
- let &showcmd = l:save_sc
-
- call <SID>DEBUG('HasEligibleBuffers found '.l:found.' eligible buffers of '.l:needed.' needed',6)
-
- return (l:found >= l:needed)
-
-endfunction
-
-" }}}
-" Auto Update - Function called by auto commands for auto updating the MBE {{{
-"
-" IF auto update is turned on AND
-" we are in a real buffer AND
-" we have enough eligible buffers THEN
-" Update our explorer and get back to the current window
-"
-" If we get a buffer number for a buffer that
-" is being deleted, we need to make sure and
-" remove the buffer from the list of eligible
-" buffers in case we are down to one eligible
-" buffer, in which case we will want to close
-" the MBE window.
-"
-function! <SID>AutoUpdate(delBufNum)
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Entering AutoUpdate('.a:delBufNum.') : '.bufnr('%').' : '.bufname('%'),10)
- call <SID>DEBUG('===========================',10)
-
- if (g:miniBufExplInAutoUpdate == 1)
- call <SID>DEBUG('AutoUpdate recursion stopped',9)
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Terminated AutoUpdate()' ,10)
- call <SID>DEBUG('===========================',10)
- return
- else
- let g:miniBufExplInAutoUpdate = 1
- endif
-
- " Don't bother autoupdating the MBE window
- if (bufname('%') == '-MiniBufExplorer-')
- " If this is the only buffer left then toggle the buffer
- if (winbufnr(2) == -1)
- call <SID>CycleBuffer(1)
- call <SID>DEBUG('AutoUpdate does not run for cycled windows', 9)
- else
- call <SID>DEBUG('AutoUpdate does not run for the MBE window', 9)
- endif
-
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Terminated AutoUpdate()' ,10)
- call <SID>DEBUG('===========================',10)
-
- let g:miniBufExplInAutoUpdate = 0
- return
-
- endif
-
- if (a:delBufNum != -1)
- call <SID>DEBUG('AutoUpdate will make sure that buffer '.a:delBufNum.' is not included in the buffer list.', 5)
- endif
-
- " Only allow updates when the AutoUpdate flag is set
- " this allows us to stop updates on startup.
- if g:miniBufExplorerAutoUpdate == 1
- " Only show MiniBufExplorer if we have a real buffer
- if ((g:miniBufExplorerMoreThanOne == 0) || (bufnr('%') != -1 && bufname('%') != ""))
- if <SID>HasEligibleBuffers(a:delBufNum) == 1
- " if we don't have a window then create one
- let l:bufnr = <SID>FindWindow('-MiniBufExplorer-', 0)
- if (l:bufnr == -1)
- call <SID>DEBUG('About to call StartExplorer (Create MBE)', 9)
- call <SID>StartExplorer(0, a:delBufNum)
- else
- " otherwise only update the window if the contents have
- " changed
- let l:ListChanged = <SID>BuildBufferList(a:delBufNum, 0)
- if (l:ListChanged)
- call <SID>DEBUG('About to call StartExplorer (Update MBE)', 9)
- call <SID>StartExplorer(0, a:delBufNum)
- endif
- endif
-
- " go back to the working buffer
- if (bufname('%') == '-MiniBufExplorer-')
- wincmd p
- endif
- else
- call <SID>DEBUG('Failed in eligible check', 9)
- call <SID>StopExplorer(0)
- endif
-
- " VIM sometimes turns syntax highlighting off,
- " we can force it on, but this may cause weird
- " behavior so this is an optional hack to force
- " syntax back on when we enter a buffer
- if g:miniBufExplForceSyntaxEnable
- call <SID>DEBUG('Enable Syntax', 9)
- exec 'syntax enable'
- endif
-
- else
- call <SID>DEBUG('No buffers loaded...',9)
- endif
- else
- call <SID>DEBUG('AutoUpdates are turned off, terminating',9)
- endif
-
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Completed AutoUpdate()' ,10)
- call <SID>DEBUG('===========================',10)
-
- let g:miniBufExplInAutoUpdate = 0
-
-endfunction
-
-" }}}
-" GetSelectedBuffer - From the MBE window, return the bufnum for buf under cursor {{{
-"
-" If we are in our explorer window then return the buffer number
-" for the buffer under the cursor.
-"
-function! <SID>GetSelectedBuffer()
- call <SID>DEBUG('Entering GetSelectedBuffer()',10)
-
- " Make sure we are in our window
- if bufname('%') != '-MiniBufExplorer-'
- call <SID>DEBUG('GetSelectedBuffer called in invalid window',1)
- return -1
- endif
-
- let l:save_reg = @"
- let @" = ""
- normal ""yi[
- if @" != ""
- let l:retv = substitute(@",'\([0-9]*\):.*', '\1', '') + 0
- let @" = l:save_reg
- return l:retv
- else
- let @" = l:save_reg
- return -1
- endif
-
-endfunction
-
-" }}}
-" MBESelectBuffer - From the MBE window, open buffer under the cursor {{{
-"
-" If we are in our explorer, then we attempt to open the buffer under the
-" cursor in the previous window.
-"
-function! <SID>MBESelectBuffer()
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Entering MBESelectBuffer()' ,10)
- call <SID>DEBUG('===========================',10)
-
- " Make sure we are in our window
- if bufname('%') != '-MiniBufExplorer-'
- call <SID>DEBUG('MBESelectBuffer called in invalid window',1)
- return
- endif
-
- let l:save_rep = &report
- let l:save_sc = &showcmd
- let &report = 10000
- set noshowcmd
-
- let l:bufnr = <SID>GetSelectedBuffer()
- let l:resize = 0
-
- if(l:bufnr != -1) " If the buffer exists.
-
- let l:saveAutoUpdate = g:miniBufExplorerAutoUpdate
- let g:miniBufExplorerAutoUpdate = 0
- " Switch to the previous window
- wincmd p
-
- " If we are in the buffer explorer or in a nonmodifiable buffer with
- " g:miniBufExplModSelTarget set then try another window (a few times)
- if bufname('%') == '-MiniBufExplorer-' || (g:miniBufExplModSelTarget == 1 && getbufvar(bufnr('%'), '&modifiable') == 0)
- wincmd w
- if bufname('%') == '-MiniBufExplorer-' || (g:miniBufExplModSelTarget == 1 && getbufvar(bufnr('%'), '&modifiable') == 0)
- wincmd w
- if bufname('%') == '-MiniBufExplorer-' || (g:miniBufExplModSelTarget == 1 && getbufvar(bufnr('%'), '&modifiable') == 0)
- wincmd w
- " The following handles the case where -MiniBufExplorer-
- " is the only window left. We need to resize so we don't
- " end up with a 1 or two line buffer.
- if bufname('%') == '-MiniBufExplorer-'
- let l:resize = 1
- endif
- endif
- endif
- endif
-
- exec('b! '.l:bufnr)
- if (l:resize)
- resize
- endif
- let g:miniBufExplorerAutoUpdate = l:saveAutoUpdate
- call <SID>AutoUpdate(-1)
-
- endif
-
- let &report = l:save_rep
- let &showcmd = l:save_sc
-
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Completed MBESelectBuffer()',10)
- call <SID>DEBUG('===========================',10)
-
-endfunction
-
-" }}}
-" MBEDeleteBuffer - From the MBE window, delete selected buffer from list {{{
-"
-" After making sure that we are in our explorer, This will delete the buffer
-" under the cursor. If the buffer under the cursor is being displayed in a
-" window, this routine will attempt to get different buffers into the
-" windows that will be affected so that windows don't get removed.
-"
-function! <SID>MBEDeleteBuffer()
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Entering MBEDeleteBuffer()' ,10)
- call <SID>DEBUG('===========================',10)
-
- " Make sure we are in our window
- if bufname('%') != '-MiniBufExplorer-'
- call <SID>DEBUG('MBEDeleteBuffer called in invalid window',1)
- return
- endif
-
- let l:curLine = line('.')
- let l:curCol = virtcol('.')
- let l:selBuf = <SID>GetSelectedBuffer()
- let l:selBufName = bufname(l:selBuf)
-
- if l:selBufName == 'MiniBufExplorer.DBG' && g:miniBufExplorerDebugLevel > 0
- call <SID>DEBUG('MBEDeleteBuffer will not delete the debug window, when debugging is turned on.',1)
- return
- endif
-
- let l:save_rep = &report
- let l:save_sc = &showcmd
- let &report = 10000
- set noshowcmd
-
-
- if l:selBuf != -1
-
- " Don't want auto updates while we are processing a delete
- " request.
- let l:saveAutoUpdate = g:miniBufExplorerAutoUpdate
- let g:miniBufExplorerAutoUpdate = 0
-
- " Save previous window so that if we show a buffer after
- " deleting. The show will come up in the correct window.
- wincmd p
- let l:prevWin = winnr()
- let l:prevWinBuf = winbufnr(winnr())
-
- call <SID>DEBUG('Previous window: '.l:prevWin.' buffer in window: '.l:prevWinBuf,5)
- call <SID>DEBUG('Selected buffer is <'.l:selBufName.'>['.l:selBuf.']',5)
-
- " If buffer is being displayed in a window then
- " move window to a different buffer before
- " deleting this one.
- let l:winNum = (bufwinnr(l:selBufName) + 0)
- " while we have windows that contain our buffer
- while l:winNum != -1
- call <SID>DEBUG('Buffer '.l:selBuf.' is being displayed in window: '.l:winNum,5)
-
- " move to window that contains our selected buffer
- exec l:winNum.' wincmd w'
-
- call <SID>DEBUG('We are now in window: '.winnr().' which contains buffer: '.bufnr('%').' and should contain buffer: '.l:selBuf,5)
-
- let l:origBuf = bufnr('%')
- call <SID>CycleBuffer(1)
- let l:curBuf = bufnr('%')
-
- call <SID>DEBUG('Window now contains buffer: '.bufnr('%').' which should not be: '.l:selBuf,5)
-
- if l:origBuf == l:curBuf
- " we wrapped so we are going to have to delete a buffer
- " that is in an open window.
- let l:winNum = -1
- else
- " see if we have anymore windows with our selected buffer
- let l:winNum = (bufwinnr(l:selBufName) + 0)
- endif
- endwhile
-
- " Attempt to restore previous window
- call <SID>DEBUG('Restoring previous window to: '.l:prevWin,5)
- exec l:prevWin.' wincmd w'
-
- " Try to get back to the -MiniBufExplorer- window
- let l:winNum = bufwinnr(bufnr('-MiniBufExplorer-'))
- if l:winNum != -1
- exec l:winNum.' wincmd w'
- call <SID>DEBUG('Got to -MiniBufExplorer- window: '.winnr(),5)
- else
- call <SID>DEBUG('Unable to get to -MiniBufExplorer- window',1)
- endif
-
- " Delete the buffer selected.
- call <SID>DEBUG('About to delete buffer: '.l:selBuf,5)
- exec('silent! bd '.l:selBuf)
-
- let g:miniBufExplorerAutoUpdate = l:saveAutoUpdate
- call <SID>DisplayBuffers(-1)
- call cursor(l:curLine, l:curCol)
-
- endif
-
- let &report = l:save_rep
- let &showcmd = l:save_sc
-
- call <SID>DEBUG('===========================',10)
- call <SID>DEBUG('Completed MBEDeleteBuffer()',10)
- call <SID>DEBUG('===========================',10)
-
-endfunction
-
-" }}}
-" MBEClick - Handle mouse double click {{{
-"
-function! s:MBEClick()
- call <SID>DEBUG('Entering MBEClick()',10)
- call <SID>MBESelectBuffer()
-endfunction
-
-"
-" MBEDoubleClick - Double click with the mouse.
-"
-function! s:MBEDoubleClick()
- call <SID>DEBUG('Entering MBEDoubleClick()',10)
- call <SID>MBESelectBuffer()
-endfunction
-
-" }}}
-" CycleBuffer - Cycle Through Buffers {{{
-"
-" Move to next or previous buffer in the current window. If there
-" are no more modifiable buffers then stay on the current buffer.
-" can be called with no parameters in which case the buffers are
-" cycled forward. Otherwise a single argument is accepted, if
-" it's 0 then the buffers are cycled backwards, otherwise they
-" are cycled forward.
-"
-function! <SID>CycleBuffer(forward)
-
- " The following hack handles the case where we only have one
- " window open and it is too small
- let l:saveAutoUpdate = g:miniBufExplorerAutoUpdate
- if (winbufnr(2) == -1)
- resize
- let g:miniBufExplorerAutoUpdate = 0
- endif
-
- " Change buffer (keeping track of before and after buffers)
- let l:origBuf = bufnr('%')
- if (a:forward == 1)
- bn!
- else
- bp!
- endif
- let l:curBuf = bufnr('%')
-
- " Skip any non-modifiable buffers, but don't cycle forever
- " This should stop us from stopping in any of the [Explorers]
- while getbufvar(l:curBuf, '&modifiable') == 0 && l:origBuf != l:curBuf
- if (a:forward == 1)
- bn!
- else
- bp!
- endif
- let l:curBuf = bufnr('%')
- endwhile
-
- let g:miniBufExplorerAutoUpdate = l:saveAutoUpdate
- if (l:saveAutoUpdate == 1)
- call <SID>AutoUpdate(-1)
- endif
-
-endfunction
-
-" }}}
-" DEBUG - Display debug output when debugging is turned on {{{
-"
-" Thanks to Charles E. Campbell, Jr. PhD <cec@NgrOyphSon.gPsfAc.nMasa.gov>
-" for Decho.vim which was the inspiration for this enhanced debugging
-" capability.
-"
-function! <SID>DEBUG(msg, level)
-
- if g:miniBufExplorerDebugLevel >= a:level
-
- " Prevent a report of our actions from showing up.
- let l:save_rep = &report
- let l:save_sc = &showcmd
- let &report = 10000
- set noshowcmd
-
- " Debug output to a buffer
- if g:miniBufExplorerDebugMode == 0
- " Save the current window number so we can come back here
- let l:prevWin = winnr()
- wincmd p
- let l:prevPrevWin = winnr()
- wincmd p
-
- " Get into the debug window or create it if needed
- call <SID>FindCreateWindow('MiniBufExplorer.DBG', 1, 0, 0)
-
- " Make sure we really got to our window, if not we
- " will display a confirm dialog and turn debugging
- " off so that we won't break things even more.
- if bufname('%') != 'MiniBufExplorer.DBG'
- call confirm('Error in window debugging code. Dissabling MiniBufExplorer debugging.', 'OK')
- let g:miniBufExplorerDebugLevel = 0
- endif
-
- " Write Message to DBG buffer
- let res=append("$",s:debugIndex.':'.a:level.':'.a:msg)
- norm G
- "set nomodified
-
- " Return to original window
- exec l:prevPrevWin.' wincmd w'
- exec l:prevWin.' wincmd w'
- " Debug output using VIM's echo facility
- elseif g:miniBufExplorerDebugMode == 1
- echo s:debugIndex.':'.a:level.':'.a:msg
- " Debug output to a file -- VERY SLOW!!!
- " should be OK on UNIX and Win32 (not the 95/98 variants)
- elseif g:miniBufExplorerDebugMode == 2
- if has('system') || has('fork')
- if has('win32') && !has('win95')
- let l:result = system("cmd /c 'echo ".s:debugIndex.':'.a:level.':'.a:msg." >> MiniBufExplorer.DBG'")
- endif
- if has('unix')
- let l:result = system("echo '".s:debugIndex.':'.a:level.':'.a:msg." >> MiniBufExplorer.DBG'")
- endif
- else
- call confirm('Error in file writing version of the debugging code, vim not compiled with system or fork. Dissabling MiniBufExplorer debugging.', 'OK')
- let g:miniBufExplorerDebugLevel = 0
- endif
- elseif g:miniBufExplorerDebugMode == 3
- let g:miniBufExplorerDebugOutput = g:miniBufExplorerDebugOutput."\n".s:debugIndex.':'.a:level.':'.a:msg
- endif
- let s:debugIndex = s:debugIndex + 1
-
- let &report = l:save_rep
- let &showcmd = l:save_sc
-
- endif
-
-endfunc " }}}
-
-" MBE Script History {{{
-"=============================================================================
-"
-" History: 6.3.2 o For some reason there was still a call to StopExplorer
-" with 2 params. Very old bug. I know I fixed before,
-" any way many thanks to Jason Mills for reporting this!
-" 6.3.1 o Include folds in source so that it's easier to
-" navigate.
-" o Added g:miniBufExplForceSyntaxEnable setting for folks
-" that want a :syntax enable to be called when we enter
-" buffers. This can resolve issues caused by a vim bug
-" where buffers show up without highlighting when another
-" buffer has been closed, quit, wiped or deleted.
-" 6.3.0 o Added an option to allow single click (rather than
-" the default double click) to select buffers in the
-" MBE window. This feature was requested by AW Law
-" and was inspired by taglist.vim. Note that you will
-" need the latest version of taglist.vim if you want to
-" use MBE and taglist both with singleclick turned on.
-" Also thanks to AW Law for pointing out that you can
-" make an Explorer not be listed in a standard :ls.
-" o Added the ability to have your tabs show up in a
-" vertical window rather than the standard horizontal
-" one. Just let g:miniBufExplVSplit = <width> in your
-" .vimrc and your will get this functionality.
-" o If you use the vertical explorer and you want it to
-" autosize then let g:miniBufExplMaxSize = <max width>
-" in your .vimrc. You may use the MinSize letting in
-" addition to the MaxLetting if you don't want a super
-" thin window.
-" o g:miniBufExplMaxHeight was renamed g:miniBufExplMaxSize
-" g:miniBufExplMinHeight was renamed g:miniBufExplMinSize
-" the old settings are backwards compatible if you don't
-" use the new settings, but they are depreciated.
-" 6.2.8 o Add an option to stop MBE from targeting non-modifiable
-" buffers when switching buffers. Thanks to AW Law for
-" the inspiration for this. This may not work if a user
-" has lots of explorer/help windows open.
-" 6.2.7 o Very minor bug fix for people who want to set
-" loaded_minibufexplorer in their .vimrc in order to
-" stop MBE from loading. 99.99% of users do not need
-" this update.
-" 6.2.6 o Moved history to end of source file
-" o Updated highlighting documentation
-" o Created global commands MBEbn and MBEbp that can be
-" used in mappings if folks want to cycle buffers while
-" skipping non-eligible buffers.
-" 6.2.5 o Added <Leader>mbt key mapping which will toggle
-" the MBE window. I map this to F3 in my .vimrc
-" with "map <F3> :TMiniBufExplorer<CR>" which
-" means I can easily close the MBE window when I'm
-" not using it and get it back when I want it.
-" o Changed default debug mode to 3 (write to global
-" g:miniBufExplorerDebugOutput)
-" o Made a pass through the documentation to clarify
-" serveral issues and provide more complete docs
-" for mappings and commands.
-" 6.2.4 o Because of the autocommand switch (see 6.2.0) it
-" was possible to remove the restriction on the
-" :set hidden option. It is now possible to use
-" this option with MBE.
-" 6.2.3 o Added miniBufExplTabWrap option. It is turned
-" off by default. When turned on spaces are added
-" between tabs and gq} is issued to perform line
-" formatting. This won't work very well if filenames
-" contain spaces. It would be pretty easy to write
-" my own formatter, but I'm too lazy, so if someone
-" really needs that feature I'll add it :)
-" 6.2.2 o Changed the way the g:miniBufExplorerMoreThanOne
-" global is handled. You can set this to the number
-" of eligible buffers you want to be loaded before
-" the MBE window is loaded. Setting it to 0 causes
-" the MBE window to be opened even if there are no
-" buffers. Setting it to 4 causes the window to stay
-" closed until the 4th eligible buffer is loaded.
-" o Added a MinHeight option. This is nice if you want
-" the MBE window to always take the same amount of
-" space. For example set MaxSize and MinSize to 2
-" and set MoreThanOne to 0 and you will always have
-" a 2 row (plus the ruler :) MBE window.
-" NOTE: in 6.3.0 we started using MinSize instead of
-" Minheight. This will still work if MinSize is not
-" specified, but it is depreciated. Use MinSize instead.
-" o I now setlocal foldcomun=0 and nonumber in the MBE
-" window. This is for those of you that like to have
-" these options turned on locally. I'm assuming noone
-" outthere wants foldcolumns and line numbers in the
-" MBE window? :)
-" o Fixed a bug where an empty MBE window was taking half
-" of the screen (partly why the MinHeight option was
-" added.)
-" 6.2.1 o If MBE is the only window (because of :bd for example)
-" and there are still eligible buffers then one of them
-" will be displayed.
-" o The <Leader>mbe mapping now highlights the buffer from
-" the current window.
-" o The delete ('d') binding in the MBE window now restors
-" the cursor position, which can help if you want to
-" delete several buffers in a row that are not at the
-" beginning of the buffer list.
-" o Added a new key binding ('p') in the MBE window to
-" switch to the previous window (last edit window)
-" 6.2.0 o Major overhaul of autocommand and list updating code,
-" we now have much better handling of :bd (which is the
-" most requested feature.) As well as resolving other
-" issues where the buffer list would not be updated
-" automatically. The old version tried to trap specific
-" events, this one just updates frequently, but it keeps
-" track and only changes the screen if there has been
-" a change.
-" o Added g:miniBufExplMaxHeight variable so you can keep
-" the -MiniBufExplorer- window small when you have lots
-" of buffers (or buffers with long names :)
-" NOTE: in 6.3.0 we started using MaxSize instead of
-" MaxHeight. This will still work if MaxSize is not
-" specified, but it is depreciated. Use MaxSize instead.
-" o Improvement to internal syntax highlighting code
-" I renamed the syntax group names. Anyone who has
-" figured out how to use them already shouldn't have
-" any trouble with the new Nameing :)
-" o Added debug mode 3 which writes to a global variable
-" this is fast and doesn't mess with the buffer/window
-" lists.
-" 6.1.0 o <Leader>mbc was failing because I was calling one of
-" my own functions with the wrong number of args. :(
-" Thanks to Gerry Patterson for finding this!
-" This code is very stable (although it has some
-" idiocyncracies.)
-" 6.0.9 o Double clicking tabs was overwriting the cliboard
-" register on MS Windows. Thanks to Shoeb Bhinderwala
-" for reporting this issue.
-" 6.0.8 o Apparently some VIM builds are having a hard time with
-" line continuation in scripts so the few that were here
-" have been removed.
-" o Generalized FindExplorer and FindCreateExplorer so
-" that they can be used for the debug window. Renaming
-" to FindWindow and FindCreateWindow.
-" o Updated debugging code so that debug output is put into
-" a buffer which can then be written to disk or emailed
-" to me when someone is having a major issue. Can also
-" write directly to a file (VERY SLOWLY) on UNIX or Win32
-" (not 95 or 98 at the moment) or use VIM's echo function
-" to display the output to the screen.
-" o Several people have had issues when the hidden option
-" is turned on. So I have put in several checks to make
-" sure folks know this if they try to use MBE with this
-" option set.
-" 6.0.7 o Handling BufDelete autocmd so that the UI updates
-" properly when using :bd (rather than going through
-" the MBE UI.)
-" o The AutoUpdate code will now close the MBE window when
-" there is a single eligible buffer available.
-" This has the usefull side effect of stopping the MBE
-" window from blocking the VIM session open when you close
-" the last buffer.
-" o Added functions, commands and maps to close & update
-" the MBE window (<leader>mbc and <leader>mbu.)
-" o Made MBE open/close state be sticky if set through
-" StartExplorer(1) or StopExplorer(1), which are
-" called from the standard mappings. So if you close
-" the mbe window with \mbc it won't be automatically
-" opened again unless you do a \mbe (or restart VIM).
-" o Removed spaces between "tabs" (even more mini :)
-" o Simplified MBE tab processing
-" 6.0.6 o Fixed register overwrite bug found by Sébastien Pierre
-" 6.0.5 o Fixed an issue with window sizing when we run out of
-" buffers.
-" o Fixed some weird commenting bugs.
-" o Added more optional fancy window/buffer navigation:
-" o You can turn on the capability to use control and the
-" arrow keys to move between windows.
-" o You can turn on the ability to use <C-TAB> and
-" <C-S-TAB> to open the next and previous (respectively)
-" buffer in the current window.
-" o You can turn on the ability to use <C-TAB> and
-" <C-S-TAB> to switch windows (forward and backwards
-" respectively.)
-" 6.0.4 o Added optional fancy window navigation:
-" o Holding down control and pressing a vim direction
-" [hjkl] will switch windows in the indicated direction.
-" 6.0.3 o Changed buffer name to -MiniBufExplorer- to resolve
-" Issue in filename pattern matching on Windows.
-" 6.0.2 o 2 Changes requested by Suresh Govindachar:
-" o Added SplitToEdge option and set it on by default
-" o Added tab and shift-tab mappings in [MBE] window
-" 6.0.1 o Added MoreThanOne option and set it on by default
-" MiniBufExplorer will not automatically open until
-" more than one eligible buffers are opened. This
-" reduces cluter when you are only working on a
-" single file.
-" NOTE: See change log for 6.2.2 for more details about
-" this feature
-" 6.0.0 o Initial Release on November 20, 2001
-"
-"=============================================================================
-" }}}
-" vim:ft=vim:fdm=marker:ff=unix:nowrap:tabstop=4:shiftwidth=4:softtabstop=4:smarttab:shiftround:expandtab
+++ /dev/null
-let s:tree_up_dir_line = '.. (up a dir)'
-"NERDTreeFlags are syntax items that should be invisible, but give clues as to
-"how things should be highlighted
-syn match NERDTreeFlag #\~#
-syn match NERDTreeFlag #\[RO\]#
-
-"highlighting for the .. (up dir) line at the top of the tree
-execute "syn match NERDTreeUp #\\V". s:tree_up_dir_line ."#"
-
-"highlighting for the ~/+ symbols for the directory nodes
-syn match NERDTreeClosable #\~\<#
-syn match NERDTreeClosable #\~\.#
-syn match NERDTreeOpenable #+\<#
-syn match NERDTreeOpenable #+\.#he=e-1
-
-"highlighting for the tree structural parts
-syn match NERDTreePart #|#
-syn match NERDTreePart #`#
-syn match NERDTreePartFile #[|`]-#hs=s+1 contains=NERDTreePart
-
-"quickhelp syntax elements
-syn match NERDTreeHelpKey #" \{1,2\}[^ ]*:#hs=s+2,he=e-1
-syn match NERDTreeHelpKey #" \{1,2\}[^ ]*,#hs=s+2,he=e-1
-syn match NERDTreeHelpTitle #" .*\~#hs=s+2,he=e-1 contains=NERDTreeFlag
-syn match NERDTreeToggleOn #".*(on)#hs=e-2,he=e-1 contains=NERDTreeHelpKey
-syn match NERDTreeToggleOff #".*(off)#hs=e-3,he=e-1 contains=NERDTreeHelpKey
-syn match NERDTreeHelpCommand #" :.\{-}\>#hs=s+3
-syn match NERDTreeHelp #^".*# contains=NERDTreeHelpKey,NERDTreeHelpTitle,NERDTreeFlag,NERDTreeToggleOff,NERDTreeToggleOn,NERDTreeHelpCommand
-
-"highlighting for readonly files
-syn match NERDTreeRO #.*\[RO\]#hs=s+2 contains=NERDTreeFlag,NERDTreeBookmark,NERDTreePart,NERDTreePartFile
-
-"highlighting for sym links
-syn match NERDTreeLink #[^-| `].* -> # contains=NERDTreeBookmark,NERDTreeOpenable,NERDTreeClosable,NERDTreeDirSlash
-
-"highlighing for directory nodes and file nodes
-syn match NERDTreeDirSlash #/#
-syn match NERDTreeDir #[^-| `].*/# contains=NERDTreeLink,NERDTreeDirSlash,NERDTreeOpenable,NERDTreeClosable
-syn match NERDTreeExecFile #[|` ].*\*\($\| \)# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark
-syn match NERDTreeFile #|-.*# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile
-syn match NERDTreeFile #`-.*# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile
-syn match NERDTreeCWD #^[</].*$#
-
-"highlighting for bookmarks
-syn match NERDTreeBookmark # {.*}#hs=s+1
-
-"highlighting for the bookmarks table
-syn match NERDTreeBookmarksLeader #^>#
-syn match NERDTreeBookmarksHeader #^>-\+Bookmarks-\+$# contains=NERDTreeBookmarksLeader
-syn match NERDTreeBookmarkName #^>.\{-} #he=e-1 contains=NERDTreeBookmarksLeader
-syn match NERDTreeBookmark #^>.*$# contains=NERDTreeBookmarksLeader,NERDTreeBookmarkName,NERDTreeBookmarksHeader
-
-if exists("g:NERDChristmasTree") && g:NERDChristmasTree
- hi def link NERDTreePart Special
- hi def link NERDTreePartFile Type
- hi def link NERDTreeFile Normal
- hi def link NERDTreeExecFile Title
- hi def link NERDTreeDirSlash Identifier
- hi def link NERDTreeClosable Type
-else
- hi def link NERDTreePart Normal
- hi def link NERDTreePartFile Normal
- hi def link NERDTreeFile Normal
- hi def link NERDTreeClosable Title
-endif
-
-hi def link NERDTreeBookmarksHeader statement
-hi def link NERDTreeBookmarksLeader ignore
-hi def link NERDTreeBookmarkName Identifier
-hi def link NERDTreeBookmark normal
-
-hi def link NERDTreeHelp String
-hi def link NERDTreeHelpKey Identifier
-hi def link NERDTreeHelpCommand Identifier
-hi def link NERDTreeHelpTitle Macro
-hi def link NERDTreeToggleOn Question
-hi def link NERDTreeToggleOff WarningMsg
-
-hi def link NERDTreeDir Directory
-hi def link NERDTreeUp Directory
-hi def link NERDTreeCWD Statement
-hi def link NERDTreeLink Macro
-hi def link NERDTreeOpenable Title
-hi def link NERDTreeFlag ignore
-hi def link NERDTreeRO WarningMsg
-hi def link NERDTreeBookmark Statement
-
-hi def link NERDTreeCurrentNode Search
"==============================================================================
" General Settings
"==============================================================================
+let $VIMHOME=expand("<sfile>:p:h") " Keep track of where our vim settings directory is
syntax enable " Turn on syntax highlighting
filetype plugin on " Turn on filetype plugins
filetype indent off " Turn off filetype indent to use custom indent settings
-colorscheme torte " Set default color scheme
+colorscheme cake " Set default color scheme
set nocompatible " Disable VI compatibility
set backspace=indent,eol,start " Makes backspace work as expected
set whichwrap+=<,>,[,],h,l " Make cursor keys wrap line
set noerrorbells " Turn off auditory bells
set hid " Change buffer without saving
set clipboard=unnamed " Yank and Put commands use the system clipboard
-set laststatus=0 " Turn off the status line
-set undodir=~/vimfiles/undo " Set directory for storing undo files
+set laststatus=2 " Turn off the status line
+set undodir=$VIMHOME/undo " Set directory for storing undo files
set undofile " Turn on persistent undo
set cscopetag " Search both cscope dbs and ctags files for tags
set csto=0 " Search cscope dbs before ctags files
set history=20 " Save 20 lines of command history
set hlsearch " Turn on search highlighting
set ignorecase " Ignore case in searches
-set smartcase " Don't ignore case when search term contains capitals
+"set smartcase " Don't ignore case when search term contains capitals
set incsearch " Highlight search string as you type
set tags=tags;/ " Search from current directory to root for ctags db
set fileformats=unix,dos,mac " support all three, in this order
set formatoptions+=r " Enable continuation of comments after a newline
set omnifunc=syntaxcomplete#Complete " Auto complete based on syntax
set completeopt=menu,longest " Show a popup menu with the longest common prefix selected
-highlight Pmenu guibg=blue gui=bold " Change omnicomplete window to blue background
+
+"==============================================================================
+" Global Variables
+"==============================================================================
+let g:BufsLeft = "" " Buffers to the left of our current buffer
+let g:CurBuffer = "" " Name of our current buffer
+let g:BufsRight = "" " Buffers to the right of the current buffer
+
+"==============================================================================
+" Function and Command Definitions
+"==============================================================================
+set statusline=%-(%{g:BufsLeft}%#CurBuf#%{g:CurBuffer}%#SyntaxLine#%{g:BufsRight}%)%=[%l][%c][%P][%L]
+
+"set statusline=%(%{g:BufsLeft}
+"set statusline+=%#CurBuf#
+"set statusline+=%{g:CurBuffer}
+"set statusline+=%#SyntaxLine#
+"set statusline+=%{g:BufsRight}%)
+"set statusline+=%<%=[%l][%c][%P][%L]%<
"==============================================================================
" Function and Command Definitions
endif
endfunction
+function! UpdateStatus()
+ let g:CurBuffer = '[' . bufnr('%') . ' ' . expand('%:t') . ((&modified) ? ' +]' : ']')
+ let g:BufsLeft = ""
+ let g:BufsRight = ""
+ let i = bufnr('$')
+ let my_left_len = (winwidth(0) - len(g:CurBuffer) - 20)
+ let my_right_len = 0
+
+ while(i > 0)
+ if buflisted(i) && getbufvar(i, "&modifiable") && i != bufnr('%')
+ let bufName = '[' . i . ' ' . fnamemodify(bufname(i), ":t")
+ let bufName .= (getbufvar(i, "&modified") ? ' +]' : ']' )
+ if i < bufnr('%')
+ let g:BufsLeft = bufName . g:BufsLeft
+ else
+ let g:BufsRight = bufName . g:BufsRight
+ endif
+ endif
+ let i -= 1
+ endwhile
+
+ if len(g:BufsLeft) < my_left_len
+ let my_right_len = winwidth(0) - (len(g:BufsLeft) + len(g:CurBuffer) + 20)
+ endif
+
+ if len(g:BufsRight) < my_right_len
+ let my_left_len = winwidth(0) - (len(g:BufsRight) + len(g:CurBuffer) + 20)
+ endif
+
+ if len(g:BufsLeft) > my_left_len
+ let g:BufsLeft = '<' . strpart(g:BufsLeft, len(g:BufsLeft) - my_left_len, my_left_len)
+ endif
+
+ if len(g:BufsRight) > my_right_len
+ let g:BufsRight = strpart(g:BufsRight, 0, my_right_len) . '>'
+ endif
+endfunction
+
+"function! UpdateStatus()
+" let g:CurBuffer = '[' . bufnr('%') . ' ' . expand('%:t') . ((&modified) ? ' +]' : ']')
+" let max_len = winwidth(0) - len(g:CurBuffer)
+" let g:BufsLeft = ""
+" let g:BufsRight = ""
+" let i = bufnr('$')
+"
+" while(i > 0)
+" if buflisted(i) && getbufvar(i, "&modifiable") && i != bufnr('%')
+" let bufName = '[' . i . ' ' . fnamemodify(bufname(i), ":t")
+" let bufName .= (getbufvar(i, "&modified") ? ' +]' : ']' )
+" if i < bufnr('%')
+" let g:BufsLeft = bufName . g:BufsLeft
+" else
+" let g:BufsRight = bufName . g:BufsRight
+" endif
+" endif
+" let i -= 1
+" endwhile
+"
+" if (len(g:BufsLeft) + len(g:CurBuffer)) > max_len
+" let strstart = (len(g:BufsLeft) + len(g:CurBuffer)) - max_len
+" let g:BufsLeft = '<' . strpart(g:BufsLeft, strstart, max_len)
+" endif
+"endfunction
+
" ---- ToFn - Converts a group of C function prototypes to definitions ----
command! -range=% -nargs=0 ToFn execute "<line1>,<line2>s/;/\r{\r\r}\r/"
" ---- Omni Complete ----
inoremap <C-Space> <C-n>
-" ---- Nerd Tree Toggle ----
-map <Leader>t :NERDTreeToggle<CR>
-
" ---- Buffer Management ----
map <C-S-tab> :bp<CR>
imap <C-S-tab> <ESC>:bp<CR>
map <C-tab> :bn<CR>
imap <C-tab> <ESC>:bn<CR>
-map <Leader>d :Kwbd<CR>
-imap <Leader>d <ESC>:Kwbd<CR>
+map <Leader>d :bd<CR>
+imap <Leader>d <ESC>:bd<CR>
" ---- Working With Windows ----
map <M-h> <C-w>h
abbreviate ifndef #ifndef<CR>#endif<up><END>
abbreviate prf printf("");<left><left><left>
+abbreviate ctest
+ \void test_(void)<CR>
+ \{<CR>
+ \ // Setup<CR>
+ \ // Expected calls<CR>
+ \ // Function to test<CR>
+ \ // Asserts<CR>
+ \}<UP><UP><UP><UP><UP><UP><END><ESC>%i
+
" Command mode abbreviations
cnoreabbrev trim %s/\s\+$//
cnoreabbrev print hardcopy
" Reformat the whitespace to remove tabs and trailing space
autocmd BufWritePre * call ReformatWhiteSpace()
+" Update the buffer list in the status line
+autocmd VimEnter,BufNew,BufEnter,BufWritePost,VimResized * call UpdateStatus()
+
"==============================================================================
" GVim
"==============================================================================
projects / archive / vim_config.git / commitdiff