[rbdr/dotfiles] / vim / autoload / Pl / Parser.vim

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 " }}}
Commit	Line	Data
321ecaca BB	1	let g:Pl#Parser#Symbols = {
	2	\ 'compatible': {
	3	\ 'dividers': [ '', [0x2502], '', [0x2502] ]
	4	\ , 'symbols' : {
	5	\ 'BRANCH': 'BR:'
	6	\ , 'RO' : 'RO'
	7	\ , 'FT' : 'FT'
	8	\ , 'LINE' : 'LN'
	9	\ , 'COL' : 'C'
	10	\ }
	11	\ },
	12	\ 'unicode': {
	13	\ 'dividers': [ [0x25b6], [0x276f], [0x25c0], [0x276e] ]
	14	\ , 'symbols' : {
	15	\ 'BRANCH': [0x26a1]
	16	\ , 'RO' : [0x2613]
	17	\ , 'FT' : [0x2691]
	18	\ , 'LINE' : [0x204b]
	19	\ , 'COL' : [0x2551]
	20	\ },
	21	\ },
	22	\ 'fancy': {
	23	\ 'dividers': [ [0x2b80], [0x2b81], [0x2b82], [0x2b83] ]
	24	\ , 'symbols' : {
	25	\ 'BRANCH': [0x2b60]
	26	\ , 'RO' : [0x2b64]
	27	\ , 'FT' : [0x2b62, 0x2b63]
	28	\ , 'LINE' : [0x2b61]
	29	\ , 'COL' : [0x2551]
	30	\ }
	31	\ }
	32	\ }
	33
	34	let s:LEFT_SIDE = 0
	35	let s:RIGHT_SIDE = 2
	36
	37	let s:PADDING = 1
	38
	39	let s:EMPTY_SEGMENT = { 'type': 'empty' }
	40
	41	let s:HARD_DIVIDER = 0
	42	let s:SOFT_DIVIDER = 1
	43
	44	function! Pl#Parser#GetStatusline(segments) " {{{
	45	let statusline = {
	46	\ 'n': ''
	47	\ , 'N': ''
	48	\ , 'v': ''
	49	\ , 'i': ''
	50	\ , 'r': ''
	51	\ , 's': ''
	52	\ }
	53
	54	" Run through the different modes and create the statuslines
	55	for mode in keys(statusline)
	56	" Create an empty statusline list
	57	let stl = []
	58
	59	call extend(stl, s:ParseSegments(mode, s:LEFT_SIDE, a:segments))
	60
	61	let statusline[mode] .= join(stl, '')
	62	endfor
	63
	64	return statusline
65	endfunction " }}}
66	function! Pl#Parser#ParseChars(arg) " {{{
67	" Handles symbol arrays which can be either an array of hex values,
68	" or a string. Will convert the hex array to a string, or return the
69	" string as-is.
70	let arg = a:arg
71
72	if type(arg) == type([])
73	" Hex array
74	call map(arg, 'nr2char(v:val)')
75
76	return join(arg, '')
77	endif
78
79	" Anything else, just return it as it is
80	return arg
81	endfunction " }}}
82	function! s:ParseSegments(mode, side, segments, ...) " {{{
83	let mode = a:mode
84	let side = a:side
85	let segments = a:segments
86
87	let level = exists('a:1') ? a:1 : 0
88	let base_color = exists('a:2') ? a:2 : {}
89
90	let ret = []
91
92	for i in range(0, len(segments) - 1)
93	unlet! seg_prev seg_curr seg_next
94
95	" Prepare some resources (fetch previous, current and next segment)
96	let seg_curr = deepcopy(get(segments, i))
97
98	" Find previous segment
99	let seg_prev = s:EMPTY_SEGMENT
100
101	" If we're currently at i = 0 we have to start on 0 or else we will start on the last segment (list[-1])
102	let range_start = (i == 0 ? i : i - 1)
103	for j in range(range_start, 0, -1)
104	let seg = deepcopy(get(segments, j))
105	if get(seg, 'name') ==# 'TRUNCATE'
106	" Skip truncate segments
107	continue
108	endif
109
110	" Look ahead for another segment that's visible in this mode
111	if index(get(seg, 'modes'), mode) != -1
112	" Use this segment
113	let seg_prev = seg
114
115	break
116	endif
117	endfor
118
119	"" Find next segment
120	let seg_next = s:EMPTY_SEGMENT
121
122	" 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
123	let range_start = (i == len(segments) - 1 ? i : i + 1)
124	for j in range(range_start, len(segments) - 1, 1)
125	let seg = deepcopy(get(segments, j))
126	if get(seg, 'name') ==# 'TRUNCATE'
127	" Skip truncate segments
128	continue
129	endif
130
131	" Look ahead for another segment that's visible in this mode
132	if index(get(seg, 'modes'), mode) != -1
133	" Use this segment
134	let seg_next = seg
135
136	break
137	endif
138	endfor
139
140	if index(get(seg_curr, 'modes', []), mode) == -1
141	" The segment is invisible in this mode, skip it
142	" FIXME When two segments after each other are hidden, a gap appears where the segments would be, this is probably due to segment padding
143	continue
144	endif
145
146	" Handle the different segment types
147	if seg_curr.type == 'segment'
148	if seg_curr.name ==# 'TRUNCATE'
149	" Truncate statusline
150	call add(ret, '%<')
151	elseif seg_curr.name ==# 'SPLIT'
152	" Split statusline
153
154	" Switch sides
155	let side = s:RIGHT_SIDE
156
157	" Handle highlighting
158	let mode_colors = get(seg_curr.colors, mode, seg_curr.colors['n'])
159	let hl_group = s:HlCreate(mode_colors)
160
161	" Add segment text
162	call add(ret, '%#'. hl_group .'#%=')
163	else
164	" Add segment text
165	let text = seg_curr.text
166
167	" Decide on whether to use the group's colors or the segment's colors
168	let colors = get(seg_curr, 'colors', base_color)
169
170	" Fallback to normal (current) highlighting if we don't have mode-specific highlighting
171	let mode_colors = get(colors, mode, get(colors, 'n', {}))
172
173	if empty(mode_colors)
174	echom 'Segment doesn''t have any colors! NS: "'. seg_curr.ns .'" SEG: "'. seg_curr.name .'"'
175
176	continue
177	endif
178
179	" Check if we're in a group (level > 0)
180	if level > 0
181	" If we're in a group we don't have dividers between segments, so we should only pad one side
182	let padding_right = (side == s:LEFT_SIDE ? repeat(' ', s:PADDING) : '')
183	let padding_left = (side == s:RIGHT_SIDE ? repeat(' ', s:PADDING) : '')
184
185	" Check if we lack a bg/fg color for this segment
186	" If we do, use the bg/fg color from base_color
187	let base_color_mode = ! has_key(base_color, mode) ? base_color['n'] : base_color[mode]
188
189	for col in ['ctermbg', 'ctermfg', 'guibg', 'guifg']
190	if empty(mode_colors[col])
191	let mode_colors[col] = base_color_mode[col]
192	endif
193	endfor
194	else
195	"" If we're outside a group we have dividers and must pad both sides
196	let padding_left = repeat(' ', s:PADDING)
197	let padding_right = repeat(' ', s:PADDING)
198	endif
199
200	" Get main hl group for segment
201	let hl_group = s:HlCreate(mode_colors)
202
203	" Prepare segment text
204	let text = '%(%#'. hl_group .'#'. padding_left . text . padding_right . '%)'
205
206	if level == 0
207	" Add divider to single segments
208	let text = s:AddDivider(text, side, mode, colors, seg_prev, seg_curr, seg_next)
209	endif
210
211	call add(ret, text)
212	endif
213	elseif seg_curr.type == 'segment_group'
214	" Recursively parse segment group
215	let func_params = [mode, side, seg_curr.segments, level + 1]
216
217	if has_key(seg_curr, 'colors')
218	" Pass the base colors on to the child segments
219	call add(func_params, seg_curr.colors)
220	endif
221
222	" Get segment group string
223	let text = join(call('s:ParseSegments', func_params), '')
224
225	" Pad on the opposite side of the divider
226	let padding_right = (side == s:RIGHT_SIDE ? repeat(' ', s:PADDING) : '')
227	let padding_left = (side == s:LEFT_SIDE ? repeat(' ', s:PADDING) : '')
228
229	let text = s:AddDivider(padding_left . text . padding_right, side, mode, seg_curr.colors, seg_prev, seg_curr, seg_next)
230
231	call add(ret, text)
232	endif
233	endfor
234
235	return ret
236	endfunction " }}}
237	function! s:HlCreate(hl) " {{{
238	" Create a short and unique highlighting group name
239	" It uses the hex values of all the color properties and an attribute flag at the end
240	" NONE colors are translated to NN for cterm and NNNNNN for gui colors
241	let hi_group = printf('Pl%s%s%s%s%s'
242	\ , (a:hl['ctermfg'] == 'NONE' ? 'NN' : printf('%02x', a:hl['ctermfg']))
243	\ , (a:hl['guifg'] == 'NONE' ? 'NNNNNN' : printf('%06x', a:hl['guifg'] ))
244	\ , (a:hl['ctermbg'] == 'NONE' ? 'NN' : printf('%02x', a:hl['ctermbg']))
245	\ , (a:hl['guibg'] == 'NONE' ? 'NNNNNN' : printf('%06x', a:hl['guibg'] ))
246	\ , substitute(a:hl['attr'], '\v([a-zA-Z])[a-zA-Z]*,?', '\1', 'g')
247	\ )
248
249	if ! s:HlExists(hi_group)
250	let ctermbg = a:hl['ctermbg'] == 'NONE' ? 'NONE' : printf('%d', a:hl['ctermbg'])
251	if (has('win32') \|\| has('win64')) && !has('gui_running') && ctermbg != 'NONE' && ctermbg > 128
252	let ctermbg -= 128
253	endif
254	let hi_cmd = printf('hi %s ctermfg=%s ctermbg=%s cterm=%s guifg=%s guibg=%s gui=%s'
255	\ , hi_group
256	\ , a:hl['ctermfg'] == 'NONE' ? 'NONE' : printf('%d', a:hl['ctermfg'])
257	\ , ctermbg
258	\ , a:hl['attr']
259	\ , (a:hl['guifg'] == 'NONE' ? 'NONE' : printf('#%06x', a:hl['guifg']))
260	\ , (a:hl['guibg'] == 'NONE' ? 'NONE' : printf('#%06x', a:hl['guibg']))
261	\ , a:hl['attr']
262	\ )
263
264	exec hi_cmd
265
266	" Add command to Pl#HL list for caching
267	call add(g:Pl#HL, hi_cmd)
268	endif
269
270	" Return only the highlighting group name
271	return hi_group
272	endfunction " }}}
273	function! s:HlExists(hl) " {{{
274	if ! hlexists(a:hl)
275	return 0
276	endif
277
278	redir => hlstatus
279	silent exec 'hi' a:hl
280	redir END
281
282	return (hlstatus !~ 'cleared')
283	endfunction " }}}
284	function! s:AddDivider(text, side, mode, colors, prev, curr, next) " {{{
285	let seg_prev = a:prev
286	let seg_curr = a:curr
287	let seg_next = a:next
288
289	" Set default color/type for the divider
290	let div_colors = get(a:colors, a:mode, a:colors['n'])
291	let div_type = s:SOFT_DIVIDER
292
293	" Define segment to compare
294	let cmp_seg = a:side == s:LEFT_SIDE ? seg_next : seg_prev
295
296	let cmp_all_colors = get(cmp_seg, 'colors', {})
297	let cmp_colors = get(cmp_all_colors, a:mode, get(cmp_all_colors, 'n', {}))
298
299	if ! empty(cmp_colors)
300	" Compare the highlighting groups
301	"
302	" If the background color for cterm is equal, use soft divider with the current segment's highlighting
303	" If not, use hard divider with a new highlighting group
304	"
305	" Note that if the previous/next segment is the split, a hard divider is always used
306	if get(div_colors, 'ctermbg') != get(cmp_colors, 'ctermbg') \|\| get(seg_next, 'name') ==# 'SPLIT' \|\| get(seg_prev, 'name') ==# 'SPLIT'
307	let div_type = s:HARD_DIVIDER
308
309	" Create new highlighting group
310	" Use FG = CURRENT BG, BG = CMP BG
311	let div_colors['ctermfg'] = get(div_colors, 'ctermbg')
312	let div_colors['guifg'] = get(div_colors, 'guibg')
313
314	let div_colors['ctermbg'] = get(cmp_colors, 'ctermbg')
315	let div_colors['guibg'] = get(cmp_colors, 'guibg')
316
317	let div_colors['attr'] = 'NONE'
318	endif
319	endif
320
321	" Prepare divider
322	let divider_raw = deepcopy(g:Pl#Parser#Symbols[g:Powerline_symbols].dividers[a:side + div_type])
323	let divider = Pl#Parser#ParseChars(divider_raw)
324
325	" Don't add dividers for segments adjacent to split (unless it's a hard divider)
326	if ((get(seg_next, 'name') ==# 'SPLIT' \|\| get(seg_prev, 'name') ==# 'SPLIT') && div_type != s:HARD_DIVIDER)
327	return ''
328	endif
329
330	if a:side == s:LEFT_SIDE
331	" Left side
332	" Divider to the right
333	return printf('%%(%s%%#%s#%s%%)', a:text, s:HlCreate(div_colors), divider)
334	else
335	" Right side
336	" Divider to the left
337	return printf('%%(%%#%s#%s%s%%)', s:HlCreate(div_colors), divider, a:text)
338	endif
339	endfunction " }}}