942 lines
29 KiB
VimL
942 lines
29 KiB
VimL
" Related to float window create
|
|
let s:is_vim = !has('nvim')
|
|
let s:borderchars = get(g:, 'coc_borderchars',
|
|
\ ['─', '│', '─', '│', '┌', '┐', '┘', '└'])
|
|
let s:prompt_win_width = get(g:, 'coc_prompt_win_width', 32)
|
|
let s:scrollbar_ns = exists('*nvim_create_namespace') ? nvim_create_namespace('coc-scrollbar') : 0
|
|
" winvar: border array of numbers, button boolean
|
|
|
|
" detect if there's float window/popup created by coc.nvim
|
|
function! coc#float#has_float() abort
|
|
if s:is_vim
|
|
if !exists('*popup_list')
|
|
return 0
|
|
endif
|
|
let arr = filter(popup_list(), 'getwinvar(v:val,"float",0)&&popup_getpos(v:val)["visible"]')
|
|
return !empty(arr)
|
|
endif
|
|
for i in range(1, winnr('$'))
|
|
if getwinvar(i, 'float')
|
|
return 1
|
|
endif
|
|
endfor
|
|
return 0
|
|
endfunction
|
|
|
|
function! coc#float#close_all() abort
|
|
if !has('nvim') && exists('*popup_clear')
|
|
call popup_clear()
|
|
return
|
|
endif
|
|
let winids = coc#float#get_float_win_list()
|
|
for id in winids
|
|
call coc#float#close(id)
|
|
endfor
|
|
endfunction
|
|
|
|
function! coc#float#jump() abort
|
|
if s:is_vim
|
|
return
|
|
endif
|
|
let winids = coc#float#get_float_win_list()
|
|
if !empty(winids)
|
|
call win_gotoid(winids[0])
|
|
endif
|
|
endfunction
|
|
|
|
function! coc#float#get_float_mode(lines, config) abort
|
|
let allowSelection = get(a:config, 'allowSelection', 0)
|
|
let pumAlignTop = get(a:config, 'pumAlignTop', 0)
|
|
let mode = mode()
|
|
let checked = (mode == 's' && allowSelection) || index(['i', 'n', 'ic'], mode) != -1
|
|
if !checked
|
|
return v:null
|
|
endif
|
|
if !s:is_vim && mode ==# 'i'
|
|
" helps to fix undo issue, don't know why.
|
|
call feedkeys("\<C-g>u", 'n')
|
|
endif
|
|
let dimension = coc#float#get_config_cursor(a:lines, a:config)
|
|
if empty(dimension)
|
|
return v:null
|
|
endif
|
|
if pumvisible() && ((pumAlignTop && dimension['row'] <0)|| (!pumAlignTop && dimension['row'] > 0))
|
|
return v:null
|
|
endif
|
|
return [mode, bufnr('%'), [line('.'), col('.')], dimension]
|
|
endfunction
|
|
|
|
" create/reuse float window for config position, config including:
|
|
" - line: line count relative to cursor, nagetive number means abover cursor.
|
|
" - col: column count relative to cursor, nagetive number means left of cursor.
|
|
" - width: content width without border and title.
|
|
" - height: content height without border and title.
|
|
" - title: (optional) title.
|
|
" - border: (optional) border as number list, like [1, 1, 1 ,1].
|
|
" - cursorline: (optional) enable cursorline when is 1.
|
|
" - autohide: (optional) window should be closed on CursorMoved when is 1.
|
|
function! coc#float#create_float_win(winid, bufnr, config) abort
|
|
call coc#float#close_auto_hide_wins(a:winid)
|
|
" use exists
|
|
if a:winid && coc#float#valid(a:winid)
|
|
if s:is_vim
|
|
let [line, col] = s:popup_position(a:config)
|
|
call popup_move(a:winid, {
|
|
\ 'line': line,
|
|
\ 'col': col,
|
|
\ 'minwidth': a:config['width'],
|
|
\ 'minheight': a:config['height'],
|
|
\ 'maxwidth': a:config['width'],
|
|
\ 'maxheight': a:config['height'],
|
|
\ })
|
|
let opts = {
|
|
\ 'cursorline': get(a:config, 'cursorline', 0),
|
|
\ 'title': get(a:config, 'title', ''),
|
|
\ }
|
|
if !s:empty_border(get(a:config, 'border', []))
|
|
let opts['border'] = a:config['border']
|
|
endif
|
|
call popup_setoptions(a:winid, opts)
|
|
return [a:winid, winbufnr(a:winid)]
|
|
else
|
|
let config = s:convert_config_nvim(a:config)
|
|
" not reuse related windows
|
|
call coc#float#nvim_close_related(a:winid)
|
|
call nvim_win_set_config(a:winid, config)
|
|
call coc#float#nvim_create_related(a:winid, config, a:config)
|
|
return [a:winid, winbufnr(a:winid)]
|
|
endif
|
|
endif
|
|
let winid = 0
|
|
if s:is_vim
|
|
let [line, col] = s:popup_position(a:config)
|
|
let bufnr = coc#float#create_float_buf(a:bufnr)
|
|
let title = get(a:config, 'title', '')
|
|
let opts = {
|
|
\ 'title': title,
|
|
\ 'line': line,
|
|
\ 'col': col,
|
|
\ 'padding': empty(title) ? [0, 1, 0, 1] : [0, 0, 0, 0],
|
|
\ 'borderchars': s:borderchars,
|
|
\ 'highlight': 'CocFloating',
|
|
\ 'fixed': 1,
|
|
\ 'cursorline': get(a:config, 'cursorline', 0),
|
|
\ 'minwidth': a:config['width'],
|
|
\ 'minheight': a:config['height'],
|
|
\ 'maxwidth': a:config['width'],
|
|
\ 'maxheight': a:config['height']
|
|
\ }
|
|
if get(a:config, 'close', 0)
|
|
let opts['close'] = 'button'
|
|
endif
|
|
if !s:empty_border(get(a:config, 'border', []))
|
|
let opts['border'] = a:config['border']
|
|
endif
|
|
let winid = popup_create(bufnr, opts)
|
|
if winid == 0
|
|
return []
|
|
endif
|
|
if has("patch-8.1.2281")
|
|
call setwinvar(winid, '&showbreak', 'NONE')
|
|
endif
|
|
else
|
|
let config = s:convert_config_nvim(a:config)
|
|
let bufnr = coc#float#create_float_buf(a:bufnr)
|
|
let winid = nvim_open_win(bufnr, 0, config)
|
|
if winid == 0
|
|
return []
|
|
endif
|
|
call setwinvar(winid, '&winhl', 'Normal:CocFloating,NormalNC:CocFloating,FoldColumn:CocFloating,CursorLine:CocMenuSel')
|
|
call setwinvar(winid, '&signcolumn', 'no')
|
|
" no left border
|
|
if s:empty_border(get(a:config, 'border', [])) || a:config['border'][3] == 0
|
|
call setwinvar(winid, '&foldcolumn', 1)
|
|
endif
|
|
call coc#float#nvim_create_related(winid, config, a:config)
|
|
endif
|
|
if !s:is_vim
|
|
" change cursorline option affects vim's own highlight
|
|
call setwinvar(winid, '&cursorline', get(a:config, 'cursorline', 0))
|
|
call setwinvar(winid, 'border', get(a:config, 'border', []))
|
|
endif
|
|
if get(a:config, 'autohide', 0)
|
|
call setwinvar(winid, 'autohide', 1)
|
|
endif
|
|
if s:is_vim || has('nvim-0.5.0')
|
|
call setwinvar(winid, '&scrolloff', 0)
|
|
endif
|
|
call setwinvar(winid, '&list', 0)
|
|
call setwinvar(winid, '&number', 0)
|
|
call setwinvar(winid, '&relativenumber', 0)
|
|
call setwinvar(winid, '&cursorcolumn', 0)
|
|
call setwinvar(winid, '&colorcolumn', 0)
|
|
call setwinvar(winid, 'float', 1)
|
|
call setwinvar(winid, '&wrap', 1)
|
|
call setwinvar(winid, '&linebreak', 1)
|
|
call setwinvar(winid, '&conceallevel', 2)
|
|
let g:coc_last_float_win = winid
|
|
call coc#util#do_autocmd('CocOpenFloat')
|
|
return [winid, winbufnr(winid)]
|
|
endfunction
|
|
|
|
function! coc#float#valid(winid) abort
|
|
if a:winid == 0 || type(a:winid) != 0
|
|
return 0
|
|
endif
|
|
if s:is_vim
|
|
return s:popup_visible(a:winid)
|
|
endif
|
|
if exists('*nvim_win_is_valid') && nvim_win_is_valid(a:winid)
|
|
let config = nvim_win_get_config(a:winid)
|
|
return !empty(get(config, 'relative', ''))
|
|
endif
|
|
return 0
|
|
endfunction
|
|
|
|
" create buffer for popup/float window
|
|
function! coc#float#create_float_buf(bufnr) abort
|
|
" reuse buffer cause error on vim8
|
|
if a:bufnr && bufloaded(a:bufnr)
|
|
return a:bufnr
|
|
endif
|
|
if s:is_vim
|
|
noa let bufnr = bufadd('')
|
|
noa call bufload(bufnr)
|
|
else
|
|
noa let bufnr = nvim_create_buf(v:false, v:true)
|
|
endif
|
|
" Don't use popup filetype, it would crash on reuse!
|
|
call setbufvar(bufnr, '&buftype', 'nofile')
|
|
call setbufvar(bufnr, '&bufhidden', 'hide')
|
|
call setbufvar(bufnr, '&swapfile', 0)
|
|
call setbufvar(bufnr, '&tabstop', 2)
|
|
call setbufvar(bufnr, '&undolevels', -1)
|
|
return bufnr
|
|
endfunction
|
|
|
|
" border window for neovim, content config with border
|
|
function! coc#float#nvim_border_win(config, border, title, related) abort
|
|
if s:empty_border(a:border)
|
|
return
|
|
endif
|
|
" width height col row relative
|
|
noa let bufnr = nvim_create_buf(v:false, v:true)
|
|
call setbufvar(bufnr, '&bufhidden', 'wipe')
|
|
let row = a:border[0] ? a:config['row'] - 1 : a:config['row']
|
|
let col = a:border[3] ? a:config['col'] - 1 : a:config['col']
|
|
let width = a:config['width'] + a:border[1] + a:border[3]
|
|
let height = a:config['height'] + a:border[0] + a:border[2]
|
|
let opt = {
|
|
\ 'relative': a:config['relative'],
|
|
\ 'width': width,
|
|
\ 'height': height,
|
|
\ 'row': row,
|
|
\ 'col': col,
|
|
\ 'focusable': v:false,
|
|
\ 'style': 'minimal',
|
|
\ }
|
|
let winid = nvim_open_win(bufnr, 0, opt)
|
|
if !winid
|
|
return
|
|
endif
|
|
call setwinvar(winid, '&winhl', 'Normal:CocFloating,NormalNC:CocFloating')
|
|
let lines = coc#float#create_border_lines(a:border, a:title, a:config['width'], a:config['height'])
|
|
call nvim_buf_set_lines(bufnr, 0, -1, v:false, lines)
|
|
call add(a:related, winid)
|
|
endfunction
|
|
|
|
function! coc#float#create_border_lines(border, title, width, height) abort
|
|
let list = []
|
|
if a:border[0]
|
|
let top = (a:border[3] ? s:borderchars[4]: '')
|
|
\.repeat(s:borderchars[0], a:width)
|
|
\.(a:border[1] ? s:borderchars[5] : '')
|
|
if !empty(a:title)
|
|
let top = coc#helper#str_compose(top, 1, a:title.' ')
|
|
endif
|
|
call add(list, top)
|
|
endif
|
|
let mid = (a:border[3] ? s:borderchars[3]: '')
|
|
\.repeat(' ', a:width)
|
|
\.(a:border[1] ? s:borderchars[1] : '')
|
|
call extend(list, repeat([mid], a:height))
|
|
if a:border[2]
|
|
let bot = (a:border[3] ? s:borderchars[7]: '')
|
|
\.repeat(s:borderchars[2], a:width)
|
|
\.(a:border[1] ? s:borderchars[6] : '')
|
|
call add(list, bot)
|
|
endif
|
|
return list
|
|
endfunction
|
|
|
|
" Create float window for input
|
|
function! coc#float#create_prompt_win(title, default) abort
|
|
call coc#float#close_auto_hide_wins()
|
|
noa let bufnr = nvim_create_buf(v:false, v:true)
|
|
call nvim_buf_set_lines(bufnr, 0, -1, v:false, [a:default])
|
|
call setbufvar(bufnr, '&bufhidden', 'wipe')
|
|
" Calculate col
|
|
let curr = win_screenpos(winnr())[1] + wincol() - 2
|
|
let width = min([max([strdisplaywidth(a:title) + 2, s:prompt_win_width]), &columns - 2])
|
|
if width == &columns - 2
|
|
let col = 0 - curr
|
|
else
|
|
let col = curr + width <= &columns - 2 ? 0 : &columns - s:prompt_win_width
|
|
endif
|
|
let config = {
|
|
\ 'relative': 'cursor',
|
|
\ 'width': width,
|
|
\ 'height': 1,
|
|
\ 'row': 0,
|
|
\ 'col': col,
|
|
\ 'style': 'minimal',
|
|
\ }
|
|
let winid = nvim_open_win(bufnr, 0, config)
|
|
if winid == 0
|
|
return []
|
|
endif
|
|
call setwinvar(winid, '&winhl', 'Normal:CocFloating,NormalNC:CocFloating')
|
|
let related = []
|
|
call coc#float#nvim_border_win(config, [1,1,1,1], a:title, related)
|
|
call setwinvar(winid, 'related', related)
|
|
call win_gotoid(winid)
|
|
inoremap <buffer> <C-a> <Home>
|
|
inoremap <buffer><expr><C-e> pumvisible() ? "\<C-e>" : "\<End>"
|
|
exe 'inoremap <silent><buffer> <esc> <C-r>=coc#float#close_i('.winid.')<CR><esc>'
|
|
exe 'nnoremap <silent><buffer> <esc> :call coc#float#close('.winid.')<CR>'
|
|
exe 'inoremap <expr><nowait><buffer> <cr> "\<c-r>=coc#float#prompt_insert('.winid.')\<cr>\<esc>"'
|
|
call feedkeys('A', 'in')
|
|
return [bufnr, winid]
|
|
endfunction
|
|
|
|
function! coc#float#close_i(winid) abort
|
|
call coc#float#close(a:winid)
|
|
return ''
|
|
endfunction
|
|
|
|
function! coc#float#prompt_insert(winid) abort
|
|
let text = getline('.')
|
|
let bufnr = winbufnr(a:winid)
|
|
call coc#rpc#notify('PromptInsert',[text, bufnr])
|
|
call timer_start(50, { -> coc#float#close(a:winid)})
|
|
return ''
|
|
endfunction
|
|
|
|
" Position of cursor relative to editor
|
|
function! s:win_position() abort
|
|
let nr = winnr()
|
|
let [row, col] = win_screenpos(nr)
|
|
return [row + winline() - 2, col + wincol() - 2]
|
|
endfunction
|
|
|
|
" get popup position for vim8 based on config of neovim float window
|
|
function! s:popup_position(config) abort
|
|
let relative = get(a:config, 'relative', 'editor')
|
|
if relative ==# 'cursor'
|
|
return [s:popup_cursor(a:config['row']), s:popup_cursor(a:config['col'])]
|
|
endif
|
|
return [a:config['row'] + 1, a:config['col'] + 1]
|
|
endfunction
|
|
|
|
function! s:popup_cursor(n) abort
|
|
if a:n == 0
|
|
return 'cursor'
|
|
endif
|
|
if a:n < 0
|
|
return 'cursor'.a:n
|
|
endif
|
|
return 'cursor+'.a:n
|
|
endfunction
|
|
|
|
" Close float window by id
|
|
function! coc#float#close(winid) abort
|
|
if !coc#float#valid(a:winid)
|
|
return 0
|
|
endif
|
|
if s:is_vim
|
|
call popup_close(a:winid)
|
|
return 1
|
|
else
|
|
call coc#float#nvim_close_related(a:winid)
|
|
call nvim_win_close(a:winid, 1)
|
|
return 1
|
|
endif
|
|
return 0
|
|
endfunction
|
|
|
|
" Float window id on current tab.
|
|
" return 0 if not found
|
|
function! coc#float#get_float_win() abort
|
|
if has('nvim')
|
|
for i in range(1, winnr('$'))
|
|
let id = win_getid(i)
|
|
let config = nvim_win_get_config(id)
|
|
if (!empty(config) && config['focusable'] == v:true && !empty(config['relative']))
|
|
if !getwinvar(id, 'button', 0)
|
|
return id
|
|
endif
|
|
endif
|
|
endfor
|
|
elseif exists('*popup_list')
|
|
let arr = filter(popup_list(), 'popup_getpos(v:val)["visible"]')
|
|
if !empty(arr)
|
|
return arr[0]
|
|
endif
|
|
endif
|
|
return 0
|
|
endfunction
|
|
|
|
function! coc#float#get_float_win_list() abort
|
|
if s:is_vim && exists('*popup_list')
|
|
return filter(popup_list(), 'popup_getpos(v:val)["visible"]')
|
|
elseif has('nvim') && exists('*nvim_win_get_config')
|
|
let res = []
|
|
for i in range(1, winnr('$'))
|
|
let id = win_getid(i)
|
|
let config = nvim_win_get_config(id)
|
|
" ignore border & button window
|
|
if (!empty(config) && config['focusable'] == v:true && !empty(config['relative']))
|
|
if !getwinvar(id, 'button', 0)
|
|
call add(res, id)
|
|
endif
|
|
endif
|
|
endfor
|
|
return res
|
|
endif
|
|
return []
|
|
endfunction
|
|
|
|
" Check if a float window is scrollable
|
|
function! coc#float#scrollable(winid) abort
|
|
let bufnr = winbufnr(a:winid)
|
|
if bufnr == -1
|
|
return 0
|
|
endif
|
|
if s:is_vim
|
|
let pos = popup_getpos(a:winid)
|
|
" scrollbar enabled
|
|
if get(popup_getoptions(a:winid), 'scrollbar', 0)
|
|
return get(pos, 'scrollbar', 0)
|
|
endif
|
|
let ch = coc#float#content_height(bufnr, pos['core_width'], getwinvar(a:winid, '&wrap'))
|
|
return ch > pos['core_height']
|
|
else
|
|
let height = nvim_win_get_height(a:winid)
|
|
let width = nvim_win_get_width(a:winid)
|
|
if width > 1 && getwinvar(a:winid, '&foldcolumn', 0)
|
|
" since we use foldcolumn for left pading
|
|
let width = width - 1
|
|
endif
|
|
let ch = coc#float#content_height(bufnr, width, getwinvar(a:winid, '&wrap'))
|
|
return ch > height
|
|
endif
|
|
endfunction
|
|
|
|
function! coc#float#has_scroll() abort
|
|
let win_ids = filter(coc#float#get_float_win_list(), 'coc#float#scrollable(v:val)')
|
|
return !empty(win_ids)
|
|
endfunction
|
|
|
|
function! coc#float#scroll(forward, ...)
|
|
if !has('nvim-0.4.3') && !has('patch-8.2.0750')
|
|
throw 'coc#float#scroll() requires nvim >= 0.4.3 or vim >= 8.2.0750'
|
|
endif
|
|
let amount = get(a:, 1, 0)
|
|
let win_ids = filter(coc#float#get_float_win_list(), 'coc#float#scrollable(v:val)')
|
|
if empty(win_ids)
|
|
return ''
|
|
endif
|
|
if has('nvim')
|
|
call timer_start(10, { -> s:scroll_nvim(win_ids, a:forward, amount)})
|
|
else
|
|
call timer_start(10, { -> s:scroll_vim(win_ids, a:forward, amount)})
|
|
endif
|
|
return mode() =~ '^i' ? "" : "\<Ignore>"
|
|
endfunction
|
|
|
|
function! s:scroll_nvim(win_ids, forward, amount) abort
|
|
let curr = win_getid()
|
|
for id in a:win_ids
|
|
if nvim_win_is_valid(id)
|
|
let wrapped = 0
|
|
let width = nvim_win_get_width(id)
|
|
if getwinvar(id, '&wrap', 0)
|
|
if width > 1 && getwinvar(id, '&foldcolumn', 0)
|
|
let width = width - 1
|
|
endif
|
|
for line in nvim_buf_get_lines(winbufnr(id), 0, -1, v:false)
|
|
if strdisplaywidth(line) > width
|
|
let wrapped = 1
|
|
break
|
|
endif
|
|
endfor
|
|
endif
|
|
noa call win_gotoid(id)
|
|
let height = nvim_win_get_height(id)
|
|
let firstline = line('w0')
|
|
let lastline = line('w$')
|
|
let linecount = line('$')
|
|
let delta = a:amount ? a:amount : max([1, height - 1])
|
|
if a:forward
|
|
if lastline == linecount && strdisplaywidth(line('$')) <= width
|
|
continue
|
|
endif
|
|
if !a:amount && firstline != lastline
|
|
execute 'noa normal! Lzt'
|
|
else
|
|
execute 'noa normal! H'.delta.'jzt'
|
|
endif
|
|
let lnum = line('.')
|
|
while lnum < linecount && line('w0') == firstline && line('w$') == lastline
|
|
execute 'noa normal! jzt'
|
|
let lnum = lnum + 1
|
|
endwhile
|
|
else
|
|
if !a:amount && firstline != lastline
|
|
execute 'noa normal! Hzb'
|
|
else
|
|
execute 'noa normal! L'.delta.'kzb'
|
|
endif
|
|
let lnum = line('.')
|
|
while lnum > 1 && line('w0') == firstline && line('w$') == lastline
|
|
execute 'noa normal! kzb'
|
|
let lnum = lnum - 1
|
|
endwhile
|
|
endif
|
|
call coc#float#nvim_scrollbar(id)
|
|
endif
|
|
endfor
|
|
noa call win_gotoid(curr)
|
|
redraw
|
|
endfunction
|
|
|
|
function! s:scroll_vim(win_ids, forward, amount) abort
|
|
for id in a:win_ids
|
|
if s:popup_visible(id)
|
|
let pos = popup_getpos(id)
|
|
let bufnr = winbufnr(id)
|
|
let linecount = get(getbufinfo(bufnr)[0], 'linecount', 0)
|
|
" for forward use last line (or last line + 1) as first line
|
|
if a:forward
|
|
if pos['firstline'] == pos['lastline']
|
|
call popup_setoptions(id, {'firstline': min([pos['firstline'] + 1, linecount])})
|
|
else
|
|
if pos['lastline'] == linecount
|
|
let win_width = pos['core_width']
|
|
let text = getbufline(bufnr, '$')[0]
|
|
if strdisplaywidth(text) <= win_width
|
|
" last line shown
|
|
return
|
|
endif
|
|
endif
|
|
let lnum = a:amount ? min([linecount, pos['firstline'] + a:amount]) : pos['lastline']
|
|
call popup_setoptions(id, {'firstline': lnum})
|
|
endif
|
|
else
|
|
if pos['firstline'] == 1
|
|
call win_execute(id, 'normal! gg0')
|
|
return
|
|
endif
|
|
" we could only change firstline
|
|
" iterate lines before last lines to fill content height - 1
|
|
let total_height = a:amount ? min([a:amount, pos['core_height']]) : pos['core_height'] - 1
|
|
if total_height == 0
|
|
call popup_setoptions(id, {'firstline': pos['firstline'] - 1})
|
|
else
|
|
let lines = getbufline(bufnr, 1, '$')
|
|
let curr = pos['firstline'] - 1
|
|
let width = pos['core_width']
|
|
let used = 0
|
|
while v:true
|
|
if curr == 1
|
|
break
|
|
endif
|
|
let w = max([1, strdisplaywidth(lines[curr - 1])])
|
|
let used += float2nr(ceil(str2float(string(w))/width))
|
|
if used > total_height
|
|
let curr = curr == pos['firstline'] -1 ? curr : curr + 1
|
|
break
|
|
elseif used == total_height
|
|
break
|
|
endif
|
|
let curr = curr - 1
|
|
endwhile
|
|
call popup_setoptions(id, {'firstline': curr})
|
|
endif
|
|
endif
|
|
endif
|
|
endfor
|
|
redraw
|
|
endfunction
|
|
|
|
function! s:popup_visible(id) abort
|
|
let pos = popup_getpos(a:id)
|
|
if !empty(pos) && get(pos, 'visible', 0)
|
|
return 1
|
|
endif
|
|
return 0
|
|
endfunction
|
|
|
|
function! s:convert_config_nvim(config) abort
|
|
let result = coc#helper#dict_omit(a:config, ['title', 'border', 'cursorline', 'autohide', 'close'])
|
|
let border = get(a:config, 'border', [])
|
|
if !s:empty_border(border)
|
|
if result['relative'] ==# 'cursor' && result['row'] < 0
|
|
" move top when has bottom border
|
|
if get(border, 2, 0)
|
|
let result['row'] = result['row'] - 1
|
|
endif
|
|
else
|
|
" move down when has top border
|
|
if get(border, 0, 0)
|
|
let result['row'] = result['row'] + 1
|
|
endif
|
|
endif
|
|
" move right when has left border
|
|
if get(border, 3, 0)
|
|
let result['col'] = result['col'] + 1
|
|
endif
|
|
let result['width'] = result['width'] + 1 - get(border,3, 0)
|
|
else
|
|
let result['width'] = result['width'] + 1
|
|
endif
|
|
return result
|
|
endfunction
|
|
|
|
" Close windows that could auto hide
|
|
function! coc#float#close_auto_hide_wins(...) abort
|
|
let winids = coc#float#get_float_win_list()
|
|
let except = get(a:, 1, 0)
|
|
for id in winids
|
|
if except && id == except
|
|
continue
|
|
endif
|
|
if getwinvar(id, 'autohide', 0)
|
|
call coc#float#close(id)
|
|
endif
|
|
endfor
|
|
endfunction
|
|
|
|
" neovim only
|
|
function! coc#float#nvim_close_btn(config, winid, close, border, related) abort
|
|
if !a:close
|
|
return
|
|
endif
|
|
let config = {
|
|
\ 'relative': a:config['relative'],
|
|
\ 'width': 1,
|
|
\ 'height': 1,
|
|
\ 'row': get(a:border, 0, 0) ? a:config['row'] - 1 : a:config['row'],
|
|
\ 'col': a:config['col'] + a:config['width'],
|
|
\ 'focusable': v:true,
|
|
\ 'style': 'minimal',
|
|
\ }
|
|
noa let bufnr = nvim_create_buf(v:false, v:true)
|
|
call setbufvar(bufnr, '&bufhidden', 'wipe')
|
|
call nvim_buf_set_lines(bufnr, 0, -1, v:false, ['X'])
|
|
let winid = nvim_open_win(bufnr, 0, config)
|
|
" map for winid & close_winid
|
|
if winid
|
|
call setwinvar(winid, 'button', 1)
|
|
call setwinvar(a:winid, 'close_winid', winid)
|
|
call setwinvar(winid, '&winhl', 'Normal:CocFloating,NormalNC:CocFloating')
|
|
call add(a:related, winid)
|
|
endif
|
|
endfunction
|
|
|
|
function! coc#float#nvim_check_close(winid) abort
|
|
let target = getwinvar(a:winid, 'target_winid', 0)
|
|
if target
|
|
call coc#float#close(target)
|
|
endif
|
|
endfunction
|
|
|
|
" Create padding window by config of current window & border config
|
|
function! coc#float#nvim_right_pad(config, border, related) abort
|
|
" Check right border
|
|
if !empty(a:border) && get(a:border, 1, 0)
|
|
return
|
|
endif
|
|
let config = {
|
|
\ 'relative': a:config['relative'],
|
|
\ 'width': 1,
|
|
\ 'height': a:config['height'],
|
|
\ 'row': a:config['row'],
|
|
\ 'col': a:config['col'] + a:config['width'],
|
|
\ 'focusable': v:false,
|
|
\ 'style': 'minimal',
|
|
\ }
|
|
noa let bufnr = nvim_create_buf(v:false, v:true)
|
|
call setbufvar(bufnr, '&bufhidden', 'wipe')
|
|
call nvim_buf_set_lines(bufnr, 0, -1, v:false, repeat([' '], a:config['height']))
|
|
let winid = nvim_open_win(bufnr, 0, config)
|
|
if winid
|
|
call setwinvar(winid, 'ispad', 1)
|
|
call setwinvar(winid, '&winhl', 'Normal:CocFloating,NormalNC:CocFloating')
|
|
call add(a:related, winid)
|
|
endif
|
|
endfunction
|
|
|
|
function! coc#float#content_height(bufnr, width, wrap) abort
|
|
if !bufloaded(a:bufnr)
|
|
return 0
|
|
endif
|
|
if !a:wrap
|
|
return has('nvim') ? nvim_buf_line_count(a:bufnr) : len(getbufline(a:bufnr, 1, '$'))
|
|
endif
|
|
let lines = has('nvim') ? nvim_buf_get_lines(a:bufnr, 0, -1, 0) : getbufline(a:bufnr, 1, '$')
|
|
let total = 0
|
|
for line in lines
|
|
let dw = max([1, strdisplaywidth(line)])
|
|
let total += float2nr(ceil(str2float(string(dw))/a:width))
|
|
endfor
|
|
return total
|
|
endfunction
|
|
|
|
function! s:add_related(winid, target) abort
|
|
let arr = getwinvar(a:target, 'related', [])
|
|
if index(arr, a:winid) >= 0
|
|
return
|
|
endif
|
|
call add(arr, a:winid)
|
|
call setwinvar(a:target, 'related', arr)
|
|
endfunction
|
|
|
|
function! coc#float#nvim_refresh_scrollbar() abort
|
|
let id = getwinvar(win_getid(), 'scrollbar', 0)
|
|
if coc#float#valid(id)
|
|
call coc#float#nvim_scrollbar(win_getid())
|
|
endif
|
|
endfunction
|
|
|
|
" Close related windows for neovim.
|
|
function! coc#float#nvim_close_related(winid) abort
|
|
if !has('nvim') || !a:winid
|
|
return
|
|
endif
|
|
let winids = getwinvar(a:winid, 'related', [])
|
|
if !empty(winids)
|
|
call nvim_win_del_var(a:winid, 'related')
|
|
endif
|
|
for id in winids
|
|
if nvim_win_is_valid(id) && id != a:winid
|
|
call nvim_win_close(id, 1)
|
|
endif
|
|
endfor
|
|
endfunction
|
|
|
|
function! coc#float#nvim_create_related(winid, config, opts) abort
|
|
let related = []
|
|
call coc#float#nvim_close_btn(a:config, a:winid, get(a:opts, 'close', 0), get(a:opts, 'border', []), related)
|
|
call coc#float#nvim_border_win(a:config, get(a:opts, 'border', []), get(a:opts, 'title', ''), related)
|
|
call coc#float#nvim_right_pad(a:config, get(a:opts, 'border', []), related)
|
|
for id in related
|
|
call setwinvar(id, 'target_winid', a:winid)
|
|
endfor
|
|
call setwinvar(a:winid, 'related', related)
|
|
endfunction
|
|
|
|
" Create scrollbar for winid
|
|
" Need called on create, config, buffer change, scrolled
|
|
function! coc#float#nvim_scrollbar(winid) abort
|
|
if !has('nvim-0.4.3')
|
|
return
|
|
endif
|
|
if a:winid == 0 || !nvim_win_is_valid(a:winid) || getwinvar(a:winid, 'button', 0)
|
|
return
|
|
endif
|
|
let config = nvim_win_get_config(a:winid)
|
|
" ignore border & button window
|
|
if (!get(config, 'focusable', v:false) || empty(get(config, 'relative', '')))
|
|
return
|
|
endif
|
|
let [row, column] = nvim_win_get_position(a:winid)
|
|
let width = nvim_win_get_width(a:winid)
|
|
let height = nvim_win_get_height(a:winid)
|
|
let bufnr = winbufnr(a:winid)
|
|
let cw = getwinvar(a:winid, '&foldcolumn', 0) ? width - 1 : width
|
|
let ch = coc#float#content_height(bufnr, cw, getwinvar(a:winid, '&wrap'))
|
|
let close_winid = getwinvar(a:winid, 'close_winid', 0)
|
|
let border = getwinvar(a:winid, 'border', [])
|
|
let move_down = close_winid && !get(border, 0, 0)
|
|
if move_down
|
|
let height = height - 1
|
|
if height == 0
|
|
return
|
|
endif
|
|
endif
|
|
let id = 0
|
|
if nvim_win_is_valid(getwinvar(a:winid, 'scrollbar', 0))
|
|
let id = getwinvar(a:winid, 'scrollbar', 0)
|
|
endif
|
|
if ch <= height || height == 0
|
|
" no scrollbar, remove exists
|
|
if id
|
|
call nvim_win_del_var(a:winid, 'scrollbar')
|
|
call coc#float#close(id)
|
|
endif
|
|
return
|
|
endif
|
|
if height == 0
|
|
return
|
|
endif
|
|
if id && bufloaded(winbufnr(id))
|
|
let sbuf = winbufnr(id)
|
|
else
|
|
noa let sbuf = nvim_create_buf(v:false, v:true)
|
|
call setbufvar(sbuf, '&bufhidden', 'wipe')
|
|
endif
|
|
call nvim_buf_set_lines(sbuf, 0, -1, v:false, repeat([' '], height))
|
|
let opts = {
|
|
\ 'row': move_down ? row + 1 : row,
|
|
\ 'col': column + width,
|
|
\ 'relative': 'editor',
|
|
\ 'width': 1,
|
|
\ 'height': height,
|
|
\ 'focusable': v:false,
|
|
\ 'style': 'minimal',
|
|
\ }
|
|
if id
|
|
call nvim_win_set_config(id, opts)
|
|
else
|
|
let id = nvim_open_win(sbuf, 0 , opts)
|
|
call setwinvar(id, 'isscrollbar', 1)
|
|
call setwinvar(id, 'target_winid', a:winid)
|
|
endif
|
|
let thumb_height = max([1, float2nr(floor(height * (height + 0.0)/ch))])
|
|
let curr = win_getid()
|
|
if curr != a:winid
|
|
noa call win_gotoid(a:winid)
|
|
endif
|
|
let firstline = line('w0')
|
|
let lastline = line('w$')
|
|
let linecount = line('$')
|
|
if firstline == 1
|
|
let start = 0
|
|
elseif lastline == linecount
|
|
let start = height - thumb_height
|
|
else
|
|
let start = max([1, float2nr(round((height - thumb_height + 0.0)*(firstline - 1.0)/(ch - height)))])
|
|
endif
|
|
if curr != a:winid
|
|
noa call win_gotoid(curr)
|
|
endif
|
|
" add highlights
|
|
call nvim_buf_clear_namespace(sbuf, s:scrollbar_ns, 0, -1)
|
|
for idx in range(0, height - 1)
|
|
if idx >= start && idx < start + thumb_height
|
|
call nvim_buf_add_highlight(sbuf, s:scrollbar_ns, 'PmenuThumb', idx, 0, 1)
|
|
else
|
|
call nvim_buf_add_highlight(sbuf, s:scrollbar_ns, 'PmenuSbar', idx, 0, 1)
|
|
endif
|
|
endfor
|
|
" create scrollbar outside window
|
|
call setwinvar(a:winid, 'scrollbar', id)
|
|
call s:add_related(id, a:winid)
|
|
endfunction
|
|
|
|
function! coc#float#nvim_check_related() abort
|
|
if !has('nvim')
|
|
return
|
|
endif
|
|
let invalids = []
|
|
for i in range(1, winnr('$'))
|
|
let id = win_getid(i)
|
|
let target = getwinvar(id, 'target_winid', 0)
|
|
if target && !nvim_win_is_valid(target)
|
|
call add(invalids, id)
|
|
endif
|
|
endfor
|
|
for id in invalids
|
|
noa call nvim_win_close(id, 1)
|
|
endfor
|
|
endfunction
|
|
|
|
" Dimension of window with lines relative to cursor
|
|
" Width & height excludes border & padding
|
|
function! coc#float#get_config_cursor(lines, config) abort
|
|
let preferTop = get(a:config, 'preferTop', 0)
|
|
let title = get(a:config, 'title', '')
|
|
let border = get(a:config, 'border', [0, 0, 0, 0])
|
|
if s:empty_border(border) && len(title)
|
|
let border = [1, 1, 1, 1]
|
|
endif
|
|
let bh = get(border, 0, 0) + get(border, 2, 0)
|
|
let vh = &lines - &cmdheight - 1
|
|
if vh <= 0
|
|
return v:null
|
|
endif
|
|
let maxWidth = min([get(a:config, 'maxWidth', 80), &columns - 1])
|
|
if maxWidth < 3
|
|
return v:null
|
|
endif
|
|
let maxHeight = min([get(a:config, 'maxHeight', 80), vh])
|
|
let ch = 0
|
|
let width = min([40, strdisplaywidth(title)]) + 3
|
|
for line in a:lines
|
|
let dw = max([1, strdisplaywidth(line)])
|
|
let width = max([width, dw + 2])
|
|
let ch += float2nr(ceil(str2float(string(dw))/(maxWidth - 2)))
|
|
endfor
|
|
let width = min([maxWidth, width])
|
|
let [lineIdx, colIdx] = s:win_position()
|
|
" How much we should move left
|
|
let offsetX = min([get(a:config, 'offsetX', 0), colIdx])
|
|
let showTop = 0
|
|
let hb = vh - lineIdx -1
|
|
if lineIdx > bh + 2 && (preferTop || (lineIdx > hb && hb < ch + bh))
|
|
let showTop = 1
|
|
endif
|
|
let height = min([maxHeight, ch + bh, showTop ? lineIdx - 1 : hb])
|
|
if height <= bh
|
|
return v:null
|
|
endif
|
|
let col = - max([offsetX, colIdx - (&columns - 1 - width)])
|
|
let row = showTop ? - height : 1
|
|
return {
|
|
\ 'row': row,
|
|
\ 'col': col,
|
|
\ 'width': width - 2,
|
|
\ 'height': height - bh
|
|
\ }
|
|
endfunction
|
|
|
|
function! coc#float#get_config_pum(lines, pumconfig, maxwidth) abort
|
|
if !pumvisible()
|
|
return v:null
|
|
endif
|
|
let pw = a:pumconfig['width'] + get(a:pumconfig, 'scrollbar', 0)
|
|
let rp = &columns - a:pumconfig['col'] - pw
|
|
let showRight = a:pumconfig['col'] > rp ? 0 : 1
|
|
let maxWidth = showRight ? min([rp - 1, a:maxwidth]) : min([a:pumconfig['col'] - 1, a:maxwidth])
|
|
let maxHeight = &lines - a:pumconfig['row'] - &cmdheight - 1
|
|
if maxWidth <= 2 || maxHeight < 1
|
|
return v:null
|
|
endif
|
|
let ch = 0
|
|
let width = 0
|
|
for line in a:lines
|
|
let dw = max([1, strdisplaywidth(line)])
|
|
let width = max([width, dw + 2])
|
|
let ch += float2nr(ceil(str2float(string(dw))/(maxWidth - 2)))
|
|
endfor
|
|
let width = min([maxWidth, width])
|
|
let height = min([maxHeight, ch])
|
|
return {
|
|
\ 'col': showRight ? a:pumconfig['col'] + pw : a:pumconfig['col'] - width - 1,
|
|
\ 'row': a:pumconfig['row'],
|
|
\ 'height': height,
|
|
\ 'width': width - 2 + (s:is_vim && ch > height ? -1 : 0),
|
|
\ 'relative': 'editor'
|
|
\ }
|
|
endfunction
|
|
|
|
function! s:empty_border(border) abort
|
|
if empty(a:border)
|
|
return 1
|
|
endif
|
|
if a:border[0] == 0 && a:border[1] == 0 && a:border[2] == 0 && a:border[3] == 0
|
|
return 1
|
|
endif
|
|
return 0
|
|
endfunction
|