Welcome to my Vim Page. Herein you'll find a number of scripts, some source
code (needs compiling, but I do have pre-compiled executables for you PC
types), and Vim syntax files. If you'd like to know more about Vim, check out
Vim Online. For more about vi, click on the vi lovers home page. The
syntax files below are often snapshots of my working copies, so sometimes they
may be works-in-progress. Usually such files will say ASTRO-ONLY
somewhere in the top four lines of the file. In any case, the scripts here
will be more up-to-date than the versions, if any, that I put on vim.sf.net.
Nearly all scripts herein will be using the new vimball archive format (*.vba
files) available with vim 7.0 -- it provides for better installation and
automatic helptag generation. If there's a "vba" suffix, you'll need vim 7.0
or later! Vim 7.0 users, however, do need to get a new version of
(vimball);
vim 7.1 users already have a sufficiently up-to-date version of vimball.
This approach allows your cinoptions to be effective, so you get the
indentation style you prefer (abbreviations prevent this). So,
if you use my stubs file, you probably should set the cino option. That way
the stub will be indented in your style. I've included a copy of my cinoptions below;
feel free to incorporate them (my style is the best, of course!) and change them as
you will (aw, shucks).
Intro: Flist
is a program which does a
number of things with C/C++ source files' functions: use it to generate
listings of functions, prototypes, calling trees, tags, and more (see
flist)! You may find the maps in
flistmaps a help in using flist with the
current file in Vim.
Hints: Flist's -h option makes <hints> files.
After you've used flist to generate your hints file, just source it into
your editing session or put the following code into your
<.vimrc> for automatic sourcing of hints:
if filereadable(expand("hints"))
au BufNewFile,BufReadPost *.c,*.C,*.cpp,*.CPP,*.cxx so hints<CR>
endif
The result? Every time you type a function name, a prototype for it will
appear on the information line. In order to see it, you should set your
cmdheight to 2 or more (:set ch=2) and possibly have showmode off (:set nosmd).
Maps: Along with flist itself I've
provided a small set of maps which use flist. The maps take the form
\[px][pxgs]: prototype or extern, and prototype, extern, global, and static.
The map invokes flist against the current file and inserts a list of
(global/static/both) prototypes or extern-style function declarations. The \pc
map inserts a list of prototypes suitable for inclusion in a comment.
Source Trees: Flist's -Tg option builds a tree-like graph of function use.
Coupled with the Flist-based Tree plugin for vim 6.0 or later,
one can browse the calling tree on the left hand side of the screen,
select a function to edit by putting the cursor on its line, and hitting
return. Put <FlistTree.vim> into your plugin directory; you may then use the
command :Flist [filename(s)] to begin graph-tree editing. See the
usage notes in <FlistTree.vim> for more commands! Click for a
screenshot if you'd
like to see it first.
Dummy Functions: Flist includes a -D option, which generates "dummy" function
definitions. In order to make trees, flist makes a pass over all the source
files to determine what functions are present, and then a second pass to
determine what functions are called by what functions. Thus common functions
(such as printf) are ignored, and the structure of your program is usually
better revealed. However, if you want to know where such functions are called,
or functions that were defined in your own personal library, you may wish
to set up a file containing a list of such functions with no
body (or even arguments). That way flist will process the dummy file
quickly. The -D option allows one to generate such a dummy file easily
from real ones.
| Calling Options | Explanation |
| flist *.c | list functions in files |
| flist -d *.c | generate a <ctags> file |
| flist -e *.c | generate an <etags> file |
| flist -h *.c | generate a <hints> file |
| flist -p *.c | list prototypes |
| flist -t *.c | list of functions for inclusion in a comment |
| flist -x *.c | list functions as externs |
| flist -Ta *.c | list calling tree, all roots |
| flist -Tg *.c | "graphical" calling tree |
| flist -Tf *.c | functions found report |
| flist -Tu *.c | functions used/called-by report |
| flist "?" | help |
Color Scheme
I've included Vim-script which implements my choice for syntax
highlighting. Please check out my page on DrChip's colorscheme
for the colorscheme I use. I like keeping the same colorscheme for both
gui (gvim) and console (vim); the latter restricts the number of colors available, so such dual-use
colorschemes must needs be designed for the limitations of the console.
Columnizing
Ever wished to convert a list of words into a multi-column list
(such as ls produces)? Mcol will do that for you (see Links below),
and check out some of my mcol-using scripts in mcol.vim.
+---------+------------------------------------------------------+
|Original | Using ma on "one", moving to "six", and typing \mn3|
|List | map \mn3 0!'amcol -n3<CR> |
+---------+------------------------------------------------------+
|one | |
|two | |
|three | one three five |
|four | two four six |
|five | |
|six | |
+---------+------------------------------------------------------+
DrChip's Online Tips and Scripts
| Script | aftersyntax: allows multiple after/syntax/[lang]/files.vim |
| Script | Align: alignment by multiple separators |
| Script | AnsiEsc: highlighting by ansi escape sequences plus concealment |
| Script | AsNeeded: loading vim scripts on demand |
| Script | astronaut: same syntax highlighting for console and gui |
| Script | AutoAlign: auto-alignment of = := etc as one types |
| Script | blockhl: highlighting of {} level for C/C++ |
| Script | cecscope : command and menu driven cscope interface |
| Script | cecutil : some utilities used by other of my scripts |
| Script | CVSconflict : CVS conflict resolution using vimdiff |
| Script | Decho: supports script debugging |
| Script | DrawIt!: ascii line drawing (lines, ellipses, fills, etc) |
| Script | drcstubs: ftplugins to support quick and easy language constructs |
| Script | drc_indent: various indent files |
| Script | EasyAccents: making accents easy |
| Script | engspchk: spelling checker |
| Script | ephtml: extended perl html syntax highlighting |
| Script | foldcol: inline fold a visual block (column) |
| Script | GetLatestVimScripts.vim: how to keep your scripts from vim.sf.net up-to-date |
| Script | gvcolors: displays X colornames in their own colors |
| Script | HelpExtractor: vim+help bundling |
| Script | hicolors: display current highlighting scheme colors + colorscheme editor |
| Script | HiCurLine: Highlights the current line |
| Script | HiMtchBrkt: Highlights the current line |
| Script | hints_man2.vim: Hints for C Library Functions (man2 based) |
| Script | hints_man3.vim: Hints for C Library Functions (man3 based) |
| Script | LargeFile: Edit large files quickly |
| Script | LogiPat: Boolean Logic Patterns |
| Script | Manpageview : vim-based manpage viewing |
| Script | maplesyrup : indenting, autoalign, and matchit support for Maple V |
| Script | math: Math keymap and a menu for inserting math symbols |
| Script | Mines: a game |
| Script | mrswin: a toggling version of mswin.vim |
| Script | netrw: Network Oriented Reading and Writing |
| Script | pluginkiller: helps plugin writers find troublesome options |
| Script | vimball: vim-based archiver builder and extractor |
| Script | vis: VisualCommands, Substitutes, and Searches |
| Script | visincr: visual-block based incremented lists |
| Script | RunView: Run scripts through filter and display output in separate window |
| Script | SeeTab : makes tabs visible as alternating bars |
| Script | WhereFrom :helps one locate where maps, scripts, and functions are defined |
| Script | ZoomWin : zoom into a window, zoom out to all windows |
| Tip | Swapping characters, words, and lines |
| Tip | Alignment: =, LaTeX tables, declarations, etc |
| Tip | Applying substitutes to a visual block |
| Tip | Deleting a buffer without changing your window layout |
| Tip | Generating a column of increasing numbers |
| Tip | Getting the official distribution's latest: syntax highlighting, runtime, docs, plugins, etc |
| Tip | How do I get rid of that bold stuff with my xterm? |
| Tip | How to initialize plugins |
| Tip | How to overwrite a visual-block of text with another such block |
| Tip | How to sort using visual blocks |
| Tip | How to tell what syntax highlighting group *that* is! |
| Tip | How to toggle between all vertical and all horizontal window layout |
| Tip | How to write a plugin |
| Tip | Maps, Commands, and Functions - some examples of their interplay |
| Tip | Opening gvim atop a console window |
| Tip | Repeating a substitute from current cursor position |
| Tip | Restore cursor to file position in previous editing session |
| Tip | Using vim as a man-page viewer under Unix |
Patches
- getfsize patch
This patch extends getfsize({fname}) to getfsize({fname}[,unitsize]).
The optional second argument specifies the units that getfsize()
will return the file size in. It's useful for handling file
sizes that are over 2GB.
- Lua patch
This patch, by Luis Carvalho, provides internal vim support for Lua (akin to vim's support for perl, etc).
- Relative Numbering Patch
This patch, by Markus Heidelberg, provides for relative numbering.
- v:oldfiles support
This patch, by Bram Moolenaar, provides v:oldfiles.
PC: Pre-Compiled Executables
I've included some pre-compiled executables for the PC for which I used a Borland
C/C++ compiler (under Miscellaneous in the Links).
As a bonus, I've thrown in my calculator program, too. You should
still get the source code distributions; if you have ansi escape sequences enabled
for your MS-DOS windows, and have <rdcolor.dat>, prompts and help will come
up in color. The copyright notices associated with the source distributions also
still apply to the executables.
Short Vim Command List
If you've gotten here, I'm sure you realize that Vim has a large
number of commands -- that is, commands that one can do while
in normal mode. That's not counting the command mode commands!
Check out the Real Short Vim Normal-Mode List of Commands.
Spelling Checker
The English spelling checker
(under Scripts in the Links)
uses Vim's native syntax highlighting ability to make
misspelled (English) words show up as an "Error" (usually white on a red
background). The Vim-based English spell checker also supports entering words
that the cursor is on into a temporary or permanent dictionary and allows one
to skip to the previous or subsequent spelling error (if any). It co-exists
quite well with TeX, LaTeX, Html, and other such specialized text, and can
be used to check the spelling inside comments in various programming languages.
Getting Started:
The English spelling checker now comes as a "tarball":
gunzip the file <engspchk.tar.gz> and
tar -oxvf engspchk.tar in the .vim or _vimfiles
directory.
The English spelling checker is a plugin; it
does a quick load and makes a map for \ec (actually the \
is <Leader> which can be changed; see :he mapleader).
The dictionary isn't loaded until one types \ec.
It also creates a menu item to load the spelling checker for gvim
(the gui).
The custom user dictionary and optional Webster's 1913 dictionary
is stored using the path specified by the vim variable g:cvimsyn,
settable in the <.vimrc>.
If that variable isn't set, then the CVIMSYN environment
variable, if it exists, is used.
If you want to use the environment variable approach:
| sh | CVIMSYN="path";export CVIMSYN |
| csh | setenv CVIMSYN "path" |
| ksh | export CVIMSYN="path" |
| Windows 95,98 | in <autoexec.bat>: |
| | set CVIMSYN=..path.. |
| Windows 2000,NT,etc | Right click on <My Computer> |
| | Choose <Properties> |
| | Click <System Properties> |
| | Click <Advanced> tab |
Moving:
For Vim versions 5.04 and later, the <engspchk.vim>
file additionally provides two maps (\en and \ep) to move to the next and preceding
spelling error, if any. I suggest you upgrade if you haven't already, because
Vim's functions are powerful!
Custom Dictionary:
Engspchk allows the user to temporarily save (\et) or to
permanently save (\es) words the user uses but somehow isn't in
Engspchk's dictionary. A temporary save only affects the current
vim editing session; a permanent save writes the word to a custom user dictionary
which is automatically loaded in the future.
Alternatives:
For Vim version 6.0 and later, <engspchk.vim>
provides the (\ea) map which brings up a one-line alternatives window for the
word under the cursor. Move left and right with the full power of Vim, and
when the cursor lies on the desired substitute word, a simple carriage return
will cause replacement. You'll also need to have the
agrep
program to do this (there's a pre-compiled for Windows version available using
this link). The first use of (\ea)
takes longer than subsequent use because the script that gets invoked constructs
a plain list of words from the engspchk file.
No Flashing:
With Vim version 6.0y and later and starting with version 2.04 of
engspchk no longer will Error highlighting flash on and off while you're
typing. Thanks go to Chase Tingley (with emendations by Bram Moolenaar) who
wrote the changes to Vim to make this possible.
More Words: Previously the
<wb1913_engspchk.vim> file was provided separately, but it is
now provided in the <engsphck.tar.gz> tarball. still optional if you'd
rather not load it. Webster has provided an electronic copy of the words from
its 1913 edition; those words that appear in that dictionary that don't appear
in <engspchk.vim>'s dictionary itself are provided in the
<wb1913_engsphck.vim> file. If the file appears in the directory
specified by the g:cvimsyn variable (or by the CVIMSYN environment variable)
then it is loaded automatically.
Other Languages: There are now variants of
<engspchk.vim> for Dutch, German, Hungarian, Polish, and Yiddish. Engspchk
has been improved so that mostly all that's needed are the dictionaries themselves.
I'd appreciate it if you could let me know where on the Web to find it so I can make a link on
this page to it!
Thomas Köhler has made his create script which
uses the Bourne shell; it merges a dictionary with engspchk.vim to
create a spelling checker for another language.
Since vim 7.0 and later now includes embedded spell checking, I've removed
most of the spelling dictionaries. If someone is still interested, please
send me an email (NdrOchip@ScampbellPfamily.AbizM - NOSPAM) and I'll send
you a copy. Unfortunately, I'm limited on my webspace, and I needed the
space! I have dictionaries for Dutch, French, German, Hungarian, Italian,
Polish, Russian, and Spanish.
To see a screenshot, please click on this.
Tag Generation
I have written my own tag generating program (see Links);
although Exuberant Ctags is good, I know how to modify hdrtag
to suit me. It contains tagging generation for c/c++, c/c++ header files,
lex, yacc, TeX (cites and labels), vim scripts (functions and syntax), and Maple V.
Exuberant Ctags will no longer be distributed with vim as of v6.0i. I've provided
a link to its homesite in the source code-related links below.
Text Alignment
The alignment scripts (<Align.vim> and <AlignMaps.vim>) now supplant
the older external filter approach. The new scripts, which include help and
plentiful examples, provide:
- cyclic left, right, and centering justification of fields
- cyclic or equivalent regular-expression separators
- cyclic left, right, and centering of multi-length separators
- improved initial white space control: retain, eliminate, re-use first
- specifiable separator padding
- visual range specified alignment, including via visual-block
- multiple maps in <AlignMaps.vim> which tackle complex
alignment problems, such as aligning C/C++ declarations,
function argument lists, etc.
See my DrChip's Alignment Tool for Vim page for links and examples.
An alternative aligner is available from
Gergely Kontra
(Johannes Zellner used to have one available, but apparently his site has disappeared).
Useful Maps
- Date maps (year-month-day, month-day-year, etc)
imap <Leader>ymd <C-R>=strftime("%y%m%d")<CR>
imap <Leader>mdy <C-R>=strftime("%m/%d/%y")<CR>
imap <Leader>ndy <C-R>=strftime("%b %d, %Y")<CR>
imap <Leader>hms <C-R>=strftime("%T")<CR>
imap <Leader>ynd <C-R>=strftime("%Y %b %d")<CR>
com! YMD :norm! i<C-R>=strftime("%y%m%d")<CR>
com! MDY :norm! i<C-R>=strftime("%m/%d/%y")<CR>
com! NDY :norm! i<C-R>=strftime("%b %d, %Y")<CR>
com! HMS :norm! i<C-R>=strftime("%T")<CR>
- Determining the highlight group that the word under the cursor belongs to
nmap <silent> <F10> :echo "hi<" . synIDattr(synID(line("."),col("."),1),"name") . '> trans<' . synIDattr(synID(line("."),col("."),0),"name") . "> lo<" . synIDattr(synIDtrans(synID(line("."),col("."),1)),"name") . ">"<CR>
- Mirrors and Reversals:
nno <silent> <Leader>fr :set lz<cr>'aO<esc>ma'':'a+1,.g/^/m 'a<cr>kdd:set lz!<cr>
vno <silent> <Leader>fr :<c-u>set lz<CR>O<esc>V'>:g/^/m '<<cr>'<dd:set lz!<cr>
nmap <silent> <Leader>fR V'a\fR
vno <silent> <Leader>fR c<C-O>:set ri lz<cr><C-R>"<esc>:norm! dd`<<cr>:set ri! lz!<cr>
- Insertion mode Completion Function Key Maps (press while in insert mode to see list)
" <F1> <c-x><c-L> completion: whole line
" <F2> <c-x><c-N> completion: keywords using current file
" <F3> <c-x><c-K> completion: keywords using dictionary
" <F4> <c-x><c-T> completion: keywords using thesaurus
" <F5> <c-x><c-I> completion: keywords in current and included files
" <F6> <c-x><c-]> completion: tags
" <F7> <c-x><c-F> completion: file names
" <F8> <c-x><c-D> completion: definitions or macros
" <F9> <c-x><c-V> completion: vim command line
" <F10> <c-x><c-O> completion: omni completion
ino <silent> <F1> <c-x><c-L>
ino <silent> <F2> <c-x><c-N>
ino <silent> <F3> <c-x><c-K>
ino <silent> <F4> <c-x><c-T>
ino <silent> <F5> <c-x><c-I>
ino <silent> <F6> <c-x><c-]>
ino <silent> <F7> <c-x><c-F>
ino <silent> <F8> <c-x><c-D>
ino <silent> <F9> <c-x><c-V>
ino <silent> <F10> <c-x><c-O>
ino <silent> <F11> <C-O>ma<C-O>yiw<C-O>:ptag <C-R>"<CR><C-O>`a
ino <silent> <s-left> <c-x><c-p>
ino <silent> <s-right> <c-x><c-n>
ino <silent> <F12> <c-o>:echo 'completes[ F1:line F2:keywrd F3:dict F4:thes - F5:fromfile F6:tags F7:fname F8:defns - F9:vimcmd F10:omni ] F11:ptag-iw F12:funkey help'<CR>
- Moving up/down by function, unfolding current function but folding all else
noremap [[ [[zMzvz.
noremap ]] ]]zMzvz.
- Some typical settings for viminfo that I use:
set viminfo=!,'10,\"100,:20,%,nc:\\cec\\_viminfo
set viminfo=!,'25,\"100,:20,%,n~/.viminfo
- Transferring blocks of text between vim sessions
nmap <Leader>xr :r $HOME/.vimxfer<CR>
nmap <Leader>xw :'a,.w! $HOME/.vimxfer<CR>
vmap <Leader>xw :w! $HOME/.vimxfer<CR>
nmap <Leader>xa :'a,.w>> $HOME/.vimxfer<CR>
vmap <Leader>xa :w>> $HOME/.vimxfer<CR>
nmap <Leader>xS :so $HOME/.vimxfer<CR>
nmap <Leader>xy :'a,.y *<CR>
vmap <Leader>xy :y *<CR>
Vim Functions, Plugs, and Stubs
VIM 7.0 USERS: BE SURE TO GET THE LATEST VIMBALL PLUGIN BEFORE ATTEMPTING TO USE SCRIPTS UPLOADED ON OR AFTER AUG 1, 2006
Various functions, plug-ins, and quick-insertion stubs follow alphabetically. There are several
plugins that I post both here and at vim.sf.net.
Scripts here are my most up-to-date ones and may be considered as alpha/beta releases;
I tend to put the ones I'm updating/fixing here. After a bit of feedback, and a variable length
of time (ie. whenever I get around to it), I will also post the scripts on
vim.sf.net.
I use three release states with my plugins:
- NOT RELEASED -- my latest version (labelled v[0-9]*[a-z], ex. v3b).
May be handed out to individuals while I'm attempting
to debug some problem they're having. The version
number will remain fixed while the plugin is in this
state. These versions of my plugins shouldn't get
generally released, but accidents happen.
- ASTRO-ONLY -- a somewhat experimental version of a plugin, like
"NOT RELEASED" versions, also labelled with a trailing
letter such as v[0-9]*[a-z] (ex. v3b). These versions
do have their trailing letter changed as they get
updated. These versions appear on this website.
- (nothing) -- the plugin has been released on vim.sf.net
and concurrently on my own website. These versions drop the trailing
letter, having the format v[0-9]* (ex. v3). Those plugins which Bram has
picked up for releasing with Vim have also been forwarded to Bram.
In other words, I use the ASTRO-ONLY stage as an alpha/beta release, and NOT
RELEASED as an alpha. This process is supposed to help get the bugs out before
its released to potentially thousands.
If you have some feedback (problems or kudos!), please send an email to NdrOchip@ScampbellPfamily.AbizM
(remove the embedded NOSPAM therein first, of course).
-
| Updated Apr 07, 2005 (v2a) |
Several directories, such as .vim/after/syntax, allows multiple files
therein but does not look into sudirectories therein. By copying this
file to such a directory, and renaming it using the subdirectory name + ".vim",
the subdirectory name will be scanned for any and all *.vim files and such
files will be loaded.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
Also available at vim.sf.net where you may rank it.
- DrChip's Astronaut Colorscheme
| Updated Aug 10, 2006 (v8c) |
The astronaut.vim colorscheme
(see DrChip's colorscheme for more about it)
provides a constant colorscheme for both gvim and vim.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Alignment
| Updated Nov 24, 2009 (v36c) |
Aligns text based on patterns (see page for more!).
NOTICE: The latest version of Align and AlignMaps given here need vim 7.0aa.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
Also available at vim.sf.net where you may rank it.
- Alignment Maps
| Updated Jan 06, 2010 (v42f) |
Provides numerous maps to facilitate text alignment(see page for more!)
Also available at vim.sf.net where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Ansi Highlighting
| Updated Feb 01, 2010 (v10h) |
Source this in and ansi escape coloring sequences,
The AnsiEsc plugin provides a single command: :AnsiEsc ,
which will toggle Ansi-escape sequence processing.
When enabled, AnsiEsc will handle <esc>[FGm,
<esc>[ATTR;FGm, and <esc>[FG;BGm sequences;
subsequent text will then be colored appropriately. The escape sequence itself
takes space but will be suppressed using "Ignore" highlighting.
Ideally the escape sequences would be folded out but that capability isn't in vim yet (vim's folding is line-based).
Vince Negri's conceal plugin works really well with AnsiEsc.
See the link for Vince Negri's ownsyntax/conceal patch below.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
Also available at vim.sf.net
where you may rank it.
- AsNeeded
| Updated Oct 21, 2009 (v17d) |
Supports automatic sourcing (loading) of functions as needed. AsNeeded.vim is a plugin
that sources other scripts in the .vim/AsNeeded directory when a function is called
that is needed. One may use :AsNeeded command or :AN command. AsNeeded actually
supports as-needed sourcing for functions, maps, and commands.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- AutoAlign suite
| Updated Sep 21, 2009 (v14e) |
Uses the Align.vba.gz
package to facilitate aligning equations, etc, as you type them.
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Blockhl: Nesting Level Based Highlighting For C
| Updated Aug 29, 2008 (v6a) |
Blockhl controls the highlighting of leading tabs based on the nesting level of {}s
for the C and C++ languages by providing a sequence of graylevels.
The file should be put into the .../after/syntax/c directory.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Calendar Utilities
| Updated Oct 08, 2008 (v3b) |
Used by visincr.vim (which is described
below), <calutil.vim> provides three calendar-related functions:
DayOfWeek(y,m,d), Cal2Jul(y,m,d), and Jul2Cal(julday). DayOfWeek() converts a date
to a day of week name, and the other two convert between dates and the Julian day.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Cecmatrix: Matrix Handling
| Updated Jan 04, 2008 (v1b) |
This plugin provides:
- The MatInit command -- use visual block mode to define a Matrix
- MatAdd, MatSub, MatMult, and MatTpose commands (and functions) to add, subtract,
multiply, and transpose matrices
- The MatWrite command -- to write one or more matrices into your text
Uses the Align and cecutil plugins.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Cscope Interface
| Updated Jun 23, 2009 (v5b) |
(vim v7.0 only) Cscope interface to find functions which call functions,
are called by functions, etc. Put in your .vim/plugin directory, and
try :CSh for help. There's optional local quickfix windows, vertical
or horizontal window with cscope output, menus, etc.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- DrC's Utilities contains various functions and some maps:
| Updated Aug 20, 2009 (v18d) |
Marks: SaveMark(markname) RestoreMark(markname) DestroyMark(markname)
Pos'n: SaveWinPosn() RestoreWinPosn() \swp \rwp (actually uses )
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- C Function Menu Generator
Marcel van der Laan wrote a function
:call C_ListFuncs() which uses flist to
generate a menu of functions in the current file.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- C Compiler Commands
| Updated Jan 05, 2006 (v1) |
The compiling.vim plugin
provides error format files for several C compilers, plus
a :Chk command to show one window with source with lines with errors and warnings
given Error highlighting and a quickfix window showing the associated messages.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- CtagExpl: Ctags Explorer
| Updated Feb 04, 2009 (v1i) |
An explorer for tags files generated by exuberant ctags; much like
Lakshmanan's taglist explorer. However,
CtagExpl cooperates with gdbmgr, providing it with a tags-based explorer.
- CVS Conflict File Handler
| Updated Nov 25, 2008 (v2f) |
When one does "cvs update", one may get files marked with "C" for
conflict. Cvs was unable to automatically merge one's local
version with the repository, and merging requires human intervention.
The :CVSconflict command takes the current conflict file,
splits it into two separate files, and enables vimdiff-style
editing and viewing.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Decho: DrC's Vim Debugger
| Updated Sep 02, 2009 (v21g) |
The Decho.vim plugin provides debugging messages in a separate window.
One puts
Decho "some message here"
-or-
call Decho("another message")
and Decho will split the screen with a five line debugging window on the
bottom of the display where the messages will appear. Allows one to
inspect multiple error messages with the usual vim editing commands!
More help and commands are available with Decho's help.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- DotFill
| Updated Apr 11, 2006 (v1a) |
Facilitates setting up aligned columns with user-specified fill-characters. Often used with contents
pages. Example of usage: :[range]DotFill . (to fill with dots)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- DrawIt.vba.gz
| Updated Jan 21, 2010 (v11h) |
A plugin for drawing vertical, horizontal, and slanted lines using text.
With DrawIt, one may use the number pad to leave a trail of dashes,
bars, etc behind. Furthermore, it also supports using visual-block specified regions
to draw boxes, ellipses, arrowheads, lines, and to specify floods.
Also available at vim.sf.net
where you may rank it. The version here requires vim 7.0!!!
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Stubs
| Updated Jan 14, 2010 (v3d) |
Supports quick entry of language constructs for C, sh/ksh/bash, LaTeX, and vim.
Ie. while in insert mode and using C, a if` will result in
a if(){} construct entered into your code with the
cursor appropriately positioned for further insertion. When done with entering
the test expression, hitting <esc&rt; will place your cursor (in insert mode)
after the "{". (also see Abbreviations for C)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- EasyAccents.vim
| Updated Sep 08, 2008 (v9) |
A plug-in that makes using accented characters easier
Also available at vim.sf.net
where you may rank it. (Version 8)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Engspchk (spelling checker)
| Updated Sep 02, 2009 (v65d) |
A multiple-human-language spell checking tool!
Supports on-the-fly spell-checking, spelling suggestions,
the mouse (when available), and menus (gvim).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- FlistTree
| Updated Jan 02, 2008 (v9b) |
Shows a graphical function-usage tree. See FlistTree.vim itself for instructions.
(uses flist, a program)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlight
| Updated Nov 26, 2008 (v1b) |
Highlights patterns (like :match, :2match, etc, except any number of such highlights may be used).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Indent Files by DrC
| Updated May 03, 2005 (v1) |
The drc_indent.vim package of indent files provides DrC's indent files and customizations for sh, vim, tex, and maple.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- foldcol.vim
| Updated Feb 01, 2010 (v3b) |
Coupled with Vince Negri's conceal/ownsyntax patch, foldcol
makes it possible to fold columns of text from view.
Also available at vim.sf.net where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- funcsrch.vim
| Updated Jan 25, 2006 (v2a) |
Permits searches to be taken only within a function, as
defined by [[ (for start of function) and ][ (for end of function). These normal
commands may, of course, be defined as maps in the ftplugin directory to customize
them for specific languages.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Gnu Debugger Manager for Vim
| Updated Dec 18, 2009 (v1u) |
- Provides an interface between vim and gdb: no patches!
- No external interpreters are used (ie. no perl, no python, ...). However, it does appear to be necessary to have perl, python, or ruby support
compiled into your vim to get the shared library call that it uses to work properly. To use it with ruby enabled you'll also need to link
vim with EXTRA_LIBS=-lutil . I'm afraid that I don't have tcl available to test if that, too, fixes the shared library call.
- Integrated multi-window displays include: Messages, Function Stack, Source, Expressions, Breakpoints, Watchpoints, and Netrw.
(you'll be wanting the latest netrw available from this website)
- Snapshot 1
Snapshot 2
- Its distributed as a gzipped tarball instead of the vimball format usually used here as it contains some binaries (the two xpm files for the breakpoint signs)
- Currently tested only under Linux; it definitely does need a Unix-like environment.
- Integration with vim and gdb is provided by the plugin itself with vim's libshare() function and a shared library (C code provided)
- getscript.vba.gz
| Updated Dec 28, 2009 (v32) |
This plugin's :GetLatestVimScripts command (or :GLVS for short)
will automate grabbing the latest version of the plugins and scripts that you
express an interest in by putting a line into the GetScript/GetScript.dat
file. With cooperating plugins, GetScript can build the data file itself, too.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball.
Unfortunately, there was a bug that makes the getscript.vim version that was distributed with vim v7.0
cause difficulties with a vimball-installation of a new getscript.vim. So, you'll need to remove
the older version of getscript.vim:
- Change directory to the directory holding the vim 7.0 distribution's plugin/ and autoload/ directories.
- /bin/rm plugin/getscript*.vim autoload/getscript*.vim doc/pi_getscript.txt
- gvcolors
| Updated Oct 08, 2008 (v7b) |
Gvim colors -- displays a list of named colors that gvim has available
with X; each color shows up in its own color! One can toggle between dark and bright backgrounds
by using a rightmouse click. A leftmouse click on a color brings it to the
top line of the display. The colors at the top of the display have their
red-green-blue values, in decimal, on the bottom of the screen.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Hdrtag Explorer
| Updated Feb 04, 2009 (v1o) |
Explore tags in a left-hand window with the :Hdrtag command.
Intended to support the hdrtag program by providing
a taglist-like interface for it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- More Help Syntax Highlighting
| Updated Nov 23, 2009 (v1e) |
This script will add extra highlighting and syntax-based folding to the vim help pages.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- HelpExtractor
| Updated May 25, 2005 (v3) |
This script can be used to make .vim scripts automatically install help.
Also available at vim.sf.net
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlight Colors Help and Editor
| Updated Sep 02, 2009 (v9k) |
Shows highlighting colors in their own colors, plus a colorscheme editor!
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlight Current Line
| Updated Sep 02, 2009 (v8c) |
With this plugin the current line will be highlighted
Also available at vim.sf.net where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlight Marks
| Updated Mar 20, 2008 (v2c) |
Highlights marks by using the signs feature (your vim needs to be compiled for big/huge).
Required: Kruize and Gedde's ShowMarks.vim plugin, which does most of the work. Its at
vim.sf.net .
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Hints for Library Functions (man2 based)
| Updated Mar 13, 2007 (v1) |
Shows prototype hints as one types a function (man page 2 based)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Hints for Library Functions (man3 based)
| Updated Mar 13, 2007 (v1) |
Shows prototype hints as one types a function (man page 3 based)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- HiLinkTrace
| Updated Feb 23, 2009 (v4j) |
A plugin which traces the highlighting linkages; ie. just what highlighting
groups associated with the word under the cursor? (hilinks.vim, implements a map "\hlt")
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Highlighting Matching Brackets
| Updated Oct 28, 2009 (v23i) |
A Vim 6.0 plugin that highlights a matching bracket
when the cursor moves on it. Uses HelpExtractor to set up its help.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- LaTeX Maps
| Updated May 19, 2009 (v2g) |
Supports quick entry of LaTeX constructs (ie. ".." becomes
``..'', enum` gets expanded to \begin{enumerate}, etc).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- LargeFile
| Updated Jan 25, 2010 (v5d) |
Allows much quicker editing of large files (default: 100MB+ are "large"), at the price of turning
off events, undo, syntax highlighting, etc.
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Library Viewer
| Updated Sep 17, 2009 (v1h) |
This plugin uses the "nm" utility to present an overview of the contents of archive and object files.
Its based on autocmds, and so to use it all one needs do is to open an archive (*.a), an object (*.o) file,
or a shared library (*.so) by attempting to edit it. (formerly known as the archive/object visualizer)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- LogiPat
| Updated Sep 25, 2006 (v3b) |
Provides a :LogiPat {boolean-logic pattern} and forms a search.
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Maintainer
| Updated Mar 27, 2006 (v2a) |
Use ":echo Maintainer" to find
out who the maintainer is of the syntax file you're
currently using; ":echo Maintainer("language")"
to determine the Maintainer of a specific language (ie. c, vim, tex, jsp, etc).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Man Page Viewer
| Updated Oct 26, 2009 (v23d) |
A plugin which facilitates the viewing of man pages under Unix systems;
supports :Man topic, :Man topic booknumber, :Man booknumber topic, and
:Man topic(booknumber). While in a man page the K key will invoke manpaging
on the word under the cursor.
Also available at vim.sf.net
where you may rank it. Supports perl (*.pl, *.upl) and info (*.i), too.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Maple Syrup
| Updated Jan 25, 2006 (v3b) |
This tarball contains multiple files to support MapleSoft's Maple programming
language for symbolic algebra. Included: indent, auto-align, and matchit support.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Math Keymap
| Updated Jan 07, 2010 (v3g) |
Contains a keymap supporting math under utf-8. Install in the regular vimball way; to use it, ":set kmp=math" when in vim.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Mines
| Updated Sep 02, 2009 (v18a) |
A game for vim implementing the world famous game of Mines!
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Multi-Column Listing
| Updated Dec 24, 2009 (v1b) |
The mcol.vim plugin
converts a list of words into a multi-column listing, much as "ls" does with a list of files.
It uses the mcol program; see mcol to get a copy of the source.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- MultiPage
| Updated Sep 02, 2009 (v1i) |
The mpage.vim plugin supports using multiple windows as separate pages to view windows, with each
sequential window showing sequential lines of text.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Network Oriented Reading, Writing, and Browsing
| Updated Jan 21, 2010 (v137b) |
Supports network-oriented editing with urls. One may read and write files
using one of several supported protocols (ex: ftp, scp) and browse
directories, both remotely and locally. This version requires vim 7.0.
Be sure to remove any older versions of netrw before attempting to install this version.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball.
Unfortunately, there was a bug that makes the netrw version that was distributed with vim v7.0
cause difficulties with a vimball-installation of a new netrw. So, for vim v7.0, you'll need to remove
the older version of netrw:
- Change directory to the directory holding the vim 7.0 distribution's plugin/ and autoload/ directories.
- /bin/rm plugin/netrw*.vim autoload/netrw*.vim doc/pi_netrw.txt
Beginning with v108b of netrw: sourcing remote files is supported.
Here's a list of some netrw options that I myself use:
let g:netrw_altv = 1
let g:netrw_fastbrowse = 2
let g:netrw_keepdir = 0
let g:netrw_liststyle = 2
let g:netrw_retmap = 1
let g:netrw_silent = 1
let g:netrw_special_syntax= 1
- Netrw Clean
| Updated Oct 07, 2008 (v1b) |
The netrwclean.vim plugin will attempt to remove the netrw plugin: with :NetrwClean, only the personal directory copy
will be cleaned. With :NetrwClean!, this plugin will attempt to remove netrw from both your personal directory
and the system directory. You need permission to remove such files, of course. This plugin may be helpful
for those who've previously gotten an up-to-date version of netrw but then update their vim later via ftp, cvs, etc
with an even more recent version of netrw (in that case, use :NetrwClean).
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- pluginkiller.vba.gz
| Updated Feb 07, 2009 (v3) |
Plugin writers! Have you ever wished you could find what option settings
will interfere with your plugin before your users do? The pluginkiller
helps automate finding such troublesome settings.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Rainbow Brackets
| Updated Nov 18, 2009 (v2n) |
This plugin provides a rainbow of colors for matching brackets ( [] () {} ) depending
on their nesting level ; it is intended to support the C and C++ languages. The syntax file
distributed with Vim for Lisp already supports rainbow highlighting of ()s; bring up vim and
type ":help ft-lisp-syntax".
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- RltvNmbr
| Updated Nov 21, 2008 (v3) |
Shows relative numbering signs (ie. relative to the cursor's current position).
Really easy to use: :RltvNmbr to enable, and :RltvNmbr! to disable.
However, your vim does need to support the signs feature (:version should show +signs); try compiling vim for the "huge" feature.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Rndm
| Updated Aug 12, 2008 (v4f) |
Returns random variates
- Rndm() returns uniformly distributed variates on [0, 100,000,000)
- Urndm(a,b) returns uniformly distributed variates on [a,b])
- Dice(qty,sides) rolls qty of sides-sided dice and adds them up
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- RunView
| Updated Sep 17, 2009 (v3b) |
:[range]RunView[!] filtercmd
{visual line selection}\rh
{visual line selection}\rv
RunView passes user-selected lines through a filter (default filter specified by
g:runview_filtcmd); output from the filter is placed into a separate window.
Multiple runs of the filter are clearly separated in the filter output window.
Great for debugging scripts!
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- SeeTab
| Updated Jun 05, 2008 (v4b) |
Makes leading tabs more visible
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Showing Current Function Name in Status Line
| Updated Sep 02, 2009 (v2h) |
This package of a plugin and ftplugins manipulates the status line to show the name of the current function that
the cursor is in. Currently supported: C, DrChip's debugger output, and Vim.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Swapping Two Strings
| Updated Jan 21, 2009 (v1h) |
Use this plugin to easily swap strings!
:[range]SwapStrings string1 string2
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Tar Handler
| Updated Dec 28, 2009 (v24) |
Michael Toren wrote a nice plugin to handle tar files.
I've written a related one that also handles writing changed files back into the tarball.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball.
Unfortunately, there was a bug that makes the zip.vim version that was distributed with vim v7.0
cause difficulties with a vimball-installation of a new zip.vim. So, you'll need to remove
the older version of zip.vim:
- Change directory to the directory holding the vim 7.0 distribution's plugin/ and autoload/ directories.
- /bin/rm plugin/zip*.vim autoload/zip*.vim doc/pi_zip.txt
- Toggle Window Layout
Toggle the window layout from all-horizontal to all-vertical.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Vimball Archiver
| Updated Dec 28, 2009 (v30) |
Archive and de-archive vim plugins. To install:
well, I've decided that the vimball plugin itself should not expect that vimball is available to extract itself.
Hence, it is now being distributed as vimball.tar.gz. To unravel and install it:
- Change directory to the directory holding the plugin/ and autoload/ directories where you want to install vimball.
It is probably best to install the new vimball in the distribution directory. If you choose not to overwrite the
version that came with the plugin, but to put the new vimball in your personal directories, you must remove or otherwise
deactivate the original version that came with vim 7.0.
- gunzip vimball.tar.gz
- tar -oxvf vimball.tar
- (unix) chmod a+r autoload/vimball.vim doc/pi_vimball.txt plugin/vimballPlugin.vim
I am now also providing a program (you'll need a C compiler) that will create vimballs: mkvimball.
- Visual Block Commands
| Updated Sep 02, 2009 (v20b) |
Performs an Ex command on a ctrl-v highlighted block.
I often use it to target substitutes onto just a visual-block selection.
The original <vis.vim> was by Stefan Roemer, but this one
has been radically modified to support embedded tabs. It appears to operate
considerably faster, and has no side effects on register usage, etc.
It requires DrC's Utilities as it
also retains the original cursor/window positioning using functions from
that package.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Visual C Declarations
Use the shift-F1 key on a declaration in a C file, and a comment explaining the
declaration will be appended. Needs the cdecl program!
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Visual Block Sorting
| Updated Sep 27, 2006 (v4c) |
Sorts the lines based on a ctrl-v block selected portion thereof.
Works with Visual Incrementing, too,
to just sort the selected block. Vissort also provides BlockSort() which
enables sorting blocks of text based on a tag found in each block.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Visual Incrementing
| Updated Jun 18, 2009 (v20c) |
Transforms a ctrl-v selected visual-block of numbers into an incremented
list of numbers. The first line's number initializes the incrementation. The
updated <visincr.vim> now uses virtual column information to allow leading
tabs, handles ragged right visual blocks, will insert spaces as needed if
the count's string-length exceeds the visual-block's constraints, and also
accepts an optional incrementation argument (I [incr]) (which can be negative).
By default incr is 1. If the initial number is zero-padded on the left (ie. 001),
then the column of numbers will also be zero-padded as needed. For the maps
which handle dates, you'll also need to have
calutil.vba.gz.
- I [incr] - create an ascending or descending column of numbers, right padded
- II [incr [zfill]] - create an ascending or descending column of numbers, left padded
- IA [incr] - create an ascending or descending alphabetic column
- ID [incr] - create an ascending or descending column of daynames
- IYMD [incr] - create an ascending or descending column of year/month/day dates
- IMDY [incr] - create an ascending or descending column of month/day/year dates
- IDMY [incr] - create an ascending or descending column of day/month/year dates
The :R... versions (:RI :RII :RIYMD etc) restrict the renumbering/relabelling to
those lines which have an appropriate pattern (numbers for :RI and :RII, daynames
for :RID, etc).
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Visual Mode Based Swapping
| Updated Mar 07, 2006 (v4e) |
Swap text using visual modes!
- Select first region using a visual mode (V, v, or ctrl-v), then press <ctrl-y> ("yank").
- Select second region using a visual mode (V, v, or ctrl-v), then press <ctrl-x> ("exchange").
HelpExtractor technology is used to automatically install help for vswap.
There's also a tip about more swapping at Tip#329
In addition, one may replace columns of text with a selection:
- Select source region using visual-block (ctrl-v) selection plus motion.
- Hit <escape>
- Move cursor to where the upper left corner of the column replacement should be; hit \vr
(the backslash is actually <Leader>)
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- WhereFrom
| Updated Aug 16, 2005 (v3a) |
Ever wonder where a function, script, or command was defined, or where a setting
was last set? WhereFrom helps answer the question. :WhereFrom[!] {function|map|setting|command}
(or :WF[!] {function|map|setting|command} for a shorter command) will search the runtimepath
to determine where the item was defined. The optional "!" will make WhereFrom
continue looking for more than one instance -- the last one found is likely to be
the one you have currently loaded.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Window Kill Ring
| Updated Oct 08, 2008 (v1c) |
Implements a "kill ring" for a vim window: :[N]R[!] [files]
To see a window's kill ring contents, use :RShow.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- Zip Handler
| Updated Oct 08, 2008 (v23a) |
Zip Handler handles zip files; it resembles Tar Handler in look and feel.
It handles browsing, reading, and writing files.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball.
Unfortunately, there was a bug that makes the zip.vim version that was distributed with vim v7.0
cause difficulties with a vimball-installation of a new zip.vim. So, you'll need to remove
the older version of zip.vim:
- Change directory to the directory holding the vim 7.0 distribution's plugin/ and autoload/ directories.
- /bin/rm plugin/zip*.vim autoload/zip*.vim doc/pi_zip.txt
- Z Maps
Helpful z maps
- z< shift text on screen left
- z> shift text on screen right
- z, put cursor in middle of screen
- z0 put cursor on left-hand-side of screen
- z$ put cursor on right-hand-side of screen
- zp put text (like "p") but keep cursor in same column
- zP Put text (like "P") but keep cursor in same column
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
- ZoomWin
| Updated Oct 11, 2009 (v24c) |
Provides the ability to zoom into/out-of a window
(by Ron Aaron and C Campbell), similar to what the editor Brief provided. Version 14 was both
about 2/3 the size and faster, and the latest handles quickfix windows, too.
Also available at vim.sf.net
where you may rank it.
To extract this plugin, you'll need the new vimball plugin (or vim 7.1 or later): vimball
Links
| ---- | | | |
| Category | Description | Link | |
| Color Scheme | DrChip's Colorscheme | astronaut.tar.gz | |
| ---- | | | |
| Category | Description | Link | |
| Elsewhere | Vim Online | Vim Online | |
| | Vim Download Site | Vim Source | |
| | Vim FAQ | Vim FAQ | |
| | Vim CVS Repository | Vim's CVS Repository | |
| | Bill Joy's Original Vi Source Code | Joy's Vi Source | |
| | Colorscheme Examples | Vim Colorscheme Test | |
| | Google's Comp.Editors | Comp.Editors | |
| | Gui Vim Cheat Sheet | Vim Cheat Sheet and Tutorial | |
| | Gui Vim Cheat Sheet | Vim Cheat Sheet | |
| | Less Home Page | The Less home page | |
| | Postscript and PDF versions of Vim's User Documentation | Vim Docs in PS/PDF | |
| | Vi/Ex Tutorial (UnixWorld) | Vi/Ex Tutorial | |
| | Vi Lovers | vi lovers home page | |
| | Vi Reference | Vi Reference | |
| | Vim Book: by Oualline | Vi Improved-VIM | |
| | Vim Book: by RunPaint | Vim Recipes | |
| | Vim Book: by Swaroop | A Byte of Vim | |
| | Vim and VMS | Vim and VMS | |
| | Vim's Author | Bram Moolenaar's Vim Page | |
| | Vim and Eclipse | Vimplugin | |
| | Vim's Latest Syntax Highlighting Files | Syntax Highlighting Files | |
| | Vim's Regular Expressions | Vim Regular Expressions | |
| | Vim's User Guide | Vim's User Guide | |
| | Fellow Vim User (hypertext) | Stefan Bittner | |
| | Fellow Vim User (vimail) | Cesar A.R. Crusius | |
| | Fellow Vim User (tex latex matchit brkt) | Benji Fisher | |
| | Fellow Vim User (jtags) | Claudio Fleiner | |
| | Fellow Vim User (author of original vim home pages) | Sven Guckes | |
| | Fellow Vim User (windows, binaries) | Steve Hall | |
| | Fellow Vim User (tex latex) | Luc Hermite | |
| | Fellow Vim User (bufexplorer, rcs) | Jeff Lanzarotta | |
| | Fellow Vim User (tips,uil,prolog) | Thomas Köhler | |
| | Fellow Vim User (vi v vim, outliner) | Steve Litt | |
| | Fellow Vim User (map of vim users) | Mikolaj Machowski | |
| | Fellow Vim User (windows, howto, links, compiling vim) | Antoine Mechelynck | |
| | Fellow Vim User (tips) | David Rayner | |
| | Fellow Vim User (xml) | Tobias Reif | |
| | Fellow Vim User (tags, macros, maps) | Jos Van Riswick | |
| | Fellow Vim User (vimrc, alignment) | Brian Sturk | |
| | Fellow Vim User (mac port) | Dany St-Amant | |
| ---- | | | |
| Category | Description | Link | |
| Miscellaneous | Pre-compiled executables | Pre-Compiled Executables | |
| | (1999) Bill Joy, author of vi | 1999 Interview with Bill Joy | |
| | (1984) Bill Joy, author of vi | 1984 Interview with Bill Joy | |
| | Early Unix History | Unix History | |
| | Vim Commands | Short Vim List of Commands | |
| | Vim Regular Expressions | Vim Regular Expressions 101 | |
| | Vim Functions, Plugs, and Stubs | Vim Functions | |
| | Vim Normal Mode Reference Card (Word97) | Campbell&Troy's Vim 5 Reference Card | |
| | Oleg Raisky's Vim 5 Reference Card | Vim 5 Reference Card | |
| | Vim-LaTeX Suite | Vim LaTeX Suite | |
| | Vince Negri's ownsyntax/conceal patch | Vince Negri's Ownsyntax/Conceal patch | |
| ---- | | | |
| Category | Description | Link | |
| Scripts | Alignment | Align.tar.gz v28/33 | |
| | German Spelling Checker | German Spelling Checker | |
| | Hungarian Spelling Checker (based on engspchk v11) | Hungarian Spelling Checker | |
| | Polish Spelling Checker (based on engspchk v29) | Polish Spelling Checker | |
| | Yiddish Spelling Checker | Yiddish Spelling Checker | |
| | Matt Corks' Spelling Corrector | Spelling Corrector | |
| ---- | | | |
| Category | Description | Link | |
| | Tag Generation | Exuberant Ctags | |
| | Tag Generation | Hdrtag (C, C++, vim, tex) | |
| ---- | | | |
| Category | Description | Link | |
| Syntax | Amiga Script | amiga.vim.gz | |
| | C shell | csh.vim.gz | |
| | Dec's Control Language | dcl.vim.gz | |
| | Elm Filter | elmfilt.vim.gz | |
| | Unix's /etc/exports | exports.vim.gz | |
| | Lex | lex.vim.gz | |
| | Lisp | lisp.vim.gz | |
| | Maple V | maple.vim.gz | |
| | Rpcgen | rpcgen.vim.gz | |
| | Sh Bash Ksh | sh.vim.gz | Astro-Only |
| | Sendmail | sm.vim.gz | |
| | Tags | tags.vim.gz | |
| | LaTeX, TeX | tex.vim.gz | |
| | Vim | vim.vim.gz | Astro-Only |
| | Xmath | xmath.vim.gz | |
| | Xxd | xxd.vim.gz | |
| | Yacc | yacc.vim.gz | |
Note: An Astro-Only syntax file has not yet been sent to Bram Moolenaar
but has been made available here for downloading and testing. Sometimes syntax
files are in-between: for example, <csh.vim>, <sh.vim>, and <tex.vim> have been
sent to Bram Moolenaar but, sigh, missed the 6.0 release.
2 Tim 2:22
Now flee from youthful lusts, and pursue after righteousness, faith, love, and
peace, with those who call on the Lord from a pure heart.
|
|
The site you are viewing is a part of the Vi IMproved Editor Webring.
|
|
| Last Modified Feb 03, 2010 01:49:10 PM |
© 2010, Charles E Campbell, Jr. |
|