From 321ecaca67426410316db7db05e6e33809fe1e63 Mon Sep 17 00:00:00 2001 From: Ben Beltran Date: Fri, 19 Oct 2012 15:09:38 -0500 Subject: Add powerline --- vim/autoload/Pl/Colorscheme.vim | 145 +++++++++++++++++ vim/autoload/Pl/Hi.vim | 140 +++++++++++++++++ vim/autoload/Pl/Match.vim | 43 +++++ vim/autoload/Pl/Mod.vim | 40 +++++ vim/autoload/Pl/Parser.vim | 339 ++++++++++++++++++++++++++++++++++++++++ vim/autoload/Pl/Segment.vim | 178 +++++++++++++++++++++ vim/autoload/Pl/Theme.vim | 100 ++++++++++++ 7 files changed, 985 insertions(+) create mode 100644 vim/autoload/Pl/Colorscheme.vim create mode 100644 vim/autoload/Pl/Hi.vim create mode 100644 vim/autoload/Pl/Match.vim create mode 100644 vim/autoload/Pl/Mod.vim create mode 100644 vim/autoload/Pl/Parser.vim create mode 100644 vim/autoload/Pl/Segment.vim create mode 100644 vim/autoload/Pl/Theme.vim (limited to 'vim/autoload/Pl') diff --git a/vim/autoload/Pl/Colorscheme.vim b/vim/autoload/Pl/Colorscheme.vim new file mode 100644 index 0000000..ec15e46 --- /dev/null +++ b/vim/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 " }}} diff --git a/vim/autoload/Pl/Hi.vim b/vim/autoload/Pl/Hi.vim new file mode 100644 index 0000000..f6b3eea --- /dev/null +++ b/vim/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 " }}} diff --git a/vim/autoload/Pl/Match.vim b/vim/autoload/Pl/Match.vim new file mode 100644 index 0000000..b05f585 --- /dev/null +++ b/vim/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 " }}} diff --git a/vim/autoload/Pl/Mod.vim b/vim/autoload/Pl/Mod.vim new file mode 100644 index 0000000..fdfb571 --- /dev/null +++ b/vim/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 " }}} diff --git a/vim/autoload/Pl/Parser.vim b/vim/autoload/Pl/Parser.vim new file mode 100644 index 0000000..75c0b8f --- /dev/null +++ b/vim/autoload/Pl/Parser.vim @@ -0,0 +1,339 @@ +let g:Pl#Parser#Symbols = { + \ 'compatible': { + \ 'dividers': [ '', [0x2502], '', [0x2502] ] + \ , 'symbols' : { + \ 'BRANCH': 'BR:' + \ , 'RO' : 'RO' + \ , 'FT' : 'FT' + \ , 'LINE' : 'LN' + \ , 'COL' : 'C' + \ } + \ }, + \ 'unicode': { + \ 'dividers': [ [0x25b6], [0x276f], [0x25c0], [0x276e] ] + \ , 'symbols' : { + \ 'BRANCH': [0x26a1] + \ , 'RO' : [0x2613] + \ , 'FT' : [0x2691] + \ , 'LINE' : [0x204b] + \ , 'COL' : [0x2551] + \ }, + \ }, + \ 'fancy': { + \ 'dividers': [ [0x2b80], [0x2b81], [0x2b82], [0x2b83] ] + \ , 'symbols' : { + \ 'BRANCH': [0x2b60] + \ , 'RO' : [0x2b64] + \ , 'FT' : [0x2b62, 0x2b63] + \ , 'LINE' : [0x2b61] + \ , 'COL' : [0x2551] + \ } + \ } +\ } + +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 + let padding_right = (side == s:LEFT_SIDE ? repeat(' ', s:PADDING) : '') + let padding_left = (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 " }}} diff --git a/vim/autoload/Pl/Segment.vim b/vim/autoload/Pl/Segment.vim new file mode 100644 index 0000000..5ce68b9 --- /dev/null +++ b/vim/autoload/Pl/Segment.vim @@ -0,0 +1,178 @@ +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 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(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 + \ }] + 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') + endfor + + return ['segment', { + \ 'type': 'segment' + \ , 'name': name + \ , 'text': text + \ , 'modes': modes + \ }] + endif + +endfunction " }}} +function! Pl#Segment#Init(...) " {{{ + " Check condition parameters + if ! s:CheckConditions(a:000) + return {} + endif + + let segments = {} + let ns = '' + + for param in a:000 + 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#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 " }}} diff --git a/vim/autoload/Pl/Theme.vim b/vim/autoload/Pl/Theme.vim new file mode 100644 index 0000000..da1581e --- /dev/null +++ b/vim/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 " }}} -- cgit