Configuration highlights:

• Viper
• Tabbar
• Org-mode

The files are available at my Github repo.

set incsearch
cnoremap <expr> / (getcmdtype() == '/' || getcmdtype() == '?' ? (getcmdline() == '' ? "<Up>" : "<Cr>/<Up>") : "/")
cnoremap <expr> ? (getcmdtype() == '/' || getcmdtype() == '?' ? (getcmdline() == '' ? "<Up>" : "<Cr>?<Up>") : "?")

That been said, I think my configuration has become pretty neat. See for yourself

I only use Vim in the terminal, but most of the configuration also works in gVim (you may have to modify some of the bindings for the special characters like <C-Space>).

Although the .vimrc is long, I have tried to avoid making the configuration too heavy, so you will only find mappings that I actually use. Usually, I discover a work pattern that I want to speed up, and create a binding. Then I try it some time to see if I will get used to it; if not, I remove again. That’s the methodology

Major features

• Usable with both the Colemak and Qwerty layout
• Readable colorscheme
• Makes heavy use of alt/meta bindings (as alt is easier to hit than control)
• Efficient tabbed navigation
• Custom status line
• Quick access to often used Ex commands
• Many navigation improving bindings (examples: next occurence of visual selection, tag jump in new tab reusing existing tabs, search outline ({{{), open visual selection in split window)
• Plugins are configured to be pervasive (they will not get in your way; at least not my way )

As of writing, I use these external plugins, which you may download from vim.org.

• AlignPlugin
• NERD_commenter
• a (alternate)
• imaps
• matchit
• project
• rhs (not yet published)
• securemodelines
• surround
• taglist
• timestamp
• vcssvn

Of “major” filetype plugins, I use haskellmode and latexsuite.

These are the files of interest. Enjoy

• .vimrc (html, html folded)
• colors/mntnoe.vim
• ftplugin/python.vim
• ftplugin/java.vim
• ftplugin/xml.vim
• ftplugin/c.vim
• ftplugin/cpp.vim
• ftplugin/cpp/cppindent.vim
• ftplugin/netrw.vim
• ftplugin/tex.vim
• syntax/text.vim

On March 27, 2008:

When you use the normal gf and <C-]> bindings, you change the buffer in the current window. There is also an option to create a new window when doing it, but there are no way to reuse windows that already show the corresponding buffer, at least not natively.

You can reuse tabs and windows (like other IDE’s) with findtab.py, which is a simple Python script consisting of three functions. To use it, add something like the following to your .vimrc:

pyfile ~/.vim/extern/findtab.py

nnoremap <M-]> :python TabTag()<Cr>
nnoremap <C-w><M-f> :python TabFile()<Cr>

I have tried to make TabFile() work like gf, supporting path, includeexpr and suffixesadd. I think TabTag() works like <C-]>. The script also supplies a general Python function called FindTag(filename). It works as you think…

Suppose we do not want to indent stuff in namespace declarations. I found out that it is enough to adjust the indentation of the first definition (except for a special case when using inheritance (“: public …“), see the code):

setlocal nolisp
setlocal noautoindent

setlocal indentexpr=GetCppIndent(v:lnum)

if exists("*GetCppIndent")
    finish
endif

function! GetCppIndent(lnum)
    let cindent = cindent(a:lnum)
    if a:lnum == 1 | return cindent | endif

    let pattern1 = 'namespaces+S+s*{s*%$'
    " pattern2 is used to match this case:
    " class c : public b
    "     { <-- cursor
    let clspat = 'classs+S+s*:s*[^{]*'
    let pattern2 = 'namespaces+S+s*{s*'.clspat.'%$'

    let lines = join(getline(max([ a:lnum - 10, 1]) , a:lnum-1), ' ')

    if  lines =~ pattern1
        return indent(CppFindOccurence('namespace', a:lnum))
    elseif  lines =~ pattern2 && getline(a:lnum) =~ '^s*{'
        return indent(CppFindOccurence('class', a:lnum))
    else
        return cindent
    endif
endfunction

function! CppFindOccurence(pattern, lnum)
    for line in range(a:lnum-1,a:lnum-10,-1)
        if getline(line) =~ a:pattern
            return line
        endif
    endfor
    return -1
endfunction

Please note that this is a hack, and thus not perfect. For instance, it does not take comments or preprocessing directives into account, but that should be easy to implement if it is an issue for you…

Put something like this in your .vimrc:

vnoremap <M-s> :<C-u>call VisualSplit()<Cr>

function! VisualSplit()
	let top = getpos("'<")[1]
	let bot = getpos("'>")[1]
	let height = bot - top + 1
	normal <Esc>
	only
	split
	execute "1 wincmd w"
	" position and size the top window
	execute "normal '<z" . height . "<Cr>z<Cr>"
	" return to 'main' window
	execute "normal <C-w>2<C-w>"
endfunction

Tabbed interfaces have emerged everywhere, and also Vim 7 comes with support for it. For projects consisting of multiple files, I find it easier to work with tabs than with split windows and multiple buffers. Of course we need some better keybindings:

inoremap <M-n> <C-o>gt
inoremap <M-p> <C-o>gT
inoremap <M-w> <Esc>:tabclose<Cr>
inoremap <M-t> <Esc>:tabe<Cr>

nnoremap <M-n> gt
nnoremap <M-p> gT
nnoremap <M-w> :tabclose<Cr>
nnoremap <M-t> :tabe<Cr>

Also, making the tab bar always visible encourages you to use them more:

set showtabline=2

Now remember to use the -p parameter when you open Vim with multiple files:

vim -p *.tex

Having multiple files open in for instance LaTeX projects also allows you to use completion in references to labels in the corresponding files.

BTW add colon and underscore to iskeyword to enable completion for labels like fig:nice_figure. Oh yes, and use latex-suite…

• Tag closing with code snippets from xmledit. Press <C-k> once to close the tag, and twice to close it and leave an empty line between.
• Tag closing using omni-completion: <C-b>. This is used when the cursor is not at the end of the starting tag. Will insert the closing tag for the inner most unclosed starting tag.
• Cycle between start and end tags with <LocalLeader>5 (typically 5 or ,5)
• Remove outer tag with <LL>r
• Goto parent tag with <LL>u (working on it, doesn’t work with <x/> tags. Anybody got a clue how to do this correctly?)
• Document pretty printing with <LL>xf
• Wellformedness checking (<LL>xx), DTD validation (<LL>xd) and XML Schema validation (<LL>xs) with XML Catalog support using xmllint (see below)

Have a look at Vim as XML Editor by Tobias Reif to find more tips.

Validating using xmllint

Tobias Reif’s howto shows a nice way of validating your document without saving them. The approach uses xmllint from libxml2, which is very fast. It has xml catalog support, so it can translate public, system and uri identifiers to local files. Nice when you do not have to make changes in the document to validate it… Read the howto for further information, but in short, you have to:

1. Specify the catalog files in .bashrc (xmllint and other validators reads (or should read) this environment variable).

    export XML_CATALOG_FILES="$HOME/Docs/xml/catalog /etc/xml/catalog"

2. Maintain a list of local schemas, and refer to them in the catalog files.

   <?xml version="1.0"?>
   <!DOCTYPE catalog PUBLIC "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN"
   "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd">
   <catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
     <group prefer="public" xml:base="file:///home/user/Docs/xml/schemas/">
       <uri name="http://www.w3.org/2001/XMLSchema"
         uri="xmlschema/1_0/xsd/XMLSchema.xsd" />
     ...
     </group>
   </catalog>

3. Make xmllint know which schema to use. For DTD it is easy, as xmllint can find it from the DOCTYPE declaration in the document, and then resolve the schema from the catalog. See xml.vim for how to do that in VIM. Unfortunately, it is not that easy with XML Schemas. xmllint can’t use the URI’s from the document namespace declaration, nor can it use the reference in the schemaLocation attribute, so we cannot take advantage of catalog resolution here. If you know a validator that can do this, please let me know, as I couldn’t find one. However, I decided that I couldn’t live without this feature , so I made a workaround, though a bit clumsy (see below).

XML Schema workaround

To add support for xml catalog resolution, we need to implement it ourselves. I have written a simple URI resolver (ResolveURI.java) using the Apache XML Resolver classes. It prints the resolved local URL to stdout if it can find an uri entry in the catalogs, or returns the argument if it can’t. To get quick access to it, we wrap it in a shell script:

#!/bin/bash
DIR=/path/to/resolveruri
java -cp $DIR/resolver.jar:$DIR ResolveURI $@

Normally, the Resolver classes expect the catalogs to be in a properties file, but as we use XML_CATALOG_FILES instead, we put the file CatalogManager.properties in the class path, containing just the word

catalogs=

Now we should be ready to do at least catalog URI resolving manually. Try to run the shell script with an URI like http://www.w3.org/2001/XMLSchema as argument.

The only thing left is to make VIM call the validator. We can specify the document namespace URI as the schema identifier, or use the reference from the schemaLocation attribute. In either case, it should be placed in the “s register. For namespaces, this could be done quickly by placing the cursor over the URI and typing vi”"sy. Then we call xmllint, with the resolved Schema file:

execute "%w !xmllint --noout --schema `resolveuri " . @s . "` -"

It works with multiple namespaces, as long as they are imported into the main Schema file, with the schemaLocation attribute is specified. I admit this solution is not particularly elegant, so if you know a better solution, please let me know. Although xmllint has limited support for XML Schema, at least you can now take advantage of it’s decent speed… Perhaps one should implement the URI resolver in C++, and without utilizing libraries to catch up with xmllint? Anyway, enjoy

Download tar.bz2