| "============================================================================= |
| " File: explorer.vim |
| " Author: M A Aziz Ahmed (aziz@acorn-networks.com - doesn't work) |
| " Last Change: 2004 Jun 22 |
| " Version: 2.5 + changes |
| " Additions by Mark Waggoner (waggoner@aracnet.com) et al. |
| "----------------------------------------------------------------------------- |
| " This file implements a file explorer. |
| "----------------------------------------------------------------------------- |
| " Normally, this file will reside in the plugins directory and be |
| " automatically sourced. If not, you must manually source this file |
| " using :source explorer.vim |
| " |
| " To use it, just edit a directory (vi dirname) or type :Explore to |
| " launch the file explorer in the current window, or :Sexplore to split |
| " the current window and launch explorer there. |
| " |
| " If the current buffer is modified, the window is always split. |
| " |
| " It is also possible to delete files and rename files within explorer. |
| " See :help file-explorer for more details |
| " |
| "----------------------------------------------------------------------------- |
| " Update history removed, it's not very interesting. |
| " Contributors were: Doug Potts, Bram Moolenaar, Thomas Köhler |
| "============================================================================= |
| |
| " Has this already been loaded? |
| if exists("loaded_explorer") |
| finish |
| endif |
| let loaded_explorer=1 |
| |
| " Line continuation used here |
| let s:cpo_save = &cpo |
| set cpo&vim |
| |
| "--- |
| " Default settings for global configuration variables |
| |
| " Split vertically instead of horizontally? |
| if !exists("g:explVertical") |
| let g:explVertical=0 |
| endif |
| |
| " How big to make the window? Set to "" to avoid resizing |
| if !exists("g:explWinSize") |
| let g:explWinSize=15 |
| endif |
| |
| " When opening a new file/directory, split below current window (or |
| " above)? 1 = below, 0 = to above |
| if !exists("g:explSplitBelow") |
| let g:explSplitBelow = &splitbelow |
| endif |
| |
| " Split to right of current window (or to left)? |
| " 1 = to right, 0 = to left |
| if !exists("g:explSplitRight") |
| let g:explSplitRight = &splitright |
| endif |
| |
| " Start the first explorer window... |
| " Defaults to be the same as explSplitBelow |
| if !exists("g:explStartBelow") |
| let g:explStartBelow = g:explSplitBelow |
| endif |
| |
| " Start the first explorer window... |
| " Defaults to be the same as explSplitRight |
| if !exists("g:explStartRight") |
| let g:explStartRight = g:explSplitRight |
| endif |
| |
| " Show detailed help? |
| if !exists("g:explDetailedHelp") |
| let g:explDetailedHelp=0 |
| endif |
| |
| " Show file size and dates? |
| if !exists("g:explDetailedList") |
| let g:explDetailedList=0 |
| endif |
| |
| " Format for the date |
| if !exists("g:explDateFormat") |
| let g:explDateFormat="%d %b %Y %H:%M" |
| endif |
| |
| " Files to hide |
| if !exists("g:explHideFiles") |
| let g:explHideFiles='' |
| endif |
| |
| " Field to sort by |
| if !exists("g:explSortBy") |
| let g:explSortBy='name' |
| endif |
| |
| " Segregate directories? 1, 0, or -1 |
| if !exists("g:explDirsFirst") |
| let g:explDirsFirst=1 |
| endif |
| |
| " Segregate items in suffixes option? 1, 0, or -1 |
| if !exists("g:explSuffixesLast") |
| let g:explSuffixesLast=1 |
| endif |
| |
| " Include separator lines between directories, files, and suffixes? |
| if !exists("g:explUseSeparators") |
| let g:explUseSeparators=0 |
| endif |
| |
| " Execute file handler |
| if !exists("g:explFileHandler") |
| if has("win32") |
| " for Win32 use rundll32 |
| function! s:explFileHandlerWin32(fn) |
| exec 'silent !start rundll32 url.dll,FileProtocolHandler "' |
| \ . escape(a:fn, '%#') . '"' |
| endfunction |
| let g:explFileHandler = "<SID>explFileHandlerWin32" |
| |
| elseif has("unix") |
| " for KDE use kfmclient, for GNUME use gnome-open |
| if executable("kfmclient") |
| let g:explFileHandlerCmd = "kfmclient exec" |
| elseif executable("gnome-open") |
| let g:explFileHandlerCmd = "gnome-open" |
| else |
| let g:explFileHandlerCmd = "" |
| endif |
| if g:explFileHandlerCmd != "" |
| function! s:explFileHandlerUnix(fn) |
| if &shellredir =~ "%s" |
| let redir = substitute(&shellredir, "%s", "/dev/null", "") |
| else |
| let redir = &shellredir . "/dev/null" |
| endif |
| " Need to escape % and # but not spaces. |
| exec "silent !" . g:explFileHandlerCmd . " '" . escape(a:fn, '%#') . "'" . redir |
| endfunction |
| let g:explFileHandler = "<SID>explFileHandlerUnix" |
| endif |
| endif |
| endif |
| |
| "--- |
| " script variables - these are the same across all |
| " explorer windows |
| |
| " characters that must be escaped for a regular expression |
| let s:escregexp = '/*^$.~\' |
| |
| " characters that must be escaped for filenames |
| if has("dos16") || has("dos32") || has("win16") || has("win32") || has("os2") |
| let s:escfilename = ' %#' |
| else |
| let s:escfilename = ' \%#[]' |
| endif |
| |
| |
| " A line to use for separating sections |
| let s:separator='"---------------------------------------------------' |
| |
| "--- |
| " Create commands |
| |
| if !exists(':Explore') |
| command -n=? -complete=dir Explore :call s:StartExplorer(0, '<a>') |
| endif |
| if !exists(':Sexplore') |
| command -n=? -complete=dir Sexplore :call s:StartExplorer(1, '<a>') |
| endif |
| |
| "--- |
| " Start the explorer using the preferences from the global variables |
| " |
| function! s:StartExplorer(split, start_dir) |
| let startcmd = "edit" |
| if a:start_dir != "" |
| let fname=a:start_dir |
| else |
| let fname = expand("%:p:h") |
| endif |
| if fname == "" |
| let fname = getcwd() |
| endif |
| |
| " Create a variable to use if splitting vertically |
| let splitMode = "" |
| if g:explVertical == 1 |
| let splitMode = "vertical" |
| endif |
| |
| " Save the user's settings for splitbelow and splitright |
| let savesplitbelow = &splitbelow |
| let savesplitright = &splitright |
| |
| if a:split || &modified |
| let startcmd = splitMode . " " . g:explWinSize . "new " . fname |
| let &splitbelow = g:explStartBelow |
| let &splitright = g:explStartRight |
| else |
| let startcmd = "edit " . fname |
| endif |
| silent execute startcmd |
| let &splitbelow = savesplitbelow |
| let &splitright = savesplitright |
| endfunction |
| |
| "--- |
| " This is the main entry for 'editing' a directory |
| " |
| function! s:EditDir() |
| " Get out of here right away if this isn't a directory! |
| let name = expand("%") |
| if name == "" |
| let name = expand("%:p") |
| endif |
| if !isdirectory(name) |
| return |
| endif |
| |
| " 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. |
| setlocal noreadonly modifiable |
| setlocal noswapfile |
| setlocal buftype=nowrite |
| setlocal bufhidden=delete |
| " Don't wrap around long lines |
| setlocal nowrap |
| |
| " No need for any insertmode abbreviations, since we don't allow |
| " insertions anyway! |
| iabc <buffer> |
| |
| " Long or short listing? Use the global variable the first time |
| " explorer is called, after that use the script variable as set by |
| " the interactive user. |
| if exists("s:longlist") |
| let w:longlist = s:longlist |
| else |
| let w:longlist = g:explDetailedList |
| endif |
| |
| " Show keyboard shortcuts? |
| if exists("s:longhelp") |
| let w:longhelp = s:longhelp |
| else |
| let w:longhelp = g:explDetailedHelp |
| endif |
| |
| " Set the sort based on the global variables the first time. If you |
| " later change the sort order, it will be retained in the s:sortby |
| " variable for the next time you open explorer |
| let w:sortdirection=1 |
| let w:sortdirlabel = "" |
| let w:sorttype = "" |
| if exists("s:sortby") |
| let sortby=s:sortby |
| else |
| let sortby=g:explSortBy |
| endif |
| if sortby =~ "reverse" |
| let w:sortdirection=-1 |
| let w:sortdirlabel = "reverse " |
| endif |
| if sortby =~ "date" |
| let w:sorttype = "date" |
| elseif sortby =~ "size" |
| let w:sorttype = "size" |
| else |
| let w:sorttype = "name" |
| endif |
| call s:SetSuffixesLast() |
| |
| " If directory is already loaded, don't open it again! |
| if line('$') > 1 |
| setlocal readonly nomodifiable |
| return |
| endif |
| |
| " Get the complete path to the directory to look at with a slash at |
| " the end. This also removes "/../" and "/./" things. |
| let b:completePath = s:Path(expand("%:p")) |
| |
| " Add a slash at the end |
| if b:completePath !~ '/$' |
| let b:completePath = b:completePath . '/' |
| endif |
| |
| " escape special characters for exec commands |
| let b:completePathEsc = escape(b:completePath, s:escfilename) |
| let b:parentDirEsc = substitute(b:completePathEsc, '/[^/]*/$', '/', 'g') |
| |
| " Set up syntax highlighting |
| " Something wrong with the evaluation of the conditional though... |
| if has("syntax") && exists("g:syntax_on") && !has("syntax_items") |
| syn match browseSynopsis "^\"[ -].*" |
| syn match browseDirectory "[^\"].*/ " |
| syn match browseDirectory "[^\"].*/$" |
| syn match browseCurDir "^\"= .*$" |
| syn match browseSortBy "^\" Sorted by .*$" contains=browseSuffixInfo |
| syn match browseSuffixInfo "(.*)$" contained |
| syn match browseFilter "^\" Not Showing:.*$" |
| syn match browseFiletime "««\d\+$" |
| exec('syn match browseSuffixes "' . b:suffixesHighlight . '"') |
| |
| "hi def link browseSynopsis PreProc |
| hi def link browseSynopsis Special |
| hi def link browseDirectory Directory |
| hi def link browseCurDir Statement |
| hi def link browseSortBy String |
| hi def link browseSuffixInfo Type |
| hi def link browseFilter String |
| hi def link browseFiletime Ignore |
| hi def link browseSuffixes Type |
| endif |
| |
| " Set filter for hiding files |
| let b:filterFormula=substitute(g:explHideFiles, '\([^\\]\),', '\1\\|', 'g') |
| if b:filterFormula != '' |
| let b:filtering="\nNot showing: " . b:filterFormula |
| else |
| let b:filtering="" |
| endif |
| |
| " Show the files |
| call s:ShowDirectory() |
| |
| " Set up mappings for this buffer |
| let cpo_save = &cpo |
| set cpo&vim |
| nnoremap <buffer> <cr> :call <SID>EditEntry("","edit")<cr> |
| nnoremap <buffer> - :exec ("silent e " . b:parentDirEsc)<cr> |
| if exists("g:explFileHandler") |
| nnoremap <buffer> x :call <SID>ExecuteEntry()<cr> |
| endif |
| nnoremap <buffer> o :call <SID>OpenEntry()<cr> |
| nnoremap <buffer> O :call <SID>OpenEntryPrevWindow()<cr> |
| nnoremap <buffer> p :call <SID>EditEntry("","pedit")<cr> |
| nnoremap <buffer> ? :call <SID>ToggleHelp()<cr> |
| nnoremap <buffer> a :call <SID>ShowAllFiles()<cr> |
| nnoremap <buffer> R :call <SID>RenameFile()<cr> |
| nnoremap <buffer> D :. call <SID>DeleteFile()<cr> |
| vnoremap <buffer> D :call <SID>DeleteFile()<cr> |
| nnoremap <buffer> i :call <SID>ToggleLongList()<cr> |
| nnoremap <buffer> s :call <SID>SortSelect()<cr> |
| nnoremap <buffer> r :call <SID>SortReverse()<cr> |
| nnoremap <buffer> c :exec "cd ".b:completePathEsc<cr> |
| nnoremap <buffer> <2-leftmouse> :call <SID>DoubleClick()<cr> |
| if exists("*ExplorerCustomMap") |
| call ExplorerCustomMap() |
| endif |
| let &cpo = cpo_save |
| |
| " prevent the buffer from being modified |
| setlocal readonly nomodifiable |
| endfunction |
| |
| "--- |
| " Determine the number of windows open to this buffer number. |
| " Care of Yegappan Lakshman. Thanks! |
| fun! 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 |
| |
| " If this is the only window, open file in a new window |
| " Otherwise, open file in the most recently visited window |
| " |
| function! s:OpenEntryPrevWindow() |
| " Figure out if there are any other windows |
| let n = winnr() |
| wincmd p |
| " No other window? Then open a new one |
| if n == winnr() |
| call s:OpenEntry() |
| " Other windows exist |
| else |
| " Check if the previous buffer is modified - ask if they want to save! |
| " Was it modified, and is it the only window open to this file |
| if &modified && s:BufInWindows(winbufnr(winnr())) < 2 |
| let bufname = bufname(winbufnr(winnr())) |
| |
| let action=confirm("Save Changes in " . bufname . "?","&Yes\n&No\n&Cancel") |
| " Yes - try to save - if there is an error, cancel |
| if action == 1 |
| let v:errmsg = "" |
| silent w |
| if v:errmsg != "" |
| echoerr "Unable to write buffer!" |
| wincmd p |
| return |
| endif |
| " No, abandon changes |
| elseif action == 2 |
| set nomodified |
| echomsg "Warning, abandoning changes in " . bufname |
| " Cancel (or any other result), don't do the open |
| else |
| wincmd p |
| return |
| endif |
| endif |
| wincmd p |
| call s:EditEntry("wincmd p","edit") |
| endif |
| endfunction |
| |
| |
| "--- |
| " Open a file or directory in a new window. |
| " Use g:explSplitBelow and g:explSplitRight to decide where to put the |
| " split window, and resize the original explorer window if it is |
| " larger than g:explWinSize |
| " |
| function! s:OpenEntry() |
| " Are we on a line with a file name? |
| let l = getline(".") |
| if l =~ '^"' |
| return |
| endif |
| |
| " Copy window settings to script settings |
| let s:sortby=w:sortdirlabel . w:sorttype |
| let s:longhelp = w:longhelp |
| let s:longlist = w:longlist |
| |
| " Get the window number of the explorer window |
| let n = winnr() |
| |
| " Save the user's settings for splitbelow and splitright |
| let savesplitbelow=&splitbelow |
| let savesplitright=&splitright |
| |
| " Figure out how to do the split based on the user's preferences. |
| " We want to split to the (left,right,top,bottom) of the explorer |
| " window, but we want to extract the screen real-estate from the |
| " window next to the explorer if possible. |
| " |
| " 'there' will be set to a command to move from the split window |
| " back to the explorer window |
| " |
| " 'back' will be set to a command to move from the explorer window |
| " back to the newly split window |
| " |
| " 'right' and 'below' will be set to the settings needed for |
| " splitbelow and splitright IF the explorer is the only window. |
| " |
| if g:explVertical |
| if g:explSplitRight |
| let there="wincmd h" |
| let back ="wincmd l" |
| let right=1 |
| let below=0 |
| else |
| let there="wincmd l" |
| let back ="wincmd h" |
| let right=0 |
| let below=0 |
| endif |
| else |
| if g:explSplitBelow |
| let there="wincmd k" |
| let back ="wincmd j" |
| let right=0 |
| let below=1 |
| else |
| let there="wincmd j" |
| let back ="wincmd k" |
| let right=0 |
| let below=0 |
| endif |
| endif |
| |
| " Get the file name |
| let fn=s:GetFullFileName() |
| |
| " Attempt to go to adjacent window |
| exec(back) |
| " If no adjacent window, set splitright and splitbelow appropriately |
| if n == winnr() |
| let &splitright=right |
| let &splitbelow=below |
| else |
| " found adjacent window - invert split direction |
| let &splitright=!right |
| let &splitbelow=!below |
| endif |
| |
| " Create a variable to use if splitting vertically |
| let splitMode = "" |
| if g:explVertical == 1 |
| let splitMode = "vertical" |
| endif |
| |
| " Is it a directory? If so, get a real path to it instead of |
| " relative path. This also removes "/../" and "/./" things. |
| if isdirectory(fn) |
| let fn = fnamemodify(fn, ":p") |
| endif |
| |
| " Open the new window |
| exec("silent " . splitMode." sp " . escape(fn,s:escfilename)) |
| |
| " resize the explorer window if it is larger than the requested size |
| exec(there) |
| if g:explWinSize =~ '[0-9]\+' && winheight("") > g:explWinSize |
| exec("silent ".splitMode." resize ".g:explWinSize) |
| endif |
| exec(back) |
| |
| " Restore splitmode settings |
| let &splitbelow=savesplitbelow |
| let &splitright=savesplitright |
| |
| endfunction |
| |
| function! s:ExecuteEntry() |
| " Are we on a line with a file name? |
| let l = getline(".") |
| if l =~ '^"' |
| return |
| endif |
| |
| " Get the file name |
| let fn = s:GetFullFileName() |
| if has("win32") && fn =~ '^//' |
| let fn = substitute(fn, '/', '\\', 'g') |
| endif |
| exec "call " . g:explFileHandler . "(fn)" |
| endfunction |
| |
| "--- |
| " Double click with the mouse |
| " |
| function s:DoubleClick() |
| if expand("<cfile>") =~ '[\\/]$' |
| call s:EditEntry("","edit") " directory: open in this window |
| else |
| call s:OpenEntryPrevWindow() " file: open in another window |
| endif |
| endfun |
| |
| "--- |
| " Open file or directory in the same window as the explorer is |
| " currently in |
| " |
| function! s:EditEntry(movefirst,editcmd) |
| " Are we on a line with a file name? |
| let l = getline(".") |
| if l =~ '^"' |
| return |
| endif |
| |
| " Copy window settings to script settings |
| let s:sortby=w:sortdirlabel . w:sorttype |
| let s:longhelp = w:longhelp |
| let s:longlist = w:longlist |
| |
| " Get the file name |
| let fn = s:GetFullFileName() |
| if isdirectory(fn) |
| " This removes "/../" and "/./" things. |
| let fn = fnamemodify(fn, ":p") |
| endif |
| |
| " Move to desired window if needed |
| exec(a:movefirst) |
| " Edit the file/dir |
| exec(a:editcmd . " " . escape(fn,s:escfilename)) |
| endfunction |
| |
| |
| "--- |
| " Create a regular expression out of the suffixes option for sorting |
| " and set a string to indicate whether we are sorting with the |
| " suffixes at the end (or the beginning) |
| " |
| function! s:SetSuffixesLast() |
| let b:suffixesRegexp = '\(' . substitute(escape(&suffixes,s:escregexp),',','\\|','g') . '\)$' |
| let b:suffixesHighlight = '^[^"].*\(' . substitute(escape(&suffixes,s:escregexp),',','\\|','g') . '\)\( \|$\)' |
| if has("fname_case") |
| let b:suffixesRegexp = '\C' . b:suffixesRegexp |
| let b:suffixesHighlight = '\C' . b:suffixesHighlight |
| else |
| let b:suffixesRegexp = '\c' . b:suffixesRegexp |
| let b:suffixesHighlight = '\c' . b:suffixesHighlight |
| endif |
| if g:explSuffixesLast > 0 && &suffixes != "" |
| let b:suffixeslast=" (" . &suffixes . " at end of list)" |
| elseif g:explSuffixesLast < 0 && &suffixes != "" |
| let b:suffixeslast=" (" . &suffixes . " at start of list)" |
| else |
| let b:suffixeslast=" ('suffixes' mixed with files)" |
| endif |
| endfunction |
| |
| "--- |
| " Show the header and contents of the directory |
| " |
| function! s:ShowDirectory() |
| "Delete all lines |
| 1,$d _ |
| " Prevent a report of our actions from showing up |
| let oldRep=&report |
| let save_sc = &sc |
| set report=10000 nosc |
| |
| " Add the header |
| call s:AddHeader() |
| $d _ |
| |
| " Display the files |
| |
| " Get a list of all the files |
| let files = s:Path(glob(b:completePathEsc . "*")) |
| if files != "" && files !~ "\n$" |
| let files = files . "\n" |
| endif |
| |
| " Add the dot files now, making sure "." is not included! |
| let files = files . substitute(s:Path(glob(b:completePathEsc . ".*")), "[^\n]*/./\\=\n", '' , '') |
| if files != "" && files !~ "\n$" |
| let files = files . "\n" |
| endif |
| |
| " Are there any files left after filtering? |
| if files != "" |
| normal! mt |
| put =files |
| let b:maxFileLen = 0 |
| 0 |
| /^"=/+1,$g/^/call s:MarkDirs() |
| keepjumps normal! `t |
| call s:AddFileInfo() |
| endif |
| |
| normal! zz |
| |
| " Move to first directory in the listing |
| 0 |
| /^"=/+1 |
| |
| " Do the sort |
| call s:SortListing("Loaded contents of ".b:completePath.". ") |
| |
| " Move to first directory in the listing |
| 0 |
| /^"=/+1 |
| |
| let &report=oldRep |
| let &sc = save_sc |
| |
| endfunction |
| |
| "--- |
| " Mark which items are directories - called once for each file name |
| " must be used only when size/date is not displayed |
| " |
| function! s:MarkDirs() |
| let oldRep=&report |
| set report=1000 |
| "Remove slashes if added |
| s;/$;;e |
| "Removes all the leading slashes and adds slashes at the end of directories |
| s;^.*\\\([^\\]*\)$;\1;e |
| s;^.*/\([^/]*\)$;\1;e |
| "normal! ^ |
| let currLine=getline(".") |
| if isdirectory(b:completePath . currLine) |
| s;$;/; |
| let fileLen=strlen(currLine)+1 |
| else |
| let fileLen=strlen(currLine) |
| if (b:filterFormula!="") && (currLine =~ b:filterFormula) |
| " Don't show the file if it is to be filtered. |
| d _ |
| endif |
| endif |
| if fileLen > b:maxFileLen |
| let b:maxFileLen=fileLen |
| endif |
| let &report=oldRep |
| endfunction |
| |
| "--- |
| " Make sure a path has proper form |
| " |
| function! s:Path(p) |
| if has("dos16") || has("dos32") || has("win16") || has("win32") || has("os2") |
| return substitute(a:p,'\\','/','g') |
| else |
| return a:p |
| endif |
| endfunction |
| |
| "--- |
| " Extract the file name from a line in several different forms |
| " |
| function! s:GetFullFileNameEsc() |
| return s:EscapeFilename(s:GetFullFileName()) |
| endfunction |
| |
| function! s:GetFileNameEsc() |
| return s:EscapeFilename(s:GetFileName()) |
| endfunction |
| |
| function! s:EscapeFilename(name) |
| return escape(a:name,s:escfilename) |
| endfunction |
| |
| |
| function! s:GetFullFileName() |
| return s:ExtractFullFileName(getline(".")) |
| endfunction |
| |
| function! s:GetFileName() |
| return s:ExtractFileName(getline(".")) |
| endfunction |
| |
| function! s:ExtractFullFileName(line) |
| let fn=s:ExtractFileName(a:line) |
| if fn == '/' |
| return b:completePath |
| else |
| return b:completePath . s:ExtractFileName(a:line) |
| endif |
| endfunction |
| |
| function! s:ExtractFileName(line) |
| return substitute(strpart(a:line,0,b:maxFileLen),'\s\+$','','') |
| endfunction |
| |
| "--- |
| " Get the size of the file |
| function! s:ExtractFileSize(line) |
| if (w:longlist==0) |
| return getfsize(s:ExtractFileName(a:line)) |
| else |
| return strpart(a:line,b:maxFileLen+2,b:maxFileSizeLen) |
| endif |
| endfunction |
| |
| "--- |
| " Get the date of the file as a number |
| function! s:ExtractFileDate(line) |
| if w:longlist==0 |
| return getftime(s:ExtractFileName(a:line)) |
| else |
| return strpart(matchstr(strpart(a:line,b:maxFileLen+b:maxFileSizeLen+4),"««.*"),2) + 0 |
| endif |
| endfunction |
| |
| |
| "--- |
| " Add the header with help information |
| " |
| function! s:AddHeader() |
| let save_f=@f |
| 1 |
| if w:longhelp==1 |
| let @f="\" <enter> : open file or directory\n" |
| \."\" o : open new window for file/directory\n" |
| \."\" O : open file in previously visited window\n" |
| \."\" p : preview the file\n" |
| if exists("g:explFileHandler") |
| let @f=@f."\" x : execute file or directory\n" |
| endif |
| let @f=@f |
| \."\" i : toggle size/date listing\n" |
| \."\" s : select sort field r : reverse sort\n" |
| \."\" - : go up one level c : cd to this dir\n" |
| \."\" R : rename file D : delete file\n" |
| \."\" :help file-explorer for detailed help\n" |
| else |
| let @f="\" Press ? for keyboard shortcuts\n" |
| endif |
| let @f=@f."\" Sorted by ".w:sortdirlabel.w:sorttype.b:suffixeslast.b:filtering."\n" |
| let @f=@f."\"= ".b:completePath."\n" |
| put! f |
| let @f=save_f |
| endfunction |
| |
| |
| "--- |
| " Show the size and date for each file |
| " |
| function! s:AddFileInfo() |
| let save_sc = &sc |
| set nosc |
| |
| " Mark our starting point |
| normal! mt |
| |
| call s:RemoveSeparators() |
| |
| " Remove all info |
| 0 |
| /^"=/+1,$g/^/call setline(line("."),s:GetFileName()) |
| |
| " Add info if requested |
| if w:longlist==1 |
| " Add file size and calculate maximum length of file size field |
| let b:maxFileSizeLen = 0 |
| 0 |
| /^"=/+1,$g/^/let fn=s:GetFullFileName() | |
| \let fileSize=getfsize(fn) | |
| \let fileSizeLen=strlen(fileSize) | |
| \if fileSizeLen > b:maxFileSizeLen | |
| \ let b:maxFileSizeLen = fileSizeLen | |
| \endif | |
| \exec "normal! ".(b:maxFileLen-strlen(getline("."))+2)."A \<esc>" | |
| \exec 's/$/'.fileSize.'/' |
| |
| " Right justify the file sizes and |
| " add file modification date |
| 0 |
| /^"=/+1,$g/^/let fn=s:GetFullFileName() | |
| \exec "normal! A \<esc>$b".(b:maxFileLen+b:maxFileSizeLen-strlen(getline("."))+3)."i \<esc>\"_x" | |
| \exec 's/$/ '.escape(s:FileModDate(fn), '/').'/' |
| setlocal nomodified |
| endif |
| |
| call s:AddSeparators() |
| |
| " return to start |
| keepjumps normal! `t |
| |
| let &sc = save_sc |
| endfunction |
| |
| |
| "---- |
| " Get the modification time for a file |
| " |
| function! s:FileModDate(name) |
| let filetime=getftime(a:name) |
| if filetime > 0 |
| return strftime(g:explDateFormat,filetime) . " ««" . filetime |
| else |
| return "" |
| endif |
| endfunction |
| |
| "--- |
| " Delete a file or files |
| " |
| function! s:DeleteFile() range |
| let oldRep = &report |
| let &report = 1000 |
| |
| let filesDeleted = 0 |
| let stopDel = 0 |
| let delAll = 0 |
| let currLine = a:firstline |
| let lastLine = a:lastline |
| setlocal noreadonly modifiable |
| |
| while ((currLine <= lastLine) && (stopDel==0)) |
| exec(currLine) |
| let fileName=s:GetFullFileName() |
| if isdirectory(fileName) |
| echo fileName." : Directory deletion not supported yet" |
| let currLine = currLine + 1 |
| else |
| if delAll == 0 |
| let sure=input("Delete ".fileName." (y/n/a/q)? ") |
| if sure=="a" |
| let delAll = 1 |
| endif |
| endif |
| if (sure=="y") || (sure=="a") |
| let success=delete(fileName) |
| if success!=0 |
| exec (" ") |
| echo "\nCannot delete ".fileName |
| let currLine = currLine + 1 |
| else |
| d _ |
| let filesDeleted = filesDeleted + 1 |
| let lastLine = lastLine - 1 |
| endif |
| elseif sure=="q" |
| let stopDel = 1 |
| elseif sure=="n" |
| let currLine = currLine + 1 |
| endif |
| endif |
| endwhile |
| echo "\n".filesDeleted." files deleted" |
| let &report = oldRep |
| setlocal nomodified |
| setlocal readonly nomodifiable |
| endfunction |
| |
| "--- |
| " Rename a file |
| " |
| function! s:RenameFile() |
| let fileName=s:GetFullFileName() |
| setlocal noreadonly modifiable |
| if isdirectory(fileName) |
| echo "Directory renaming not supported yet" |
| elseif filereadable(fileName) |
| let altName=input("Rename ".fileName." to : ") |
| echo " " |
| if altName=="" |
| setlocal readonly nomodifiable |
| return |
| endif |
| let success=rename(fileName, b:completePath.altName) |
| if success!=0 |
| echo "Cannot rename ".fileName. " to ".altName |
| else |
| echo "Renamed ".fileName." to ".altName |
| let oldRep=&report |
| set report=1000 |
| e! |
| let &report=oldRep |
| endif |
| endif |
| setlocal nomodified |
| setlocal readonly nomodifiable |
| endfunction |
| |
| "--- |
| " Toggle between short and long help |
| " |
| function! s:ToggleHelp() |
| if exists("w:longhelp") && w:longhelp==0 |
| let w:longhelp=1 |
| let s:longhelp=1 |
| else |
| let w:longhelp=0 |
| let s:longhelp=0 |
| endif |
| " Allow modification |
| setlocal noreadonly modifiable |
| call s:UpdateHeader() |
| " Disallow modification |
| setlocal readonly nomodifiable |
| endfunction |
| |
| "--- |
| " Update the header |
| " |
| function! s:UpdateHeader() |
| let oldRep=&report |
| set report=10000 |
| " Save position |
| normal! mt |
| " Remove old header |
| 0 |
| 1,/^"=/ d _ |
| " Add new header |
| call s:AddHeader() |
| " Go back where we came from if possible |
| 0 |
| if line("'t") != 0 |
| keepjumps normal! `t |
| endif |
| |
| let &report=oldRep |
| setlocal nomodified |
| endfunction |
| |
| "--- |
| " Toggle long vs. short listing |
| " |
| function! s:ToggleLongList() |
| setlocal noreadonly modifiable |
| if exists("w:longlist") && w:longlist==1 |
| let w:longlist=0 |
| let s:longlist=0 |
| else |
| let w:longlist=1 |
| let s:longlist=1 |
| endif |
| call s:AddFileInfo() |
| setlocal readonly nomodifiable |
| endfunction |
| |
| "--- |
| " Show all files - remove filtering |
| " |
| function! s:ShowAllFiles() |
| setlocal noreadonly modifiable |
| let b:filterFormula="" |
| let b:filtering="" |
| call s:ShowDirectory() |
| setlocal readonly nomodifiable |
| endfunction |
| |
| "--- |
| " Figure out what section we are in |
| " |
| function! s:GetSection() |
| let fn=s:GetFileName() |
| let section="file" |
| if fn =~ '/$' |
| let section="directory" |
| elseif fn =~ b:suffixesRegexp |
| let section="suffixes" |
| endif |
| return section |
| endfunction |
| |
| "--- |
| " Remove section separators |
| " |
| function! s:RemoveSeparators() |
| if !g:explUseSeparators |
| return |
| endif |
| 0 |
| silent! exec '/^"=/+1,$g/^' . s:separator . "/d _" |
| endfunction |
| |
| "--- |
| " Add section separators |
| " between directories and files if they are separated |
| " between files and 'suffixes' files if they are separated |
| function! s:AddSeparators() |
| if !g:explUseSeparators |
| return |
| endif |
| 0 |
| /^"=/+1 |
| let lastsec=s:GetSection() |
| +1 |
| .,$g/^/let sec=s:GetSection() | |
| \if g:explDirsFirst != 0 && sec != lastsec && |
| \ (lastsec == "directory" || sec == "directory") | |
| \ exec "normal! I" . s:separator . "\n\<esc>" | |
| \elseif g:explSuffixesLast != 0 && sec != lastsec && |
| \ (lastsec == "suffixes" || sec == "suffixes") | |
| \ exec "normal! I" . s:separator . "\n\<esc>" | |
| \endif | |
| \let lastsec=sec |
| endfunction |
| |
| "--- |
| " General string comparison function |
| " |
| function! s:StrCmp(line1, line2, direction) |
| if a:line1 < a:line2 |
| return -a:direction |
| elseif a:line1 > a:line2 |
| return a:direction |
| else |
| return 0 |
| endif |
| endfunction |
| |
| "--- |
| " Function for use with Sort(), to compare the file names |
| " Default sort is to put in alphabetical order, but with all directory |
| " names before all file names |
| " |
| function! s:FileNameCmp(line1, line2, direction) |
| let f1=s:ExtractFileName(a:line1) |
| let f2=s:ExtractFileName(a:line2) |
| |
| " Put directory names before file names |
| if (g:explDirsFirst != 0) && (f1 =~ '\/$') && (f2 !~ '\/$') |
| return -g:explDirsFirst |
| elseif (g:explDirsFirst != 0) && (f1 !~ '\/$') && (f2 =~ '\/$') |
| return g:explDirsFirst |
| elseif (g:explSuffixesLast != 0) && (f1 =~ b:suffixesRegexp) && (f2 !~ b:suffixesRegexp) |
| return g:explSuffixesLast |
| elseif (g:explSuffixesLast != 0) && (f1 !~ b:suffixesRegexp) && (f2 =~ b:suffixesRegexp) |
| return -g:explSuffixesLast |
| else |
| return s:StrCmp(substitute(f1, "/$", "", ""), substitute(f2, "/$", "", ""), a:direction) |
| endif |
| |
| endfunction |
| |
| "--- |
| " Function for use with Sort(), to compare the file modification dates |
| " Default sort is to put NEWEST files first. Reverse will put oldest |
| " files first |
| " |
| function! s:FileDateCmp(line1, line2, direction) |
| let f1=s:ExtractFileName(a:line1) |
| let f2=s:ExtractFileName(a:line2) |
| let t1=s:ExtractFileDate(a:line1) |
| let t2=s:ExtractFileDate(a:line2) |
| |
| " Put directory names before file names |
| if (g:explDirsFirst != 0) && (f1 =~ '\/$') && (f2 !~ '\/$') |
| return -g:explDirsFirst |
| elseif (g:explDirsFirst != 0) && (f1 !~ '\/$') && (f2 =~ '\/$') |
| return g:explDirsFirst |
| elseif (g:explSuffixesLast != 0) && (f1 =~ b:suffixesRegexp) && (f2 !~ b:suffixesRegexp) |
| return g:explSuffixesLast |
| elseif (g:explSuffixesLast != 0) && (f1 !~ b:suffixesRegexp) && (f2 =~ b:suffixesRegexp) |
| return -g:explSuffixesLast |
| elseif t1 > t2 |
| return -a:direction |
| elseif t1 < t2 |
| return a:direction |
| else |
| return s:StrCmp(substitute(f1, "/$", "", ""), substitute(f2, "/$", "", ""), 1) |
| endif |
| endfunction |
| |
| "--- |
| " Function for use with Sort(), to compare the file sizes |
| " Default sort is to put largest files first. Reverse will put |
| " smallest files first |
| " |
| function! s:FileSizeCmp(line1, line2, direction) |
| let f1=s:ExtractFileName(a:line1) |
| let f2=s:ExtractFileName(a:line2) |
| let s1=s:ExtractFileSize(a:line1) |
| let s2=s:ExtractFileSize(a:line2) |
| |
| if (g:explDirsFirst != 0) && (f1 =~ '\/$') && (f2 !~ '\/$') |
| return -g:explDirsFirst |
| elseif (g:explDirsFirst != 0) && (f1 !~ '\/$') && (f2 =~ '\/$') |
| return g:explDirsFirst |
| elseif (g:explSuffixesLast != 0) && (f1 =~ b:suffixesRegexp) && (f2 !~ b:suffixesRegexp) |
| return g:explSuffixesLast |
| elseif (g:explSuffixesLast != 0) && (f1 !~ b:suffixesRegexp) && (f2 =~ b:suffixesRegexp) |
| return -g:explSuffixesLast |
| elseif s1 > s2 |
| return -a:direction |
| elseif s1 < s2 |
| return a:direction |
| else |
| return s:StrCmp(substitute(f1, "/$", "", ""), substitute(f2, "/$", "", ""), 1) |
| endif |
| endfunction |
| |
| "--- |
| " Sort lines. SortR() is called recursively. |
| " |
| function! s:SortR(start, end, cmp, direction) |
| |
| " Bottom of the recursion if start reaches end |
| if a:start >= a:end |
| return |
| endif |
| " |
| let partition = a:start - 1 |
| let middle = partition |
| let partStr = getline((a:start + a:end) / 2) |
| let i = a:start |
| while (i <= a:end) |
| let str = getline(i) |
| exec "let result = " . a:cmp . "(str, partStr, " . a:direction . ")" |
| if result <= 0 |
| " Need to put it before the partition. Swap lines i and partition. |
| let partition = partition + 1 |
| if result == 0 |
| let middle = partition |
| endif |
| if i != partition |
| let str2 = getline(partition) |
| call setline(i, str2) |
| call setline(partition, str) |
| endif |
| endif |
| let i = i + 1 |
| endwhile |
| |
| " Now we have a pointer to the "middle" element, as far as partitioning |
| " goes, which could be anywhere before the partition. Make sure it is at |
| " the end of the partition. |
| if middle != partition |
| let str = getline(middle) |
| let str2 = getline(partition) |
| call setline(middle, str2) |
| call setline(partition, str) |
| endif |
| call s:SortR(a:start, partition - 1, a:cmp,a:direction) |
| call s:SortR(partition + 1, a:end, a:cmp,a:direction) |
| endfunction |
| |
| "--- |
| " To Sort a range of lines, pass the range to Sort() along with the name of a |
| " function that will compare two lines. |
| " |
| function! s:Sort(cmp,direction) range |
| call s:SortR(a:firstline, a:lastline, a:cmp, a:direction) |
| endfunction |
| |
| "--- |
| " Reverse the current sort order |
| " |
| function! s:SortReverse() |
| if exists("w:sortdirection") && w:sortdirection == -1 |
| let w:sortdirection = 1 |
| let w:sortdirlabel = "" |
| else |
| let w:sortdirection = -1 |
| let w:sortdirlabel = "reverse " |
| endif |
| let s:sortby=w:sortdirlabel . w:sorttype |
| call s:SortListing("") |
| endfunction |
| |
| "--- |
| " Toggle through the different sort orders |
| " |
| function! s:SortSelect() |
| " Select the next sort option |
| if !exists("w:sorttype") |
| let w:sorttype="name" |
| elseif w:sorttype == "name" |
| let w:sorttype="size" |
| elseif w:sorttype == "size" |
| let w:sorttype="date" |
| else |
| let w:sorttype="name" |
| endif |
| let s:sortby=w:sortdirlabel . w:sorttype |
| call s:SortListing("") |
| endfunction |
| |
| "--- |
| " Sort the file listing |
| " |
| function! s:SortListing(msg) |
| " Save the line we start on so we can go back there when done |
| " sorting |
| let startline = getline(".") |
| let col=col(".") |
| let lin=line(".") |
| |
| " Allow modification |
| setlocal noreadonly modifiable |
| |
| " Send a message about what we're doing |
| " Don't really need this - it can cause hit return prompts |
| " echo a:msg . "Sorting by" . w:sortdirlabel . w:sorttype |
| |
| " Create a regular expression out of the suffixes option in case |
| " we need it. |
| call s:SetSuffixesLast() |
| |
| " Remove section separators |
| call s:RemoveSeparators() |
| |
| " Do the sort |
| 0 |
| if w:sorttype == "size" |
| /^"=/+1,$call s:Sort("s:FileSizeCmp",w:sortdirection) |
| elseif w:sorttype == "date" |
| /^"=/+1,$call s:Sort("s:FileDateCmp",w:sortdirection) |
| else |
| /^"=/+1,$call s:Sort("s:FileNameCmp",w:sortdirection) |
| endif |
| |
| " Replace the header with updated information |
| call s:UpdateHeader() |
| |
| " Restore section separators |
| call s:AddSeparators() |
| |
| " Return to the position we started on |
| 0 |
| if search('\m^'.escape(startline,s:escregexp),'W') <= 0 |
| execute lin |
| endif |
| execute "normal!" col . "|" |
| |
| " Disallow modification |
| setlocal nomodified |
| setlocal readonly nomodifiable |
| |
| endfunction |
| |
| "--- |
| " Setup for editing directories after starting up by going to each window. |
| " Required for "vim -o filename dirname" |
| " |
| function! s:EditAll() |
| if winbufnr(2) == -1 |
| return |
| endif |
| let cmd = winrestcmd() |
| let curwin = winnr() |
| while 1 |
| wincmd w |
| if winnr() == curwin |
| break |
| endif |
| call s:EditDir() |
| endwhile |
| exe cmd |
| endfunction |
| |
| "--- |
| " Set up the autocommand to allow directories to be edited |
| " |
| augroup fileExplorer |
| au! |
| " Fill the window when entering the buffer; ":edit dir". |
| au BufEnter * call s:EditDir() |
| " Set the window variables after a split; ":split". |
| au WinEnter * if !exists("w:sortdirection") | call s:EditDir() | endif |
| " Fill the windows after Vim has started up. |
| au VimEnter * call s:EditAll() |
| augroup end |
| |
| " restore 'cpo' |
| let &cpo = s:cpo_save |
| unlet s:cpo_save |
