Skip to content
Browse files

Add vim-powerline plugin. (rev 99277d9)

  • Loading branch information...
1 parent 47eacae commit e5692a7daf1a44cda98d84d3364a0df251dff747 @bernd committed Apr 11, 2012
View
183 autoload/Pl.vim
@@ -0,0 +1,183 @@
+" Powerline - The ultimate statusline utility
+"
+" Author: Kim Silkebækken <kim.silkebaekken+vim@gmail.com>
+" Source repository: https://github.com/Lokaltog/vim-powerline
+
+" Script variables {{{
+ let g:Pl#OLD_STL = ''
+ let g:Pl#THEME = []
+ let g:Pl#THEME_CALLBACKS = []
+ let g:Pl#HL = []
+
+ " Cache revision, this must be incremented whenever the cache format is changed
+ let s:CACHE_REVISION = 7
+" }}}
+" Script initialization {{{
+ function! Pl#LoadCache() " {{{
+ if filereadable(g:Powerline_cache_file) && g:Powerline_cache_enabled
+ exec 'source' escape(g:Powerline_cache_file, ' \')
+
+ if ! exists('g:Powerline_cache_revision') || g:Powerline_cache_revision != s:CACHE_REVISION
+ " Cache revision differs, cache is invalid
+ unlet! g:Powerline_cache_revision
+
+ return 0
+ endif
+
+ " Create highlighting groups
+ for hi_cmd in g:Pl#HL
+ exec hi_cmd
+ endfor
+
+ " Run theme callbacks
+ for callback in g:Pl#THEME_CALLBACKS
+ " Substitute {{NEWLINE}} with newlines (strings must be
+ " stored without newlines characters to avoid vim errors)
+ exec substitute(callback[0], "{{NEWLINE}}", "\n", 'g')
+ exec substitute(callback[1], "{{NEWLINE}}", "\n", 'g')
+ endfor
+
+ return 1
+ endif
+
+ return 0
+ endfunction " }}}
+ function! Pl#ClearCache() " {{{
+ if filereadable(g:Powerline_cache_file)
+ " Delete the cache file
+ call delete(g:Powerline_cache_file)
+ endif
+
+ echo 'Powerline cache cleared. Please restart vim for the changes to take effect.'
+ endfunction " }}}
+ function! Pl#ReloadColorscheme() " {{{
+ call Pl#ClearCache()
+
+ " The colorscheme and theme files must be manually sourced because
+ " vim won't reload previously autoloaded files
+ "
+ " This is a bit hackish, but it works
+ unlet! g:Powerline#Colorschemes#{g:Powerline_colorscheme}#colorscheme
+ exec "source" split(globpath(&rtp, 'autoload/Powerline/Colorschemes/'. g:Powerline_colorscheme .'.vim', 1), '\n')[0]
+
+ unlet! g:Powerline#Themes#{g:Powerline_theme}#theme
+ exec "source" split(globpath(&rtp, 'autoload/Powerline/Themes/'. g:Powerline_theme .'.vim', 1), '\n')[0]
+
+ let g:Pl#THEME = []
+
+ call Pl#Load()
+ endfunction " }}}
+ function! Pl#Load() " {{{
+ if empty(g:Pl#OLD_STL)
+ " Store old statusline
+ let g:Pl#OLD_STL = &statusline
+ endif
+
+ if ! Pl#LoadCache()
+ try
+ " Autoload the theme dict first
+ let raw_theme = g:Powerline#Themes#{g:Powerline_theme}#theme
+ catch
+ echom 'Invalid Powerline theme! Please check your theme and colorscheme settings.'
+
+ return
+ endtry
+
+ " Create list with parsed statuslines
+ for buffer_statusline in raw_theme
+ unlet! mode_statuslines
+ let mode_statuslines = Pl#Parser#GetStatusline(buffer_statusline.segments)
+
+ if ! empty(buffer_statusline.callback)
+ " The callback function passes its arguments on to
+ " Pl#StatuslineCallback along with the normal/current mode
+ " statusline.
+ let s:cb_func = "function! PowerlineStatuslineCallback_". buffer_statusline.callback[1] ."(...)\n"
+ let s:cb_func .= "return Pl#StatuslineCallback(". string(mode_statuslines['n']) .", a:000)\n"
+ let s:cb_func .= "endfunction"
+
+ " The callback expression should be used to initialize any
+ " variables that will use the callback function. The
+ " expression requires a %s which will be replaced by the
+ " callback function name.
+ let s:cb_expr = printf(buffer_statusline.callback[2], 'PowerlineStatuslineCallback_'. buffer_statusline.callback[1])
+
+ exec s:cb_func
+ exec s:cb_expr
+
+ " Newlines must be substituted with another character
+ " because vim doesn't like newlines in strings
+ call add(g:Pl#THEME_CALLBACKS, [substitute(s:cb_func, "\n", "{{NEWLINE}}", 'g'), substitute(s:cb_expr, "\n", "{{NEWLINE}}", 'g')])
+
+ unlet! s:cb_func s:cb_expr
+
+ continue
+ endif
+
+ " Store the statuslines for matching specific buffers
+ call add(g:Pl#THEME, {
+ \ 'matches': buffer_statusline.matches,
+ \ 'mode_statuslines': mode_statuslines
+ \ })
+ endfor
+
+ if ! g:Powerline_cache_enabled
+ " Don't cache anything if caching is disabled or cache file isn't writeable
+ return
+ endif
+
+ " Prepare commands and statuslines for caching
+ let cache = [
+ \ 'let g:Powerline_cache_revision = '. string(s:CACHE_REVISION),
+ \ 'let g:Pl#HL = '. string(g:Pl#HL),
+ \ 'let g:Pl#THEME = '. string(g:Pl#THEME),
+ \ 'let g:Pl#THEME_CALLBACKS = '. string(g:Pl#THEME_CALLBACKS),
+ \ ]
+
+ call writefile(cache, g:Powerline_cache_file)
+ endif
+ endfunction " }}}
+" }}}
+" Statusline updater {{{
+ function! Pl#Statusline(statusline, current) " {{{
+ let mode = mode()
+
+ if ! a:current
+ let mode = 'N' " Normal (non-current)
+ elseif mode =~# '\v(v|V|)'
+ let mode = 'v' " Visual mode
+ elseif mode =~# '\v(s|S|)'
+ let mode = 's' " Select mode
+ elseif mode =~# '\vi'
+ let mode = 'i' " Insert mode
+ elseif mode =~# '\v(R|Rv)'
+ let mode = 'r' " Replace mode
+ else
+ " Fallback to normal mode
+ let mode = 'n' " Normal (current)
+ endif
+
+ return g:Pl#THEME[a:statusline].mode_statuslines[mode]
+ endfunction " }}}
+ function! Pl#StatuslineCallback(statusline, args) " {{{
+ " Replace %1, %2, etc. in the statusline with the callback args
+ return substitute(
+ \ a:statusline,
+ \ '\v\%(\d+)',
+ \ '\=a:args[submatch(1)]',
+ \ 'g')
+ endfunction " }}}
+ function! Pl#UpdateStatusline(current) " {{{
+ if empty(g:Pl#THEME)
+ " Load statuslines if they aren't loaded yet
+ call Pl#Load()
+ endif
+
+ for i in range(0, len(g:Pl#THEME) - 1)
+ if Pl#Match#Validate(g:Pl#THEME[i])
+ " Update window-local statusline
+ let &l:statusline = '%!Pl#Statusline('. i .','. a:current .')'
+ endif
+ endfor
+ endfunction " }}}
+" }}}
View
145 autoload/Pl/Colorscheme.vim
@@ -0,0 +1,145 @@
+function! Pl#Colorscheme#Init(hi) " {{{
+ let colorscheme = {}
+
+ for hi in a:hi
+ " Ensure that the segments are a list
+ let segments = type(hi[0]) == type('') ? [ hi[0] ] : hi[0]
+ let mode_hi_dict = hi[1]
+
+ for segment in segments
+ let colorscheme[segment] = mode_hi_dict
+ endfor
+ endfor
+
+ return colorscheme
+endfunction " }}}
+function! Pl#Colorscheme#Apply(colorscheme, buffer_segments) " {{{
+ " Set color parameters for all segments in a:buffer_segments
+
+ " TODO This function should be recursive and work on both segments and groups
+ " TODO We could probably handle the NS stuff here...
+
+ try
+ let colorscheme = g:Powerline#Colorschemes#{a:colorscheme}#colorscheme
+ catch
+ echom 'Color scheme "'. a:colorscheme .'" doesn''t exist!'
+
+ return
+ endtry
+
+ let buffer_segments = a:buffer_segments
+
+ " This is a bit complex, I'll walk you through exactly what happens here...
+ "
+ " First of all we loop through the buffer_segments, which are the segments that
+ " this specific buffer will have.
+ for buffer_segment in buffer_segments
+ " The buffer_segment consists of a 'matches' list and a 'segments' list.
+ " The 'matches' list has conditions to limit this statusline to specific buffers/windows.
+ " The 'segments' list has each segment and segment group for this buffer
+ for segment in buffer_segment.segments
+ let type = get(segment, 'type', '')
+
+ if type == 'segment_group'
+ " We're going to handle segment groups different from single segments. Segment groups
+ " have child segments which may have their own highlighting (e.g. fileinfo.flags),
+ " and these child segments may be grouped (e.g. fileinfo.flags.ro) to provide very
+ " specific highlighting. So here we'll handle all that:
+
+ " Set the default/fallback colors for this group
+ for i in range(len(segment.variants), 0, -1)
+ " Check for available highlighting for the main group segment
+ "
+ " This works like the segment highlighting below
+ " TODO Create a function for this
+ let seg_variants = join(segment.variants[0:i], '.')
+
+ let seg_name = i > 0 ? segment.name .'.'. seg_variants : segment.name
+ let seg_ns_name = len(segment.ns) > 0 ? segment.ns .':'. seg_name : seg_name
+
+ if has_key(colorscheme, seg_ns_name)
+ " We have a namespaced highlight group
+ let segment.colors = colorscheme[seg_ns_name]
+ break
+ elseif has_key(colorscheme, seg_name)
+ " We have a non-namespaced group
+ let segment.colors = colorscheme[seg_name]
+ break
+ endif
+ endfor
+
+ " The reason why we need to deepcopy the group's segments is that the child segments
+ " all point to the same base segments and that screws up highlighting if we highlight
+ " some child segments with different namespaced colors
+ let segment.segments = deepcopy(segment.segments)
+
+ " Apply colors to each child segment
+ for child_segment in segment.segments
+ " Check if this child segment is grouped (e.g. fileinfo.flags.group.subgroup)
+ " We're going to prioritize the most specific grouping and then work back to the
+ " most common group (e.g. fileinfo.flags)
+
+ " FIXME We don't have the variants from before because group children aren't run through Pl#Segment#Get
+ let child_segment.variants = [seg_name] + split(child_segment.name, '\.')
+
+ " Use the parent group's namespace
+ let child_segment.ns = segment.ns
+
+ for i in range(len(child_segment.variants), 0, -1)
+ " Check for available highlighting for the main group segment
+ let child_seg_name = join(child_segment.variants[0:i], '.')
+
+ let child_seg_ns_name = len(child_segment.ns) > 0 ? child_segment.ns .':'. child_seg_name : child_seg_name
+
+ if has_key(colorscheme, child_seg_ns_name)
+ " We have a namespaced highlight group
+ let child_segment.colors = colorscheme[child_seg_ns_name]
+ break
+ elseif has_key(colorscheme, child_seg_name)
+ " We have a non-namespaced group
+ let child_segment.colors = colorscheme[child_seg_name]
+ break
+ endif
+ endfor
+ endfor
+ elseif type == 'segment'
+ for i in range(len(segment.variants), 0, -1)
+ " Check for available highlighting
+ "
+ " This is done in the following manner, using the segment gundo:static_filename.text.buffer as an example:
+ "
+ " * Look for the hl group: gundo:static_filename.text.buffer
+ " * Look for the hl group: static_filename.text.buffer
+ " * Look for the hl group: gundo:static_filename.text
+ " * Look for the hl group: static_filename.text
+ " * Look for the hl group: gundo:static_filename
+ " * Look for the hl group: static_filename
+ " * Return the segment without highlighting, causing an error in the parser
+ let seg_variants = join(segment.variants[0:i], '.')
+
+ let seg_name = i > 0 ? segment.name .'.'. seg_variants : segment.name
+ let seg_ns_name = len(segment.ns) > 0 ? segment.ns .':'. seg_name : seg_name
+
+ if has_key(colorscheme, seg_ns_name)
+ " We have a namespaced highlight group
+ let segment.colors = colorscheme[seg_ns_name]
+ break
+ elseif has_key(colorscheme, seg_name)
+ " We have a non-namespaced group
+ let segment.colors = colorscheme[seg_name]
+ break
+ endif
+ endfor
+ endif
+
+ unlet! segment
+ endfor
+ endfor
+
+ " Good luck parsing this return value
+ "
+ " It's a huge dict with all segments for all buffers with their respective syntax highlighting.
+ " It will be parsed by the main Powerline code, where all the data will be shortened to a simple
+ " array consiting of a statusline for each mode, with generated highlighting groups and dividers.
+ return buffer_segments
+endfunction " }}}
View
140 autoload/Pl/Hi.vim
@@ -0,0 +1,140 @@
+" cterm -> gui color dict {{{
+let s:cterm2gui_dict = {
+ \ 16: 0x000000, 17: 0x00005f, 18: 0x000087, 19: 0x0000af, 20: 0x0000d7, 21: 0x0000ff,
+ \ 22: 0x005f00, 23: 0x005f5f, 24: 0x005f87, 25: 0x005faf, 26: 0x005fd7, 27: 0x005fff,
+ \ 28: 0x008700, 29: 0x00875f, 30: 0x008787, 31: 0x0087af, 32: 0x0087d7, 33: 0x0087ff,
+ \ 34: 0x00af00, 35: 0x00af5f, 36: 0x00af87, 37: 0x00afaf, 38: 0x00afd7, 39: 0x00afff,
+ \ 40: 0x00d700, 41: 0x00d75f, 42: 0x00d787, 43: 0x00d7af, 44: 0x00d7d7, 45: 0x00d7ff,
+ \ 46: 0x00ff00, 47: 0x00ff5f, 48: 0x00ff87, 49: 0x00ffaf, 50: 0x00ffd7, 51: 0x00ffff,
+ \ 52: 0x5f0000, 53: 0x5f005f, 54: 0x5f0087, 55: 0x5f00af, 56: 0x5f00d7, 57: 0x5f00ff,
+ \ 58: 0x5f5f00, 59: 0x5f5f5f, 60: 0x5f5f87, 61: 0x5f5faf, 62: 0x5f5fd7, 63: 0x5f5fff,
+ \ 64: 0x5f8700, 65: 0x5f875f, 66: 0x5f8787, 67: 0x5f87af, 68: 0x5f87d7, 69: 0x5f87ff,
+ \ 70: 0x5faf00, 71: 0x5faf5f, 72: 0x5faf87, 73: 0x5fafaf, 74: 0x5fafd7, 75: 0x5fafff,
+ \ 76: 0x5fd700, 77: 0x5fd75f, 78: 0x5fd787, 79: 0x5fd7af, 80: 0x5fd7d7, 81: 0x5fd7ff,
+ \ 82: 0x5fff00, 83: 0x5fff5f, 84: 0x5fff87, 85: 0x5fffaf, 86: 0x5fffd7, 87: 0x5fffff,
+ \ 88: 0x870000, 89: 0x87005f, 90: 0x870087, 91: 0x8700af, 92: 0x8700d7, 93: 0x8700ff,
+ \ 94: 0x875f00, 95: 0x875f5f, 96: 0x875f87, 97: 0x875faf, 98: 0x875fd7, 99: 0x875fff,
+ \ 100: 0x878700, 101: 0x87875f, 102: 0x878787, 103: 0x8787af, 104: 0x8787d7, 105: 0x8787ff,
+ \ 106: 0x87af00, 107: 0x87af5f, 108: 0x87af87, 109: 0x87afaf, 110: 0x87afd7, 111: 0x87afff,
+ \ 112: 0x87d700, 113: 0x87d75f, 114: 0x87d787, 115: 0x87d7af, 116: 0x87d7d7, 117: 0x87d7ff,
+ \ 118: 0x87ff00, 119: 0x87ff5f, 120: 0x87ff87, 121: 0x87ffaf, 122: 0x87ffd7, 123: 0x87ffff,
+ \ 124: 0xaf0000, 125: 0xaf005f, 126: 0xaf0087, 127: 0xaf00af, 128: 0xaf00d7, 129: 0xaf00ff,
+ \ 130: 0xaf5f00, 131: 0xaf5f5f, 132: 0xaf5f87, 133: 0xaf5faf, 134: 0xaf5fd7, 135: 0xaf5fff,
+ \ 136: 0xaf8700, 137: 0xaf875f, 138: 0xaf8787, 139: 0xaf87af, 140: 0xaf87d7, 141: 0xaf87ff,
+ \ 142: 0xafaf00, 143: 0xafaf5f, 144: 0xafaf87, 145: 0xafafaf, 146: 0xafafd7, 147: 0xafafff,
+ \ 148: 0xafd700, 149: 0xafd75f, 150: 0xafd787, 151: 0xafd7af, 152: 0xafd7d7, 153: 0xafd7ff,
+ \ 154: 0xafff00, 155: 0xafff5f, 156: 0xafff87, 157: 0xafffaf, 158: 0xafffd7, 159: 0xafffff,
+ \ 160: 0xd70000, 161: 0xd7005f, 162: 0xd70087, 163: 0xd700af, 164: 0xd700d7, 165: 0xd700ff,
+ \ 166: 0xd75f00, 167: 0xd75f5f, 168: 0xd75f87, 169: 0xd75faf, 170: 0xd75fd7, 171: 0xd75fff,
+ \ 172: 0xd78700, 173: 0xd7875f, 174: 0xd78787, 175: 0xd787af, 176: 0xd787d7, 177: 0xd787ff,
+ \ 178: 0xd7af00, 179: 0xd7af5f, 180: 0xd7af87, 181: 0xd7afaf, 182: 0xd7afd7, 183: 0xd7afff,
+ \ 184: 0xd7d700, 185: 0xd7d75f, 186: 0xd7d787, 187: 0xd7d7af, 188: 0xd7d7d7, 189: 0xd7d7ff,
+ \ 190: 0xd7ff00, 191: 0xd7ff5f, 192: 0xd7ff87, 193: 0xd7ffaf, 194: 0xd7ffd7, 195: 0xd7ffff,
+ \ 196: 0xff0000, 197: 0xff005f, 198: 0xff0087, 199: 0xff00af, 200: 0xff00d7, 201: 0xff00ff,
+ \ 202: 0xff5f00, 203: 0xff5f5f, 204: 0xff5f87, 205: 0xff5faf, 206: 0xff5fd7, 207: 0xff5fff,
+ \ 208: 0xff8700, 209: 0xff875f, 210: 0xff8787, 211: 0xff87af, 212: 0xff87d7, 213: 0xff87ff,
+ \ 214: 0xffaf00, 215: 0xffaf5f, 216: 0xffaf87, 217: 0xffafaf, 218: 0xffafd7, 219: 0xffafff,
+ \ 220: 0xffd700, 221: 0xffd75f, 222: 0xffd787, 223: 0xffd7af, 224: 0xffd7d7, 225: 0xffd7ff,
+ \ 226: 0xffff00, 227: 0xffff5f, 228: 0xffff87, 229: 0xffffaf, 230: 0xffffd7, 231: 0xffffff,
+ \ 232: 0x080808, 233: 0x121212, 234: 0x1c1c1c, 235: 0x262626, 236: 0x303030, 237: 0x3a3a3a,
+ \ 238: 0x444444, 239: 0x4e4e4e, 240: 0x585858, 241: 0x626262, 242: 0x6c6c6c, 243: 0x767676,
+ \ 244: 0x808080, 245: 0x8a8a8a, 246: 0x949494, 247: 0x9e9e9e, 248: 0xa8a8a8, 249: 0xb2b2b2,
+ \ 250: 0xbcbcbc, 251: 0xc6c6c6, 252: 0xd0d0d0, 253: 0xdadada, 254: 0xe4e4e4, 255: 0xeeeeee
+\ }
+" }}}
+" Allocated color dict {{{
+let s:allocated_colors = {
+ \ 'NONE': 'NONE',
+ \ }
+" }}}
+function! s:Cterm2GUI(cterm) " {{{
+ if toupper(a:cterm) == 'NONE'
+ return 'NONE'
+ endif
+
+ if ! has_key(s:cterm2gui_dict, a:cterm)
+ return 0xff0000
+ endif
+
+ return s:cterm2gui_dict[a:cterm]
+endfunction " }}}
+function! Pl#Hi#Segments(segments, mode_colors) " {{{
+ let mode_translate = {
+ \ 'normal': 'n',
+ \ 'noncurrent': 'N',
+ \ 'insert': 'i',
+ \ 'visual': 'v',
+ \ 'replace': 'r',
+ \ 'select': 's',
+ \ }
+
+ let attributes = ['bold', 'italic', 'underline']
+
+ let segments = a:segments
+ let mode_hi_dict = {}
+
+ " Mode dict
+ for [mode, colors] in items(a:mode_colors)
+ if has_key(mode_translate, mode)
+ let mode = mode_translate[mode]
+ endif
+
+ unlet! fg
+ let fg = s:allocated_colors[colors[0]]
+
+ let hi = {
+ \ 'cterm': [fg['cterm'], ''],
+ \ 'gui' : [fg['gui'], ''],
+ \ 'attr' : []
+ \ }
+
+ if exists('colors[1]')
+ if type(colors[1]) == type([])
+ " We don't have a BG color, but we have attributes
+ let hi.attr = colors[1]
+ else
+ " The second parameter is the background color
+ unlet! bg
+ let bg = s:allocated_colors[colors[1]]
+
+ let hi.cterm[1] = bg['cterm']
+ let hi.gui[1] = bg['gui']
+ endif
+ endif
+
+ if exists('colors[2]') && type(colors[2]) == type([])
+ " The third parameter is always an attribute list
+ let hi.attr = colors[2]
+ endif
+
+ let mode_hi_dict[mode] = {
+ \ 'ctermfg': (empty(hi['cterm'][0]) ? '' : (string(hi['cterm'][0]) == 'NONE' ? 'NONE' : hi['cterm'][0])),
+ \ 'ctermbg': (empty(hi['cterm'][1]) ? '' : (string(hi['cterm'][1]) == 'NONE' ? 'NONE' : hi['cterm'][1])),
+ \ 'guifg' : (empty(hi['gui'][0]) ? '' : (string(hi['gui'][0]) == 'NONE' ? 'NONE' : hi['gui'][0])),
+ \ 'guibg' : (empty(hi['gui'][1]) ? '' : (string(hi['gui'][1]) == 'NONE' ? 'NONE' : hi['gui'][1])),
+ \ 'attr' : (! len(hi['attr']) ? 'NONE' : join(hi['attr'], ','))
+ \ }
+ endfor
+
+ return [segments, mode_hi_dict]
+endfunction " }}}
+function! Pl#Hi#Allocate(colors) " {{{
+ for [key, color] in items(a:colors)
+ if type(color) == type(0)
+ " Only terminal color
+ let cterm = color
+ let gui = s:Cterm2GUI(color)
+ elseif type(color) == type([]) && len(color) == 2
+ " Terminal and GUI colors
+ let cterm = color[0]
+ let gui = color[1]
+ endif
+
+ let s:allocated_colors[key] = {
+ \ 'cterm': cterm,
+ \ 'gui': gui,
+ \ }
+
+ unlet! color
+ endfor
+endfunction " }}}
View
43 autoload/Pl/Match.vim
@@ -0,0 +1,43 @@
+function! Pl#Match#Add(pat, expr) " {{{
+ return [a:pat, a:expr]
+endfunction " }}}
+function! Pl#Match#Any(...) " {{{
+ let matches = []
+
+ for match_name in a:000
+ if empty(match_name)
+ " Skip empty match parameters
+ continue
+ endif
+
+ if has_key(g:Powerline#Matches#matches, match_name)
+ call add(matches, g:Powerline#Matches#matches[match_name])
+ endif
+
+ unlet! match_name
+ endfor
+
+ return ['match', 'any', matches]
+endfunction " }}}
+function! Pl#Match#Validate(theme) " {{{
+ let match = a:theme.matches[1]
+
+ if match == 'none'
+ return 0
+ elseif match == 'any'
+ let matches = a:theme.matches[2]
+
+ if ! len(matches)
+ " Empty match array matches everything
+ return 1
+ endif
+
+ for [eval, re] in matches
+ if match(eval(eval), '\v'. re) != -1
+ return 1
+ endif
+ endfor
+
+ return 0
+ endif
+endfunction " }}}
View
40 autoload/Pl/Mod.vim
@@ -0,0 +1,40 @@
+let s:segment_mods = []
+
+function! Pl#Mod#AddSegmentMod(action, properties) " {{{
+ call add(s:segment_mods, [a:action, a:properties])
+endfunction " }}}
+function! Pl#Mod#ApplySegmentMods(theme) " {{{
+ let theme = deepcopy(a:theme)
+
+ for mod in s:segment_mods
+ let [action, properties] = mod
+
+ " We have to loop through the segments instead of using index() because some
+ " segments are lists!
+ let target_seg_idx = -1
+
+ for i in range(0, len(theme) - 1)
+ unlet! segment
+ let segment = theme[i]
+
+ if type(segment) == type(properties.target_segment) && segment == properties.target_segment
+ let target_seg_idx = i
+ break
+ endif
+ endfor
+
+ if action == 'insert_segment'
+ " Insert segment
+ if target_seg_idx != -1
+ call insert(theme, properties.new_segment, (properties.where == 'before' ? target_seg_idx : target_seg_idx + 1))
+ endif
+ elseif action == 'remove_segment'
+ " Remove segment
+ if target_seg_idx != -1
+ call remove(theme, target_seg_idx)
+ endif
+ endif
+ endfor
+
+ return theme
+endfunction " }}}
View
350 autoload/Pl/Parser.vim
@@ -0,0 +1,350 @@
+let g:Pl#Parser#Symbols = {
+ \ 'compatible': {
+ \ 'dividers': [ '', [0x2502], '', [0x2502] ]
+ \ , 'symbols' : {
+ \ 'BRANCH': 'BR:'
+ \ , 'RO' : 'RO'
+ \ , 'FT' : 'FT'
+ \ , 'LINE' : 'LN'
+ \ }
+ \ },
+ \ 'unicode': {
+ \ 'dividers': [ [0x25b6], [0x276f], [0x25c0], [0x276e] ]
+ \ , 'symbols' : {
+ \ 'BRANCH': [0x26a1]
+ \ , 'RO' : [0x2613]
+ \ , 'FT' : [0x2691]
+ \ , 'LINE' : [0x204b]
+ \ },
+ \ },
+ \ 'fancy': {
+ \ 'dividers': [ [0x2b80], [0x2b81], [0x2b82], [0x2b83] ]
+ \ , 'symbols' : {
+ \ 'BRANCH': [0x2b60]
+ \ , 'RO' : [0x2b64]
+ \ , 'FT' : [0x2b62, 0x2b63]
+ \ , 'LINE' : [0x2b61]
+ \ }
+ \ }
+\ }
+
+" Handle symbol overrides
+for [s:key, s:value] in items(g:Powerline_symbols_override)
+ let g:Pl#Parser#Symbols[g:Powerline_symbols].symbols[s:key] = s:value
+
+ unlet! s:key s:value
+endfor
+
+" Handle divider overrides
+if len(g:Powerline_dividers_override) == 4
+ let g:Pl#Parser#Symbols[g:Powerline_symbols].dividers = g:Powerline_dividers_override
+endif
+
+let s:LEFT_SIDE = 0
+let s:RIGHT_SIDE = 2
+
+let s:PADDING = 1
+
+let s:EMPTY_SEGMENT = { 'type': 'empty' }
+
+let s:HARD_DIVIDER = 0
+let s:SOFT_DIVIDER = 1
+
+function! Pl#Parser#GetStatusline(segments) " {{{
+ let statusline = {
+ \ 'n': ''
+ \ , 'N': ''
+ \ , 'v': ''
+ \ , 'i': ''
+ \ , 'r': ''
+ \ , 's': ''
+ \ }
+
+ " Run through the different modes and create the statuslines
+ for mode in keys(statusline)
+ " Create an empty statusline list
+ let stl = []
+
+ call extend(stl, s:ParseSegments(mode, s:LEFT_SIDE, a:segments))
+
+ let statusline[mode] .= join(stl, '')
+ endfor
+
+ return statusline
+endfunction " }}}
+function! Pl#Parser#ParseChars(arg) " {{{
+ " Handles symbol arrays which can be either an array of hex values,
+ " or a string. Will convert the hex array to a string, or return the
+ " string as-is.
+ let arg = a:arg
+
+ if type(arg) == type([])
+ " Hex array
+ call map(arg, 'nr2char(v:val)')
+
+ return join(arg, '')
+ endif
+
+ " Anything else, just return it as it is
+ return arg
+endfunction " }}}
+function! s:ParseSegments(mode, side, segments, ...) " {{{
+ let mode = a:mode
+ let side = a:side
+ let segments = a:segments
+
+ let level = exists('a:1') ? a:1 : 0
+ let base_color = exists('a:2') ? a:2 : {}
+
+ let ret = []
+
+ for i in range(0, len(segments) - 1)
+ unlet! seg_prev seg_curr seg_next
+
+ " Prepare some resources (fetch previous, current and next segment)
+ let seg_curr = deepcopy(get(segments, i))
+
+ " Find previous segment
+ let seg_prev = s:EMPTY_SEGMENT
+
+ " If we're currently at i = 0 we have to start on 0 or else we will start on the last segment (list[-1])
+ let range_start = (i == 0 ? i : i - 1)
+ for j in range(range_start, 0, -1)
+ let seg = deepcopy(get(segments, j))
+ if get(seg, 'name') ==# 'TRUNCATE'
+ " Skip truncate segments
+ continue
+ endif
+
+ " Look ahead for another segment that's visible in this mode
+ if index(get(seg, 'modes'), mode) != -1
+ " Use this segment
+ let seg_prev = seg
+
+ break
+ endif
+ endfor
+
+ "" Find next segment
+ let seg_next = s:EMPTY_SEGMENT
+
+ " If we're currently at i = len(segments) - 1 we have to start on i or else we will get an error because the index doesn't exist
+ let range_start = (i == len(segments) - 1 ? i : i + 1)
+ for j in range(range_start, len(segments) - 1, 1)
+ let seg = deepcopy(get(segments, j))
+ if get(seg, 'name') ==# 'TRUNCATE'
+ " Skip truncate segments
+ continue
+ endif
+
+ " Look ahead for another segment that's visible in this mode
+ if index(get(seg, 'modes'), mode) != -1
+ " Use this segment
+ let seg_next = seg
+
+ break
+ endif
+ endfor
+
+ if index(get(seg_curr, 'modes', []), mode) == -1
+ " The segment is invisible in this mode, skip it
+ " FIXME When two segments after each other are hidden, a gap appears where the segments would be, this is probably due to segment padding
+ continue
+ endif
+
+ " Handle the different segment types
+ if seg_curr.type == 'segment'
+ if seg_curr.name ==# 'TRUNCATE'
+ " Truncate statusline
+ call add(ret, '%<')
+ elseif seg_curr.name ==# 'SPLIT'
+ " Split statusline
+
+ " Switch sides
+ let side = s:RIGHT_SIDE
+
+ " Handle highlighting
+ let mode_colors = get(seg_curr.colors, mode, seg_curr.colors['n'])
+ let hl_group = s:HlCreate(mode_colors)
+
+ " Add segment text
+ call add(ret, '%#'. hl_group .'#%=')
+ else
+ " Add segment text
+ let text = seg_curr.text
+
+ " Decide on whether to use the group's colors or the segment's colors
+ let colors = get(seg_curr, 'colors', base_color)
+
+ " Fallback to normal (current) highlighting if we don't have mode-specific highlighting
+ let mode_colors = get(colors, mode, get(colors, 'n', {}))
+
+ if empty(mode_colors)
+ echom 'Segment doesn''t have any colors! NS: "'. seg_curr.ns .'" SEG: "'. seg_curr.name .'"'
+
+ continue
+ endif
+
+ " Check if we're in a group (level > 0)
+ if level > 0
+ " If we're in a group we don't have dividers between
+ " segments, so we should only pad one side, but only pad
+ " if the segment doesn't have Pl#Segment#NoPadding() set
+ let padding_right = (seg_curr.padding && side == s:LEFT_SIDE ? repeat(' ', s:PADDING) : '')
+ let padding_left = (seg_curr.padding && side == s:RIGHT_SIDE ? repeat(' ', s:PADDING) : '')
+
+ " Check if we lack a bg/fg color for this segment
+ " If we do, use the bg/fg color from base_color
+ let base_color_mode = ! has_key(base_color, mode) ? base_color['n'] : base_color[mode]
+
+ for col in ['ctermbg', 'ctermfg', 'guibg', 'guifg']
+ if empty(mode_colors[col])
+ let mode_colors[col] = base_color_mode[col]
+ endif
+ endfor
+ else
+ "" If we're outside a group we have dividers and must pad both sides
+ let padding_left = repeat(' ', s:PADDING)
+ let padding_right = repeat(' ', s:PADDING)
+ endif
+
+ " Get main hl group for segment
+ let hl_group = s:HlCreate(mode_colors)
+
+ " Prepare segment text
+ let text = '%(%#'. hl_group .'#'. padding_left . text . padding_right . '%)'
+
+ if level == 0
+ " Add divider to single segments
+ let text = s:AddDivider(text, side, mode, colors, seg_prev, seg_curr, seg_next)
+ endif
+
+ call add(ret, text)
+ endif
+ elseif seg_curr.type == 'segment_group'
+ " Recursively parse segment group
+ let func_params = [mode, side, seg_curr.segments, level + 1]
+
+ if has_key(seg_curr, 'colors')
+ " Pass the base colors on to the child segments
+ call add(func_params, seg_curr.colors)
+ endif
+
+ " Get segment group string
+ let text = join(call('s:ParseSegments', func_params), '')
+
+ " Pad on the opposite side of the divider
+ let padding_right = (side == s:RIGHT_SIDE ? repeat(' ', s:PADDING) : '')
+ let padding_left = (side == s:LEFT_SIDE ? repeat(' ', s:PADDING) : '')
+
+ let text = s:AddDivider(padding_left . text . padding_right, side, mode, seg_curr.colors, seg_prev, seg_curr, seg_next)
+
+ call add(ret, text)
+ endif
+ endfor
+
+ return ret
+endfunction " }}}
+function! s:HlCreate(hl) " {{{
+ " Create a short and unique highlighting group name
+ " It uses the hex values of all the color properties and an attribute flag at the end
+ " NONE colors are translated to NN for cterm and NNNNNN for gui colors
+ let hi_group = printf('Pl%s%s%s%s%s'
+ \ , (a:hl['ctermfg'] == 'NONE' ? 'NN' : printf('%02x', a:hl['ctermfg']))
+ \ , (a:hl['guifg'] == 'NONE' ? 'NNNNNN' : printf('%06x', a:hl['guifg'] ))
+ \ , (a:hl['ctermbg'] == 'NONE' ? 'NN' : printf('%02x', a:hl['ctermbg']))
+ \ , (a:hl['guibg'] == 'NONE' ? 'NNNNNN' : printf('%06x', a:hl['guibg'] ))
+ \ , substitute(a:hl['attr'], '\v([a-zA-Z])[a-zA-Z]*,?', '\1', 'g')
+ \ )
+
+ if ! s:HlExists(hi_group)
+ let ctermbg = a:hl['ctermbg'] == 'NONE' ? 'NONE' : printf('%d', a:hl['ctermbg'])
+ if (has('win32') || has('win64')) && !has('gui_running') && ctermbg != 'NONE' && ctermbg > 128
+ let ctermbg -= 128
+ endif
+ let hi_cmd = printf('hi %s ctermfg=%s ctermbg=%s cterm=%s guifg=%s guibg=%s gui=%s'
+ \ , hi_group
+ \ , a:hl['ctermfg'] == 'NONE' ? 'NONE' : printf('%d', a:hl['ctermfg'])
+ \ , ctermbg
+ \ , a:hl['attr']
+ \ , (a:hl['guifg'] == 'NONE' ? 'NONE' : printf('#%06x', a:hl['guifg']))
+ \ , (a:hl['guibg'] == 'NONE' ? 'NONE' : printf('#%06x', a:hl['guibg']))
+ \ , a:hl['attr']
+ \ )
+
+ exec hi_cmd
+
+ " Add command to Pl#HL list for caching
+ call add(g:Pl#HL, hi_cmd)
+ endif
+
+ " Return only the highlighting group name
+ return hi_group
+endfunction " }}}
+function! s:HlExists(hl) " {{{
+ if ! hlexists(a:hl)
+ return 0
+ endif
+
+ redir => hlstatus
+ silent exec 'hi' a:hl
+ redir END
+
+ return (hlstatus !~ 'cleared')
+endfunction " }}}
+function! s:AddDivider(text, side, mode, colors, prev, curr, next) " {{{
+ let seg_prev = a:prev
+ let seg_curr = a:curr
+ let seg_next = a:next
+
+ " Set default color/type for the divider
+ let div_colors = get(a:colors, a:mode, a:colors['n'])
+ let div_type = s:SOFT_DIVIDER
+
+ " Define segment to compare
+ let cmp_seg = a:side == s:LEFT_SIDE ? seg_next : seg_prev
+
+ let cmp_all_colors = get(cmp_seg, 'colors', {})
+ let cmp_colors = get(cmp_all_colors, a:mode, get(cmp_all_colors, 'n', {}))
+
+ if ! empty(cmp_colors)
+ " Compare the highlighting groups
+ "
+ " If the background color for cterm is equal, use soft divider with the current segment's highlighting
+ " If not, use hard divider with a new highlighting group
+ "
+ " Note that if the previous/next segment is the split, a hard divider is always used
+ if get(div_colors, 'ctermbg') != get(cmp_colors, 'ctermbg') || get(seg_next, 'name') ==# 'SPLIT' || get(seg_prev, 'name') ==# 'SPLIT'
+ let div_type = s:HARD_DIVIDER
+
+ " Create new highlighting group
+ " Use FG = CURRENT BG, BG = CMP BG
+ let div_colors['ctermfg'] = get(div_colors, 'ctermbg')
+ let div_colors['guifg'] = get(div_colors, 'guibg')
+
+ let div_colors['ctermbg'] = get(cmp_colors, 'ctermbg')
+ let div_colors['guibg'] = get(cmp_colors, 'guibg')
+
+ let div_colors['attr'] = 'NONE'
+ endif
+ endif
+
+ " Prepare divider
+ let divider_raw = deepcopy(g:Pl#Parser#Symbols[g:Powerline_symbols].dividers[a:side + div_type])
+ let divider = Pl#Parser#ParseChars(divider_raw)
+
+ " Don't add dividers for segments adjacent to split (unless it's a hard divider)
+ if ((get(seg_next, 'name') ==# 'SPLIT' || get(seg_prev, 'name') ==# 'SPLIT') && div_type != s:HARD_DIVIDER)
+ return ''
+ endif
+
+ if a:side == s:LEFT_SIDE
+ " Left side
+ " Divider to the right
+ return printf('%%(%s%%#%s#%s%%)', a:text, s:HlCreate(div_colors), divider)
+ else
+ " Right side
+ " Divider to the left
+ return printf('%%(%%#%s#%s%s%%)', s:HlCreate(div_colors), divider, a:text)
+ endif
+endfunction " }}}
View
188 autoload/Pl/Segment.vim
@@ -0,0 +1,188 @@
+let s:default_modes = ['n', 'N', 'v', 'i', 'r', 's']
+
+function! s:CheckConditions(params) " {{{
+ " Check conditions for a segment/group
+ " Integer parameters are always conditions
+ for param in a:params
+ if type(param) == type(0) && param == 0
+ " Break here if it's an integer parameter and it's false (0)
+ return 0
+ endif
+ unlet! param
+ endfor
+
+ return 1
+endfunction " }}}
+function! Pl#Segment#Create(name, ...) " {{{
+ " Check condition parameters
+ if ! s:CheckConditions(a:000)
+ return {}
+ endif
+
+ let name = a:name
+ let modes = s:default_modes
+ let padding = 1
+ let segments = []
+
+ for param in a:000
+ " Lookup modes for this segment/group
+ if type(param) == type([]) && param[0] == 'modes'
+ let modes = param[1]
+ elseif type(param) == type([]) && param[0] == 'nopadding'
+ let padding = 0
+ elseif type(a:1) == type([]) && a:1[0] == 'segment'
+ call add(segments, param[1])
+ endif
+
+ unlet! param
+ endfor
+
+ if type(a:1) == type([]) && a:1[0] == 'segment'
+ " This is a segment group
+ return ['segment_group', {
+ \ 'type': 'segment_group'
+ \ , 'name': name
+ \ , 'segments': segments
+ \ , 'modes': modes
+ \ , 'padding': padding
+ \ }]
+ else
+ " This is a single segment
+ let text = a:1
+
+ " Search/replace symbols
+ for [key, symbol] in items(g:Pl#Parser#Symbols[g:Powerline_symbols].symbols)
+ let text = substitute(
+ \ text,
+ \ '\v\$('. key .')',
+ \ '\=Pl#Parser#ParseChars(g:Pl#Parser#Symbols[g:Powerline_symbols].symbols[submatch(1)])',
+ \ 'g')
+
+ unlet! key symbol
+ endfor
+
+ return ['segment', {
+ \ 'type': 'segment'
+ \ , 'name': name
+ \ , 'text': text
+ \ , 'modes': modes
+ \ , 'padding': padding
+ \ }]
+ endif
+
+endfunction " }}}
+function! Pl#Segment#Init(params) " {{{
+ " Check condition parameters
+ if ! s:CheckConditions(a:params)
+ return {}
+ endif
+
+ let segments = {}
+ let ns = ''
+
+ for param in a:params
+ if type(param) == type('')
+ " String parameters is the namespace
+ let ns = param
+ elseif type(param) == type([])
+ " The data dict is in param[1]
+ " By default we don't have a namespace for the segment
+ let segment = param[1]
+
+ if ! empty(ns)
+ " Update segment so that it includes the namespace
+ " Add the namespace to the segment dict key
+ let segment.ns = ns
+ let segment.name = join([segment.ns, segment.name], ':')
+ endif
+
+ let key = segment.name
+
+ let segments[key] = segment
+ endif
+
+ unlet! param
+ endfor
+
+ return segments
+endfunction " }}}
+function! Pl#Segment#Modes(modes) " {{{
+ " Handle modes for both segments and groups
+ let modes = split(a:modes, '\zs')
+
+ if modes[0] == '!'
+ " Filter modes (e.g. "!nr" will ignore the segment in normal and replace modes)
+ let modes = filter(deepcopy(s:default_modes), 'v:val !~# "['. join(modes[1:]) .']"')
+ endif
+
+ return ['modes', modes]
+endfunction " }}}
+function! Pl#Segment#NoPadding() " {{{
+ return ['nopadding']
+endfunction " }}}
+function! Pl#Segment#Split(...) " {{{
+ return a:0 ? a:1 .':SPLIT' : 'SPLIT'
+endfunction " }}}
+function! Pl#Segment#Truncate() " {{{
+ return 'TRUNCATE'
+endfunction " }}}
+function! Pl#Segment#Get(name) " {{{
+ " Return a segment data dict
+ let args = []
+
+ " Check for printf segments (lists)
+ if type(a:name) == type([])
+ " We're dealing with a segment with printf arguments
+ let seg_orig_name = a:name[0]
+ let args = a:name[1:]
+ else
+ let seg_orig_name = a:name
+ endif
+
+ " Fetch namespace and variants for storing in the segment dict
+ let seg_ns = ''
+ let seg_variants = []
+
+ " Retrieve color scheme variants
+ let seg_name_split = split(seg_orig_name, '\v\.')
+ if len(seg_name_split) > 1
+ let seg_variants = seg_name_split[1:]
+ endif
+
+ " Retrieve segment name and namespace
+ " Use the first piece of the split string, we can't have variants in the final segment name
+ let seg_name_split = split(seg_name_split[0], '\v:')
+ let seg_name = seg_name_split[0]
+
+ if len(seg_name_split) > 1
+ let seg_ns = seg_name_split[0]
+ let seg_name = seg_name_split[-1]
+ endif
+
+ try
+ " If we have a namespace, try to use the namespaced segment first (i.e. search for the segment in the namespaced file first)
+ let return_segment = deepcopy(g:Powerline#Segments#{seg_ns}#segments[seg_ns .':'. seg_name])
+ catch
+ try
+ " We didn't find a namespaced segment, fall back to common segments
+ let return_segment = deepcopy(g:Powerline#Segments#segments[seg_name])
+ catch
+ " Didn't find the segment among the common segments either, just skip it
+ return {}
+ endtry
+ endtry
+
+ if len(args) && has_key(return_segment, 'text')
+ " Handle segment printf arguments
+ " printf doesn't accept lists as its second argument, so we have to work around that
+ let return_segment.text = call('printf', [ return_segment.text ] + args)
+ endif
+
+ " Assign namespace, name and variants
+ let return_segment.ns = seg_ns
+ let return_segment.name = seg_name
+ let return_segment.orig_name = seg_orig_name
+ let return_segment.variants = seg_variants
+
+ return return_segment
+endfunction " }}}
View
100 autoload/Pl/Theme.vim
@@ -0,0 +1,100 @@
+function! Pl#Theme#Create(...) " {{{
+ let buffer_segments = []
+
+ for buffer_segment in a:000
+ " Remove empty segments (e.g. 'Pl#Theme#Function's)
+ if empty(buffer_segment)
+ continue
+ endif
+
+ call add(buffer_segments, buffer_segment)
+ endfor
+
+ let buffer_segments = Pl#Colorscheme#Apply(g:Powerline_colorscheme, buffer_segments)
+
+ return buffer_segments
+endfunction " }}}
+function! Pl#Theme#Callback(name, expr) " {{{
+ return ['callback', a:name, a:expr]
+endfunction " }}}
+function! Pl#Theme#Buffer(ns, ...) " {{{
+ let segments = []
+ let ns = ! empty(a:ns) ? a:ns .':' : ''
+
+ " Match namespace parameter by default
+ let matches = Pl#Match#Any(a:ns)
+ let callback = []
+
+ let args = a:000
+ let args = Pl#Mod#ApplySegmentMods(args)
+
+ " Fetch segment data dicts
+ for item in args
+ if type(item) == type([])
+ if item[0] == 'match'
+ " Match item, overrides default namespace match
+ let matches = item
+
+ unlet! item
+ continue
+ elseif item[0] == 'callback'
+ " Store the item as a callback expression
+ let matches = ['match', 'none']
+ let callback = [a:ns, item[1], item[2]]
+
+ unlet! item
+ continue
+ endif
+
+ " printf segment, append ns to first item in list
+ let item[0] = ns . item[0]
+ else
+ let item = ns . item
+ endif
+
+ let segment = Pl#Segment#Get(item)
+
+ if ! empty(segment)
+ " Skip empty (possible disabled) segments
+ call add(segments, segment)
+ endif
+
+ unlet! item
+ endfor
+
+ return {
+ \ 'matches': matches
+ \ , 'callback': callback
+ \ , 'segments': segments
+ \ }
+endfunction " }}}
+function! Pl#Theme#InsertSegment(new_segment, where, target_segment) " {{{
+ " It's very important to NOT refer to the theme dict until everything's loaded!
+ "
+ " Because these functions are called from the vimrc, we need to put the
+ " actions in a list which will be parsed later.
+ "
+ " These functions don't accept a name parameter, because they work on the
+ " currently selected theme (will change any selected theme)
+ call Pl#Mod#AddSegmentMod('insert_segment', {
+ \ 'new_segment': a:new_segment,
+ \ 'where': a:where,
+ \ 'target_segment': a:target_segment
+ \ })
+endfunction " }}}
+function! Pl#Theme#RemoveSegment(target_segment) " {{{
+ " It's very important to NOT refer to the theme dict until everything's loaded!
+ "
+ " Because these functions are called from the vimrc, we need to put the
+ " actions in a list which will be parsed later.
+ "
+ " These functions don't accept a name parameter, because they work on the
+ " currently selected theme (will change any selected theme)
+ call Pl#Mod#AddSegmentMod('remove_segment', {
+ \ 'target_segment': a:target_segment
+ \ })
+endfunction " }}}
+function! Pl#Theme#ReplaceSegment(old_segment, new_segment) " {{{
+ call Pl#Theme#InsertSegment(a:new_segment, 'after', a:old_segment)
+ call Pl#Theme#RemoveSegment(a:old_segment)
+endfunction " }}}
View
166 autoload/Powerline/Colorschemes/default.vim
@@ -0,0 +1,166 @@
+call Pl#Hi#Allocate({
+ \ 'black' : 16,
+ \ 'white' : 231,
+ \
+ \ 'darkestgreen' : 22,
+ \ 'darkgreen' : 28,
+ \ 'mediumgreen' : 70,
+ \ 'brightgreen' : 148,
+ \
+ \ 'darkestcyan' : 23,
+ \ 'mediumcyan' : 117,
+ \
+ \ 'darkestblue' : 24,
+ \ 'darkblue' : 31,
+ \
+ \ 'darkestred' : 52,
+ \ 'darkred' : 88,
+ \ 'mediumred' : 124,
+ \ 'brightred' : 160,
+ \ 'brightestred' : 196,
+ \
+ \ 'darkestpurple' : 55,
+ \ 'mediumpurple' : 98,
+ \ 'brightpurple' : 189,
+ \
+ \ 'brightorange' : 208,
+ \ 'brightestorange': 214,
+ \
+ \ 'gray0' : 233,
+ \ 'gray1' : 235,
+ \ 'gray2' : 236,
+ \ 'gray3' : 239,
+ \ 'gray4' : 240,
+ \ 'gray5' : 241,
+ \ 'gray6' : 244,
+ \ 'gray7' : 245,
+ \ 'gray8' : 247,
+ \ 'gray9' : 250,
+ \ 'gray10' : 252,
+ \ })
+
+let g:Powerline#Colorschemes#default#colorscheme = Pl#Colorscheme#Init([
+ \ Pl#Hi#Segments(['SPLIT'], {
+ \ 'n': ['white', 'gray2'],
+ \ 'N': ['white', 'gray0'],
+ \ 'i': ['white', 'darkestblue'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['mode_indicator'], {
+ \ 'n': ['darkestgreen', 'brightgreen', ['bold']],
+ \ 'i': ['darkestcyan', 'white', ['bold']],
+ \ 'v': ['darkred', 'brightorange', ['bold']],
+ \ 'r': ['white', 'brightred', ['bold']],
+ \ 's': ['white', 'gray5', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['branch', 'scrollpercent', 'raw', 'filesize'], {
+ \ 'n': ['gray9', 'gray4'],
+ \ 'N': ['gray4', 'gray1'],
+ \ 'i': ['mediumcyan', 'darkblue'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['fileinfo', 'filename'], {
+ \ 'n': ['white', 'gray4', ['bold']],
+ \ 'N': ['gray7', 'gray0', ['bold']],
+ \ 'i': ['white', 'darkblue', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['fileinfo.filepath'], {
+ \ 'n': ['gray10'],
+ \ 'N': ['gray5'],
+ \ 'i': ['mediumcyan'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['static_str'], {
+ \ 'n': ['white', 'gray4'],
+ \ 'N': ['gray7', 'gray1'],
+ \ 'i': ['white', 'darkblue'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['fileinfo.flags'], {
+ \ 'n': ['brightestred', ['bold']],
+ \ 'N': ['darkred'],
+ \ 'i': ['brightestred', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['current_function', 'fileformat', 'fileencoding', 'pwd', 'filetype', 'rvm:string', 'rvm:statusline', 'virtualenv:statusline', 'charcode', 'currhigroup'], {
+ \ 'n': ['gray8', 'gray2'],
+ \ 'i': ['mediumcyan', 'darkestblue'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['lineinfo'], {
+ \ 'n': ['gray2', 'gray10', ['bold']],
+ \ 'N': ['gray7', 'gray1', ['bold']],
+ \ 'i': ['darkestcyan', 'mediumcyan', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['errors'], {
+ \ 'n': ['brightestorange', 'gray2', ['bold']],
+ \ 'i': ['brightestorange', 'darkestblue', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['lineinfo.line.tot'], {
+ \ 'n': ['gray6'],
+ \ 'N': ['gray5'],
+ \ 'i': ['darkestcyan'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['paste_indicator', 'ws_marker'], {
+ \ 'n': ['white', 'brightred', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['gundo:static_str.name', 'command_t:static_str.name'], {
+ \ 'n': ['white', 'mediumred', ['bold']],
+ \ 'N': ['brightred', 'darkestred', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['gundo:static_str.buffer', 'command_t:raw.line'], {
+ \ 'n': ['white', 'darkred'],
+ \ 'N': ['brightred', 'darkestred'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['gundo:SPLIT', 'command_t:SPLIT'], {
+ \ 'n': ['white', 'darkred'],
+ \ 'N': ['white', 'darkestred'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['lustyexplorer:static_str.name', 'minibufexplorer:static_str.name', 'nerdtree:raw.name', 'tagbar:static_str.name'], {
+ \ 'n': ['white', 'mediumgreen', ['bold']],
+ \ 'N': ['mediumgreen', 'darkestgreen', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['lustyexplorer:static_str.buffer', 'tagbar:static_str.buffer'], {
+ \ 'n': ['brightgreen', 'darkgreen'],
+ \ 'N': ['mediumgreen', 'darkestgreen'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['lustyexplorer:SPLIT', 'minibufexplorer:SPLIT', 'nerdtree:SPLIT', 'tagbar:SPLIT'], {
+ \ 'n': ['white', 'darkgreen'],
+ \ 'N': ['white', 'darkestgreen'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['ctrlp:focus', 'ctrlp:byfname'], {
+ \ 'n': ['brightpurple', 'darkestpurple'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['ctrlp:prev', 'ctrlp:next', 'ctrlp:pwd'], {
+ \ 'n': ['white', 'mediumpurple'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['ctrlp:item'], {
+ \ 'n': ['darkestpurple', 'white', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['ctrlp:marked'], {
+ \ 'n': ['brightestred', 'darkestpurple', ['bold']],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['ctrlp:count'], {
+ \ 'n': ['darkestpurple', 'white'],
+ \ }),
+ \
+ \ Pl#Hi#Segments(['ctrlp:SPLIT'], {
+ \ 'n': ['white', 'darkestpurple'],
+ \ }),
+ \ ])
View
132 autoload/Powerline/Functions.vim
@@ -0,0 +1,132 @@
+" Recalculate the trailing whitespace warning when idle, and after saving
+autocmd CursorHold,BufWritePost,InsertLeave * unlet! b:statusline_trailing_space_warning
+
+function! Powerline#Functions#GetFilepath() " {{{
+ let relpath = expand('%')
+
+ if empty(relpath)
+ return ''
+ endif
+
+ let headpath = substitute(expand('%:h'), escape($HOME, '\'), '~', '')
+ let fullpath = substitute(expand('%:p:h'), escape($HOME, '\'), '~', '')
+ let ret = ''
+
+ if g:Powerline_stl_path_style == 'short'
+ " Display a short path where the first directory is displayed with its
+ " full name, and the subsequent directories are shortened to their
+ " first letter, i.e. "/home/user/foo/foo/bar/baz.vim" becomes
+ " "~/foo/f/b/baz.vim"
+ let fpath = split(headpath, '/')
+ let fpath_shortparts = map(fpath[1:], 'v:val[0]')
+ let ret = join(extend([fpath[0]], fpath_shortparts), '/') .'/'
+ elseif g:Powerline_stl_path_style == 'relative'
+ " Display a relative path, similar to the %f statusline item
+ let ret = headpath .'/'
+ elseif g:Powerline_stl_path_style == 'full'
+ " Display the full path, similar to the %F statusline item
+ let ret = fullpath .'/'
+ endif
+
+ if ret == './'
+ return ''
+ endif
+
+ return ret
+endfunction " }}}
+function! Powerline#Functions#GetShortPath(threshold) " {{{
+ let fullpath = split(substitute(expand('%:p:h'), $HOME, '~', 'g'), '/')
+
+ if len(fullpath) > a:threshold
+ let fullpath = [fullpath[0], '…'] + fullpath[-a:threshold + 1 :]
+ endif
+
+ return join(fullpath, '/')
+endfunction " }}}
+function! Powerline#Functions#GetMode() " {{{
+ let mode = mode()
+
+ if mode =~# '\v(v|V|)'
+ " Visual mode
+ if mode ==# 'v'
+ let mode = 'VISUAL'
+ elseif mode ==# 'V'
+ let mode = 'V·LINE'
+ elseif mode ==# ''
+ let mode = 'V·BLOCK'
+ endif
+ elseif mode =~# '\v(s|S|)'
+ " Select mode
+ if mode ==# 's'
+ let mode = 'SELECT'
+ elseif mode ==# 'S'
+ let mode = 'S·LINE'
+ elseif mode ==# ''
+ let mode = 'S·BLOCK'
+ endif
+ elseif mode =~# '\vi'
+ let mode = 'INSERT' " Insert mode
+ elseif mode =~# '\v(R|Rv)'
+ let mode = 'REPLACE' " Replace mode
+ else
+ " Fallback to normal mode
+ let mode = ' N ' " Normal (current)
+ endif
+
+ return mode
+endfunction " }}}
+function! Powerline#Functions#GetFilesize() " {{{
+ let bytes = getfsize(expand("%:p"))
+
+ if bytes <= 0
+ return ''
+ endif
+
+ if bytes < 1024
+ return bytes . 'B'
+ else
+ return (bytes / 1024) . 'kB'
+ endif
+endfunction "}}}
+function! Powerline#Functions#GetCharCode() " {{{
+ " Get the output of :ascii
+ redir => ascii
+ silent! ascii
+ redir END
+
+ if match(ascii, 'NUL') != -1
+ return 'NUL'
+ endif
+
+ " Zero pad hex values
+ let nrformat = '0x%02x'
+
+ let encoding = (&fenc == '' ? &enc : &fenc)
+
+ if encoding == 'utf-8'
+ " Zero pad with 4 zeroes in unicode files
+ let nrformat = '0x%04x'
+ endif
+
+ " Get the character and the numeric value from the return value of :ascii
+ " This matches the two first pieces of the return value, e.g.
+ " "<F> 70" => char: 'F', nr: '70'
+ let [str, char, nr; rest] = matchlist(ascii, '\v\<(.{-1,})\>\s*([0-9]+)')
+
+ " Format the numeric value
+ let nr = printf(nrformat, nr)
+
+ return "'". char ."' ". nr
+endfunction "}}}
+function! Powerline#Functions#GetWSMarker() " {{{
+ " Return '...' if trailing white space is detected
+ " Return '' otherwise
+ if ! exists("b:statusline_trailing_space_warning")
+ if search('\s$', 'nw') != 0
+ let b:statusline_trailing_space_warning = ' … '
+ else
+ let b:statusline_trailing_space_warning = ''
+ endif
+ endif
+ return b:statusline_trailing_space_warning
+endfunction " }}}
View
3 autoload/Powerline/Functions/cfi.vim
@@ -0,0 +1,3 @@
+function! Powerline#Functions#cfi#GetCurrentFunction() " {{{
+ return cfi#format('%s', '')
+endfunction " }}}
View
12 autoload/Powerline/Functions/ft_man.vim
@@ -0,0 +1,12 @@
+function! Powerline#Functions#ft_man#GetName() " {{{
+ let matches = matchlist(getline(1), '\v^([a-zA-Z_\.\-]+)\((\d+)\)')
+
+ if ! len(matches)
+ return 'n/a'
+ endif
+
+ let file = tolower(matches[1])
+ let num = matches[2]
+
+ return file
+endfunction " }}}
View
7 autoload/Powerline/Functions/fugitive.vim
@@ -0,0 +1,7 @@
+function! Powerline#Functions#fugitive#GetBranch(symbol) " {{{
+ let ret = fugitive#statusline()
+
+ let ret = substitute(ret, '\c\v\[?GIT\(([a-z0-9\-_\./:]+)\)\]?', a:symbol .' \1', 'g')
+
+ return ret
+endfunction " }}}
View
16 autoload/Powerline/Functions/syntastic.vim
@@ -0,0 +1,16 @@
+function! Powerline#Functions#syntastic#GetErrors(line_symbol) " {{{
+ if ! exists('g:syntastic_stl_format')
+ " Syntastic hasn't been loaded yet
+ return ''
+ endif
+
+ " Temporarily change syntastic output format
+ let old_stl_format = g:syntastic_stl_format
+ let g:syntastic_stl_format = '╱╱╱%E{ ERRORS (%e) '. a:line_symbol .' %fe }%W{ WARNINGS (%w) '. a:line_symbol .' %fw }╱╱╱'
+
+ let ret = SyntasticStatuslineFlag()
+
+ let g:syntastic_stl_format = old_stl_format
+
+ return ret
+endfunction " }}}
View
13 autoload/Powerline/Matches.vim
@@ -0,0 +1,13 @@
+let g:Powerline#Matches#matches = {
+ \ 'command_t' : Pl#Match#Add('bufname("%")', 'GoToFile'),
+ \ 'ft_help' : Pl#Match#Add('&ft' , 'help'),
+ \ 'ft_man' : Pl#Match#Add('&ft' , 'man'),
+ \ 'ft_qf' : Pl#Match#Add('&ft' , 'qf'),
+ \ 'ft_vimpager' : Pl#Match#Add('&ft' , 'vimpager'),
+ \ 'gundo_preview' : Pl#Match#Add('bufname("%")', '__Gundo_Preview__'),
+ \ 'gundo_tree' : Pl#Match#Add('bufname("%")', '__Gundo__'),
+ \ 'lustyexplorer' : Pl#Match#Add('bufname("%")', '\[LustyExplorer-Buffers\]'),
+ \ 'minibufexplorer' : Pl#Match#Add('bufname("%")', '\-MiniBufExplorer\-'),
+ \ 'tagbar' : Pl#Match#Add('&ft' , 'tagbar'),
+ \ 'nerdtree' : Pl#Match#Add('&ft' , 'nerdtree'),
+\ }
View
30 autoload/Powerline/Segments.vim
@@ -0,0 +1,30 @@
+let g:Powerline#Segments#segments = Pl#Segment#Init([
+ \ Pl#Segment#Create('SPLIT' , '__split__'),
+ \ Pl#Segment#Create('TRUNCATE', '__truncate__'),
+ \
+ \ Pl#Segment#Create('paste_indicator' , '%{&paste ? "PASTE" : ""}', Pl#Segment#Modes('!N')),
+ \ Pl#Segment#Create('mode_indicator' , '%{Powerline#Functions#GetMode()}', Pl#Segment#Modes('!N')),
+ \ Pl#Segment#Create('fileinfo',
+ \ Pl#Segment#Create('flags.ro' , '%{&readonly ? "$RO" : ""}'),
+ \ Pl#Segment#Create('filepath' , '%{Powerline#Functions#GetFilepath()}', Pl#Segment#NoPadding()),
+ \ Pl#Segment#Create('filename' , '%t'),
+ \ Pl#Segment#Create('flags.mod' , '%M'),
+ \ Pl#Segment#Create('flags.type' , '%H%W'),
+ \ ),
+ \ Pl#Segment#Create('filename' , '%t'),
+ \ Pl#Segment#Create('filesize' , '%{Powerline#Functions#GetFilesize()}', Pl#Segment#Modes('!N')),
+ \ Pl#Segment#Create('pwd' , '%{substitute(getcwd(), expand("$HOME"), "~", "g")}'),
+ \ Pl#Segment#Create('static_str' , '%%{"%s"}'),
+ \ Pl#Segment#Create('raw' , '%s'),
+ \ Pl#Segment#Create('fileformat' , '%{&fileformat}', Pl#Segment#Modes('!N')),
+ \ Pl#Segment#Create('fileencoding' , '%{(&fenc == "" ? &enc : &fenc)}', Pl#Segment#Modes('!N')),
+ \ Pl#Segment#Create('filetype' , '%{strlen(&ft) ? &ft : "no ft"}', Pl#Segment#Modes('!N')),
+ \ Pl#Segment#Create('scrollpercent' , '%3p%%'),
+ \ Pl#Segment#Create('lineinfo',
+ \ Pl#Segment#Create('line.cur' , '$LINE %3l'),
+ \ Pl#Segment#Create('line.tot' , ':%-2c', Pl#Segment#NoPadding()),
+ \ ),
+ \ Pl#Segment#Create('charcode' , '%{Powerline#Functions#GetCharCode()}', Pl#Segment#Modes('!N')),
+ \ Pl#Segment#Create('currhigroup' , '%{synIDattr(synID(line("."), col("."), 1), "name")}', Pl#Segment#Modes('!N')),
+ \ Pl#Segment#Create('ws_marker' , '%{Powerline#Functions#GetWSMarker()}', Pl#Segment#Modes('!N')),
+\ ])
View
5 autoload/Powerline/Segments/cfi.vim
@@ -0,0 +1,5 @@
+let g:Powerline#Segments#cfi#segments = Pl#Segment#Init(['cfi',
+ \ (exists('g:cfi_disable') && g:cfi_disable == 0),
+ \
+ \ Pl#Segment#Create('current_function', '%{Powerline#Functions#cfi#GetCurrentFunction()}', Pl#Segment#Modes('!N'))
+\ ])
View
10 autoload/Powerline/Segments/ctrlp.vim
@@ -0,0 +1,10 @@
+let g:Powerline#Segments#ctrlp#segments = Pl#Segment#Init(['ctrlp'
+ \ , Pl#Segment#Create('focus', '%{"%0"}')
+ \ , Pl#Segment#Create('byfname', '%{"%1"}')
+ \ , Pl#Segment#Create('prev', '%-3{"%3"}')
+ \ , Pl#Segment#Create('item', '%-9{"%4"}')
+ \ , Pl#Segment#Create('next', '%-3{"%5"}')
+ \ , Pl#Segment#Create('marked', '%{"%6" == " <+>" ? "" : strpart("%6", 2, len("%6") - 3)}')
+ \
+ \ , Pl#Segment#Create('count', '%-6{"%0"}')
+\ ])
View
3 autoload/Powerline/Segments/ft_man.vim
@@ -0,0 +1,3 @@
+let g:Powerline#Segments#ft_man#segments = Pl#Segment#Init(['ft_man',
+ \ Pl#Segment#Create('filename', '%{Powerline#Functions#ft_man#GetName()}')
+\ ])
View
5 autoload/Powerline/Segments/fugitive.vim
@@ -0,0 +1,5 @@
+let g:Powerline#Segments#fugitive#segments = Pl#Segment#Init(['fugitive',
+ \ (exists('g:loaded_fugitive') && g:loaded_fugitive == 1),
+ \
+ \ Pl#Segment#Create('branch', '%{Powerline#Functions#fugitive#GetBranch("$BRANCH")}')
+\ ])
View
6 autoload/Powerline/Segments/rvm.vim
@@ -0,0 +1,6 @@
+let g:Powerline#Segments#rvm#segments = Pl#Segment#Init(['rvm',
+ \ (exists('g:loaded_rvm') && g:loaded_rvm == 1),
+ \
+ \ Pl#Segment#Create('string', '%{rvm#string()}'),
+ \ Pl#Segment#Create('statusline', '%{rvm#statusline()}')
+\ ])
View
5 autoload/Powerline/Segments/syntastic.vim
@@ -0,0 +1,5 @@
+let g:Powerline#Segments#syntastic#segments = Pl#Segment#Init(['syntastic',
+ \ (exists('g:loaded_syntastic_plugin') && g:loaded_syntastic_plugin == 1),
+ \
+ \ Pl#Segment#Create('errors', '%{Powerline#Functions#syntastic#GetErrors("$LINE")}', Pl#Segment#Modes('!N'))
+\ ])
View
5 autoload/Powerline/Segments/virtualenv.vim
@@ -0,0 +1,5 @@
+let g:Powerline#Segments#virtualenv#segments = Pl#Segment#Init(['virtualenv',
+ \ has('python') && (exists('g:virtualenv_loaded') && g:virtualenv_loaded == 1),
+ \
+ \ Pl#Segment#Create('statusline', '%{VirtualEnvStatusline()}')
+\ ])
View
115 autoload/Powerline/Themes/default.vim
@@ -0,0 +1,115 @@
+let g:Powerline#Themes#default#theme = Pl#Theme#Create(
+ \ Pl#Theme#Buffer(''
+ \ , 'paste_indicator'
+ \ , 'mode_indicator'
+ \ , 'fugitive:branch'
+ \ , 'fileinfo'
+ \ , 'syntastic:errors'
+ \ , Pl#Segment#Truncate()
+ \ , 'cfi:current_function'
+ \ , Pl#Segment#Split()
+ \ , 'rvm:string'
+ \ , 'virtualenv:statusline'
+ \ , 'fileformat'
+ \ , 'fileencoding'
+ \ , 'filetype'
+ \ , 'scrollpercent'
+ \ , 'lineinfo'
+ \ ),
+ \
+ \ Pl#Theme#Buffer('command_t'
+ \ , ['static_str.name', 'Command-T']
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ , ['raw.line', '%10(Match #%l%)']
+ \ ),
+ \
+ \ Pl#Theme#Buffer('gundo', Pl#Match#Any('gundo_tree')
+ \ , ['static_str.name', 'Gundo']
+ \ , ['static_str.buffer', 'Undo tree']
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ ),
+ \
+ \ Pl#Theme#Buffer('gundo', Pl#Match#Any('gundo_preview')
+ \ , ['static_str.name', 'Gundo']
+ \ , ['static_str.buffer', 'Diff preview']
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ ),
+ \
+ \ Pl#Theme#Buffer('ft_help'
+ \ , ['static_str.name', 'Help']
+ \ , 'filename'
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ , 'scrollpercent'
+ \ ),
+ \
+ \ Pl#Theme#Buffer('ft_vimpager'
+ \ , ['static_str.name', 'Pager']
+ \ , 'filename'
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ , 'scrollpercent'
+ \ ),
+ \
+ \ Pl#Theme#Buffer('lustyexplorer'
+ \ , ['static_str.name', 'LustyExplorer']
+ \ , ['static_str.buffer', 'Buffer list']
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ ),
+ \
+ \ Pl#Theme#Buffer('ft_man'
+ \ , ['static_str.name', 'Man page']
+ \ , 'filename'
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ , 'scrollpercent'
+ \ ),
+ \
+ \ Pl#Theme#Buffer('minibufexplorer'
+ \ , ['static_str.name', 'MiniBufExplorer']
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ ),
+ \
+ \ Pl#Theme#Buffer('ft_qf'
+ \ , ['static_str.name', 'Quickfix']
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ ),
+ \
+ \ Pl#Theme#Buffer('tagbar'
+ \ , ['static_str.name', 'Tagbar']
+ \ , ['static_str.buffer', 'Tree']
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ ),
+ \
+ \ Pl#Theme#Buffer('ctrlp', Pl#Theme#Callback('ctrlp_main', 'if ! exists("g:ctrlp_status_func") | let g:ctrlp_status_func = {} | endif | let g:ctrlp_status_func.main = "%s"')
+ \ , 'ctrlp:prev'
+ \ , 'ctrlp:item'
+ \ , 'ctrlp:next'
+ \ , 'ctrlp:marked'
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ , 'ctrlp:focus'
+ \ , 'ctrlp:byfname'
+ \ , 'pwd'
+ \ ),
+ \
+ \ Pl#Theme#Buffer('ctrlp', Pl#Theme#Callback('ctrlp_prog', 'if ! exists("g:ctrlp_status_func") | let g:ctrlp_status_func = {} | endif | let g:ctrlp_status_func.prog = "%s"')
+ \ , 'ctrlp:count'
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ , 'pwd'
+ \ ),
+ \
+ \ Pl#Theme#Buffer('nerdtree'
+ \ , ['raw.name', '%{Powerline#Functions#GetShortPath(4)}']
+ \ , Pl#Segment#Truncate()
+ \ , Pl#Segment#Split()
+ \ )
+\ )
View
374 doc/Powerline.txt
@@ -0,0 +1,374 @@
+*Powerline.txt* For Vim version 7.3. Last change: 2011 Nov 23
+
+ ______
+ _________ \ /__
+ \_____ \______ _ _____________ / /'__' ___ ____
+ | ___/ _ \ \/ \/ / __ \_ ___\ / | |/ \_/ __ \
+ | | | (_) \ _ / ___/| | / /__| | | \ ___/
+ '___' \____/ \/ \/ \___ |__' /___ /'__'__| /\___ \
+ \/ / / \/ \/
+ | /
+ |/
+ '
+
+==============================================================================
+CONTENTS *Powerline-contents*
+
+ 1. Introduction ....................... |Powerline-introduction|
+ 2. Usage .............................. |Powerline-usage|
+ 3. Requirements ....................... |Powerline-requirements|
+ 3.1 Recommended settings ........... |Powerline-recommended-settings|
+ 4. Configuration ...................... |Powerline-configuration|
+ 4.1 Powerline_cache_file ........... |Powerline_cache_file|
+ 4.1.1 Clearing the cache ....... |:PowerlineClearCache|
+ 4.2 Powerline_cache_enabled ........ |Powerline_cache_enabled|
+ 4.3 Powerline_symbols .............. |Powerline_symbols|
+ 4.3.1 Compatible symbols ....... |Powerline-symbols-compatible|
+ 4.3.2 Fancy symbols ............ |Powerline-symbols-fancy|
+ 4.3.3 Overriding symbols ....... |Powerline_symbols_override|
+ 4.3.4 Overriding dividers ...... |Powerline_dividers_override|
+ 4.4 Powerline_theme ................ |Powerline_theme|
+ 4.5 Powerline_colorscheme .......... |Powerline_colorscheme|
+ 4.6 Powerline_stl_path_style ....... |Powerline_stl_path_style|
+ 5. Fonts .............................. |Powerline-fonts|
+ 6. Customization ...................... |Powerline-customization|
+ 6.1 Basic customization ............ |Powerline-basic-customization|
+ 6.2 Advanced customization ......... |Powerline-advanced-customization|
+ 6.2.1 Colorschemes ............. |Powerline-cust-colorschemes|
+ 6.2.2 Functions ................ |Powerline-cust-functions|
+ 6.2.3 Segments ................. |Powerline-cust-segments|
+ 6.2.4 Themes ................... |Powerline-cust-themes|
+ 7. License ............................ |Powerline-license|
+ 8. Known issues ....................... |Powerline-known-issues|
+ 9. Contributing ....................... |Powerline-contributing|
+
+==============================================================================
+1. Introduction *Powerline* *Powerline-introduction*
+
+Powerline is a utility plugin which allows you to create better-looking, more
+functional vim statuslines.
+
+==============================================================================
+2. Usage *Powerline-usage*
+
+Powerline is automatically enabled when it's installed, either by unzipping
+the provided archive or by adding it as a Pathogen/Vundle bundle.
+
+==============================================================================
+3. Requirements *Powerline-requirements*
+
+Powerline has been developed and tested in vim 7.3, but it should run without
+any problems in vim 7.2. The default configuration requires a Unix-like system
+to work properly.
+
+The plugin only works with vim running in an 88/256-color terminal or gvim.
+
+Vi-compatible mode must be disabled.
+
+------------------------------------------------------------------------------
+3.1 Recommended settings *Powerline-recommended-settings*
+
+The following configuration options should be set in your |vimrc|: >
+
+ set nocompatible " Disable vi-compatibility
+ set laststatus=2 " Always show the statusline
+ set encoding=utf-8 " Necessary to show unicode glyphs
+
+Note: If you're using an 88/256-color terminal but still don't see the colored
+statusline, you may have to set the following option as well: >
+
+ set t_Co=256 " Explicitly tell vim that the terminal supports 256 colors
+
+==============================================================================
+4. Configuration *Powerline-configuration*
+
+Powerline will work fine without any user configuration, but default behavior
+can be overridden by setting configuration variables globally in your |vimrc|
+file.
+
+------------------------------------------------------------------------------
+4.1 Powerline_cache_file *Powerline_cache_file*
+
+By default Powerline caches all the statuslines and colors in a cache file in
+the plugin's directory (or the vim directory, depending on the installation
+method used).
+
+It's recommended that you enable the cache, as this dramatically improves vim
+startup time after the cache file has been generated (the plugin usually loads
+within ~100ms without the cache and ~1ms with the cache).
+
+Note: The default cache filename includes the current theme, colorscheme and
+symbol settings in order to tie the cache file your current configuration, so
+the cache file will be regenerated when you change any settings. This may
+leave several old cache files in your vim folder, and these may safely be
+deleted.
+
+Defaults: "<plugin_directory>/Powerline_<theme>_<colorscheme>_<symbols>.cache"
+
+------------------------------------------------------------------------------
+4.1.1 Clearing the cache *:PowerlineClearCache*
+
+Powerline provides a command to easily clear the cache after changing your
+settings or updating your theme. Simply run the following command to clear
+your cache, and restart vim afterwards: >
+
+ :PowerlineClearCache
+<
+------------------------------------------------------------------------------
+4.2 Powerline_cache_enabled *Powerline_cache_enabled*
+
+It's possible to disable statusline caching by setting this option to 0. This
+is mostly useful when developing statuslines.
+
+Default: 1
+
+------------------------------------------------------------------------------
+4.3 Powerline_symbols *Powerline_symbols*
+
+This option defines which set of symbols and dividers you want to use. There
+are currently three available options: "compatible", "unicode" and "fancy".
+
+ TYPE DESCRIPTION ~
+ compatible Doesn't use any special characters.
+ unicode Simulates icons and arrows using similar unicode glyphs.
+ fancy Custom icons and arrows. Requires a patched font.
+
+Symbols can be inserted into statuslines by using the following variables
+(just insert the variables as text in your segments):
+
+ VARIABLE DESCRIPTION ~
+ $BRANCH Inserts a branch symbol
+ $RO Inserts a read-only symbol
+ $FT Inserts a filetype symbol
+ $LINE Inserts a line number symbol
+
+Default: "compatible"
+
+------------------------------------------------------------------------------
+4.3.1 Compatible symbols *Powerline-symbols-compatible*
+
+These symbols will work in any configuration, and do not require a special
+font to work. This option will replace the fancy icons with plain text, and
+the pointy dividers with straight lines.
+
+------------------------------------------------------------------------------
+4.3.2 Fancy symbols *Powerline-symbols-fancy*
+
+These symbols require a custom font to work. A font patcher is provided for
+adding the required symbols to any outline font and some bitmap fonts, see
+|Powerline-fonts| and the provided README file for usage details.
+
+------------------------------------------------------------------------------
+4.3.3 Overriding symbols *Powerline_symbols_override*
+
+You can override symbols by adding your symbols to the
+g:Powerline_symbols_override dictionary. Example: If you want the branch
+symbol to be "∓" (hex code 0x2213) and the line symbol to be "L" you can add
+the following to your |vimrc|: >
+
+ let g:Powerline_symbols_override = {
+ \ 'BRANCH': [0x2213],
+ \ 'LINE': 'L',
+ \ }
+<
+------------------------------------------------------------------------------
+4.3.4 Overriding dividers *Powerline_dividers_override*
+
+If you for some reason want to override the dividers then you can set
+g:Powerline_dividers_override to a list with exactly four elements:
+
+ 1: Hard right-pointing arrow
+ 2: Soft right-pointing arrow
+ 3: Hard left-pointing arrow
+ 4: Soft left-pointing arrow
+
+Example: >
+
+ let g:Powerline_dividers_override = ['>>', '>', '<<', '<']
+<
+-----------------------------------------------------------------------------
+4.4 Powerline_theme *Powerline_theme*
+
+This option defines the theme Powerline uses. The available themes are located
+in autoload/Powerline/Themes/.
+
+Default: "default"
+
+------------------------------------------------------------------------------
+4.5 Powerline_colorscheme *Powerline_colorscheme*
+
+This option defines the colorscheme Powerline uses. The available colorschemes
+are located in autoload/Powerline/Colorschemes/.
+
+Default: "default"
+
+------------------------------------------------------------------------------
+4.6 Powerline_stl_path_style *Powerline_stl_path_style*
+
+There are currently four ways to display the current path and file name. The
+default is to only display the file name like the %t statusline item. By
+setting this configuration value you can choose from the following ways
+display the current path and file name:
+
+ VALUE DESCRIPTION ~
+ filename Display only the file name using the %t statusline item.
+ short Display a short path. The home directory is substituted with
+ "~", the first directory is displayed with its full name, and
+ subsequent directories are shortened to their first letter.
+ I.e. "/home/user/foo/bar/baz.vim" becomes "~/f/b/baz.vim" and
+ "long/relative/path/foo/bar/baz.vim becomes
+ "long/r/p/f/b/baz.vim".
+ relative Display a relative path, similar to the %f statusline item.
+ full Display the full path, similar to the %F statusline item.
+
+Default: "relative"
+
+==============================================================================
+5. Fonts *Powerline-fonts*
+
+TODO
+
+==============================================================================
+6. Customization *Powerline-customization*
+
+There are currently two ways of customizing Powerline: Basic customization
+using a couple of functions to insert and remove existing segments from the
+statusline, and advanced customization using your own autoload files. The
+customization features of Powerline allow you to create your own statuslines
+without ever touching the original source code.
+
+------------------------------------------------------------------------------
+6.1 Basic customization *Powerline-basic-customization*
+
+Powerline provides the following functions to alter the default statusline
+look. These functions should be called from your |vimrc| file or another file
+which is sourced at vim startup.
+
+Note: These functions are currently applied to all statuslines, so if you
+insert a segment after a segment which is present in many statuslines (e.g.
+the "filename" segment), all the statuslines will have the inserted segment.
+This behavior may be changed in a future version of Powerline.
+
+Note: Remember to clear your cache with |:PowerlineClearCache| after changing
+your statusline!
+
+Example: >
+
+ " Insert the charcode segment after the filetype segment
+ call Pl#Theme#InsertSegment('charcode', 'after', 'filetype')
+
+ " Replace the scrollpercent segment with the charcode segment
+ call Pl#Theme#ReplaceSegment('scrollpercent', 'fileinfo')
+<
+ *Pl#Theme#InsertSegment*
+Pl#Theme#InsertSegment({newsegment}, {location}, {targetsegment})
+
+This function inserts {newsegment} before or after {targetsegment}. The
+{location} parameter specifies the location of the new segment, valid values
+are "before" and "after". You can see all the available segments in
+autoload/Powerline/Segments.vim and the files specified in
+|Powerline-cust-segments|.
+
+Pl#Theme#RemoveSegment({targetsegment}) *Pl#Theme#RemoveSegment*
+
+This function removes the {targetsegment} segment entirely.
+
+Pl#Theme#ReplaceSegment({oldsegment}, {newsegment}) *Pl#Theme#ReplaceSegment*
+
+This function replaces {oldsegment} with {newsegment}.
+
+------------------------------------------------------------------------------
+6.2 Advanced customization *Powerline-advanced-customization*
+
+Because Powerline utilizes vim's autoload functionality, you can easily create
+your own segments, themes, functions and colorschemes without touching the
+original source code. This is a bit more complex than using the utility
+functions, but it allows you to do a lot more with your statusline.
+
+Your custom autoload files should be stored in your |runtimepath| (usually in
+"~/.vim/autoload/Powerline/*").
+
+Note: Remember to clear your cache with |:PowerlineClearCache| after changing
+your statusline!
+
+6.2.1 Colorschemes *Powerline-cust-colorschemes*
+------------------------------------------------------------------------------
+
+Colorschemes should be stored as separate files in
+{runtimepath}/autoload/Powerline/Colorschemes/.
+
+SYNTAX ~
+
+TODO
+
+EXAMPLE ~
+
+TODO
+
+6.2.2 Functions *Powerline-cust-functions*
+------------------------------------------------------------------------------
+
+Functions should be stored as separate files in
+{runtimepath}/autoload/Powerline/Functions/.
+
+SYNTAX ~
+
+TODO
+
+EXAMPLE ~
+
+TODO
+
+6.2.3 Segments *Powerline-cust-segments*
+------------------------------------------------------------------------------
+
+Segments should be stored as separate files in
+{runtimepath}/autoload/Powerline/Segments/.
+
+SYNTAX ~
+
+TODO
+
+EXAMPLE ~
+
+TODO
+
+6.2.4 Themes *Powerline-cust-themes*
+------------------------------------------------------------------------------
+
+Themes should be stored as separate files in
+{runtimepath}/autoload/Powerline/Themes/.
+
+SYNTAX ~
+
+TODO
+
+EXAMPLE ~
+
+TODO
+
+==============================================================================
+7. License *Powerline-license*
+
+Creative Commons Attribution-ShareAlike 3.0 Unported
+
+http://creativecommons.org/licenses/by-sa/3.0/
+
+==============================================================================
+8. Known issues *Powerline-known-issues*
+
+See the issue tracker at
+https://github.com/Lokaltog/vim-powerline/issues
+
+==============================================================================
+9. Contributing *Powerline-contributing*
+
+If you experience any bugs or have feature requests, please open an issue on
+GitHub. Fork the source repository on GitHub and send a pull request if you
+have any code improvements.
+
+Author: Kim Silkebækken <kim.silkebaekken+vim@gmail.com>
+Source repository: https://github.com/Lokaltog/vim-powerline
+
+==============================================================================
+vim:tw=78:sw=4:ts=8:ft=help:norl:
View
61 plugin/Powerline.vim
@@ -0,0 +1,61 @@
+" Powerline - The ultimate statusline utility
+"
+" Author: Kim Silkebækken <kim.silkebaekken+vim@gmail.com>
+" Source repository: https://github.com/Lokaltog/vim-powerline
+
+" Script initialization {{{
+ if exists('g:Powerline_loaded') || &compatible || version < 702
+ finish
+ endif
+
+ let g:Powerline_loaded = 1
+" }}}
+" Commands {{{
+ command! PowerlineClearCache call Pl#ClearCache()
+ command! PowerlineReloadColorscheme call Pl#ReloadColorscheme()
+" }}}
+" Set default options {{{
+ for [s:key, s:value] in items({
+ \ 'theme' : 'default'
+ \ , 'colorscheme' : 'default'
+ \ , 'symbols' : 'compatible'
+ \ , 'symbols_override' : {}
+ \ , 'dividers_override': []
+ \ , 'stl_path_style' : 'relative'
+ \ , 'cache_enabled' : 1
+ \ })
+
+ if ! exists('g:Powerline_' . s:key)
+ exec printf('let g:Powerline_%s = %s', s:key, string(s:value))
+ endif
+
+ unlet! s:key s:value
+ endfor
+
+ if ! exists('g:Powerline_cache_file')
+ exec 'let g:Powerline_cache_file = '. string(printf('%s/Powerline_%s_%s_%s.cache'
+ \ , simplify(expand('<sfile>:p:h') .'/..')
+ \ , g:Powerline_theme
+ \ , g:Powerline_colorscheme
+ \ , g:Powerline_symbols
+ \ ))
+ endif
+" }}}
+" Autocommands {{{
+ augroup Powerline
+ autocmd!
+
+ " Reload statuslines when changing color scheme
+ au ColorScheme *
+ \ call Pl#Load()
+
+ au BufEnter,WinEnter,FileType,BufUnload *
+ \ call Pl#UpdateStatusline(1)
+
+ au BufLeave,WinLeave *
+ \ call Pl#UpdateStatusline(0)
+
+ au BufWritePost */autoload/Powerline/Colorschemes/*.vim
+ \ :PowerlineReloadColorscheme
+ augroup END
+" }}}

0 comments on commit e5692a7

Please sign in to comment.
Something went wrong with that request. Please try again.