41bcd3e04b
- Stop caching width and height of the preview window which prevented the size to be adjusted after the nvim window's resize. - Add config options for height to match width options. - Mention height config options in readme and vimdoc (previously missing).
344 lines
9.5 KiB
Lua
344 lines
9.5 KiB
Lua
local cfg = require('outline.config')
|
|
|
|
-- A floating window to preview the location of a symbol from the outline.
|
|
-- Classical preview reads entire lines into a new buffer for preview. Live
|
|
-- preview sets the buffer of floating window to the code buffer, which allows
|
|
-- focusing by pressing the preview keymap again, to edit the buffer at that
|
|
-- position.
|
|
|
|
---@class outline.Preview
|
|
local Preview = {}
|
|
|
|
---@class outline.Preview
|
|
---@field buf integer
|
|
---@field win integer
|
|
---@field height integer
|
|
---@field width integer
|
|
---@field outline_height integer
|
|
---@field s outline.Sidebar
|
|
---@field conf table
|
|
---@field size_augroup integer
|
|
|
|
---@class outline.LivePreview
|
|
local LivePreview = {}
|
|
|
|
---@class outline.LivePreview
|
|
---@field win integer
|
|
---@field codewin integer
|
|
---@field codebuf integer
|
|
---@field height integer
|
|
---@field width integer
|
|
---@field outline_height integer
|
|
---@field s outline.Sidebar
|
|
---@field last_node outline.FlatSymbol
|
|
---@field initial_cursorline boolean
|
|
---@field conf table
|
|
---@field size_augroup integer
|
|
|
|
---@param conf table
|
|
function Preview:new(conf)
|
|
if conf.live == true then
|
|
return setmetatable({
|
|
conf = conf,
|
|
win = nil,
|
|
width = nil,
|
|
height = nil,
|
|
}, { __index = LivePreview })
|
|
else
|
|
return setmetatable({
|
|
conf = conf,
|
|
buf = nil,
|
|
win = nil,
|
|
width = nil,
|
|
height = nil,
|
|
}, { __index = Preview })
|
|
end
|
|
end
|
|
|
|
---Get the correct column to place the floating window based on relative
|
|
---positions of the outline and the code window.
|
|
---@param self outline.Preview|outline.LivePreview
|
|
local function calc_col(self)
|
|
-- TODO: Re-calculate dimensions on update-preview, in case outline window
|
|
-- was resized between last preview and next preview?
|
|
---@type integer
|
|
local outline_winnr = self.s.view.win
|
|
local outline_col = vim.api.nvim_win_get_position(outline_winnr)[2]
|
|
local outline_width = vim.api.nvim_win_get_width(outline_winnr)
|
|
local code_col = vim.api.nvim_win_get_position(self.s.code.win)[2]
|
|
|
|
-- TODO: What if code win is below/above outline instead?
|
|
|
|
local col = outline_col
|
|
if outline_col > code_col then
|
|
col = col - self.width - 3
|
|
else
|
|
col = col + outline_width + 1
|
|
end
|
|
|
|
return col
|
|
end
|
|
|
|
---Get the vertically center-aligned row for preview window
|
|
---@param self outline.Preview|outline.LivePreview
|
|
local function calc_row(self)
|
|
local offset = math.floor((self.outline_height - self.height) / 2) - 1
|
|
return vim.api.nvim_win_get_position(self.s.view.win)[1] + offset
|
|
end
|
|
|
|
---@param self outline.Preview|outline.LivePreview
|
|
local function update_size(self)
|
|
if self.size_augroup and (not self.win or not vim.api.nvim_win_is_valid(self.win)) then
|
|
vim.api.nvim_del_augroup_by_id(self.size_augroup)
|
|
self.win = nil
|
|
self.buf = nil
|
|
self.size_augroup = nil
|
|
return
|
|
end
|
|
|
|
self.outline_height = vim.api.nvim_win_get_height(self.s.view.win)
|
|
self.width = cfg.get_preview_width(self.conf)
|
|
self.height = cfg.get_preview_height(self.conf, self.outline_height)
|
|
local row = calc_row(self)
|
|
local col = calc_col(self)
|
|
vim.api.nvim_win_set_config(self.win, {
|
|
height = self.height,
|
|
width = self.width,
|
|
row = row,
|
|
col = col,
|
|
relative = 'editor',
|
|
})
|
|
end
|
|
|
|
function Preview:create()
|
|
self.buf = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_attach(self.buf, false, {
|
|
on_detach = function()
|
|
self.buf = nil
|
|
self.win = nil
|
|
end,
|
|
})
|
|
self.outline_height = vim.api.nvim_win_get_height(self.s.view.win)
|
|
self.width = cfg.get_preview_width(self.conf)
|
|
self.height = cfg.get_preview_height(self.conf, self.outline_height)
|
|
self.win = vim.api.nvim_open_win(self.buf, false, {
|
|
relative = 'editor',
|
|
height = self.height,
|
|
width = self.width,
|
|
bufpos = { 0, 0 },
|
|
col = calc_col(self),
|
|
row = calc_row(self),
|
|
border = self.conf.border,
|
|
focusable = false,
|
|
})
|
|
self:setup()
|
|
self:update()
|
|
|
|
if self.conf.auto_preview then
|
|
self.size_augroup = vim.api.nvim_create_augroup('outline_' .. self.s.id .. '_preview_size', {
|
|
clear = true,
|
|
})
|
|
vim.api.nvim_create_autocmd('WinResized', {
|
|
-- XXX: Using view.win doesn't work here?
|
|
pattern = tostring(self.s.code.win),
|
|
group = self.size_augroup,
|
|
callback = function()
|
|
update_size(self)
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
---Set buf & win options, and setup highlight
|
|
function Preview:setup()
|
|
vim.api.nvim_win_set_option(self.win, 'winhl', self.conf.winhl)
|
|
vim.api.nvim_win_set_option(self.win, 'winblend', self.conf.winblend)
|
|
|
|
local code_buf = self.s.code.buf
|
|
local ft = vim.api.nvim_buf_get_option(code_buf, 'filetype')
|
|
vim.api.nvim_buf_set_option(self.buf, 'syntax', ft)
|
|
|
|
local ts_highlight_fn = vim.treesitter.start
|
|
if not _G._outline_nvim_has[8] then
|
|
local ok, ts_highlight = pcall(require, 'nvim-treesitter.highlight')
|
|
if ok then
|
|
ts_highlight_fn = ts_highlight.attach
|
|
end
|
|
end
|
|
pcall(ts_highlight_fn, self.buf, ft)
|
|
|
|
vim.api.nvim_buf_set_option(self.buf, 'bufhidden', 'delete')
|
|
vim.api.nvim_buf_set_option(self.buf, 'modifiable', false)
|
|
vim.api.nvim_win_set_option(self.win, 'cursorline', true)
|
|
end
|
|
|
|
function Preview:update()
|
|
local node = self.s:_current_node()
|
|
if not node then
|
|
return
|
|
end
|
|
local lines = vim.api.nvim_buf_get_lines(self.s.code.buf, 0, -1, false)
|
|
|
|
if self.buf ~= nil then
|
|
vim.api.nvim_buf_set_option(self.buf, 'modifiable', true)
|
|
vim.api.nvim_buf_set_lines(self.buf, 0, -1, false, lines)
|
|
vim.api.nvim_buf_set_option(self.buf, 'modifiable', false)
|
|
vim.api.nvim_win_set_cursor(self.win, { node.line + 1, node.character })
|
|
end
|
|
end
|
|
|
|
---Create or update preview
|
|
function Preview:show()
|
|
if not self.s:has_focus() or #vim.api.nvim_list_wins() < 2 then
|
|
return
|
|
end
|
|
|
|
if not vim.api.nvim_win_is_valid(self.s.code.win) or not self.s.provider then
|
|
return
|
|
end
|
|
|
|
if not self.buf or not self.win then
|
|
self:create()
|
|
else
|
|
self:update()
|
|
end
|
|
end
|
|
|
|
function Preview:close()
|
|
if self.win ~= nil and vim.api.nvim_win_is_valid(self.win) then
|
|
vim.api.nvim_win_close(self.win, true)
|
|
end
|
|
end
|
|
|
|
function Preview:toggle()
|
|
if self.win ~= nil then
|
|
self:close()
|
|
else
|
|
self:show()
|
|
end
|
|
end
|
|
|
|
---Creates new preview window and sets the content. Calls setup and set_lines.
|
|
function LivePreview:create()
|
|
self.codewin = self.s.code.win
|
|
self.initial_cursorline = vim.api.nvim_win_get_option(self.s.code.win, 'cursorline')
|
|
self.outline_height = vim.api.nvim_win_get_height(self.s.view.win)
|
|
self.width = cfg.get_preview_width(self.conf)
|
|
self.height = cfg.get_preview_height(self.conf, self.outline_height)
|
|
self.win = vim.api.nvim_open_win(self.s.code.buf, false, {
|
|
relative = 'editor',
|
|
height = self.height,
|
|
width = self.width,
|
|
bufpos = { 0, 0 },
|
|
col = calc_col(self),
|
|
row = calc_row(self),
|
|
border = self.conf.border,
|
|
-- Setting this to disallow using other methods to focus on this window,
|
|
-- because currently the autocmds from setup() isn't triggering if user did
|
|
-- not use close() and focus().
|
|
focusable = false,
|
|
})
|
|
self:setup()
|
|
if self.conf.auto_preview then
|
|
self.size_augroup = vim.api.nvim_create_augroup('outline_' .. self.s.id .. '_preview_size', {
|
|
clear = true,
|
|
})
|
|
vim.api.nvim_create_autocmd('WinResized', {
|
|
-- XXX: Using view.win doesn't work here?
|
|
pattern = tostring(self.s.code.win),
|
|
group = self.size_augroup,
|
|
callback = function()
|
|
update_size(self)
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
---Set buf & win options, and autocmds
|
|
function LivePreview:setup()
|
|
vim.api.nvim_win_set_option(self.win, 'winhl', self.conf.winhl)
|
|
vim.api.nvim_win_set_option(self.win, 'winblend', self.conf.winblend)
|
|
vim.api.nvim_win_set_option(self.win, 'cursorline', true)
|
|
|
|
vim.api.nvim_create_autocmd('WinClosed', {
|
|
pattern = tostring(self.win),
|
|
once = true,
|
|
callback = function()
|
|
self.s.code.win = self.codewin
|
|
self.win = nil
|
|
end,
|
|
})
|
|
vim.api.nvim_create_autocmd('WinEnter', {
|
|
pattern = tostring(self.win),
|
|
once = true,
|
|
callback = function()
|
|
-- This doesn't work at all?
|
|
vim.api.nvim_win_set_option(self.win, 'cursorline', self.initial_cursorline)
|
|
end,
|
|
})
|
|
end
|
|
|
|
function LivePreview:update(node)
|
|
vim.api.nvim_win_set_buf(self.win, self.s.code.buf)
|
|
vim.api.nvim_win_set_cursor(self.win, { node.line + 1, node.character })
|
|
end
|
|
|
|
function LivePreview:focus()
|
|
vim.api.nvim_set_current_win(self.win)
|
|
-- Remove this when the autocmd for WinEnter works above
|
|
vim.api.nvim_win_set_option(self.win, 'cursorline', self.initial_cursorline)
|
|
end
|
|
|
|
---Create, focus, or update preview
|
|
function LivePreview:show()
|
|
if not self.s:has_focus() or #vim.api.nvim_list_wins() < 2 then
|
|
return
|
|
end
|
|
|
|
if
|
|
not vim.api.nvim_win_is_valid(self.s.code.win)
|
|
or (self.codewin and not vim.api.nvim_win_is_valid(self.codewin))
|
|
or not self.s.provider
|
|
then
|
|
return
|
|
end
|
|
|
|
local node = self.s:_current_node()
|
|
if not node then
|
|
return
|
|
end
|
|
|
|
if not self.win then
|
|
self:create()
|
|
vim.api.nvim_win_set_cursor(self.win, { node.line + 1, node.character })
|
|
self.last_node = node
|
|
return
|
|
end
|
|
|
|
if node == self.last_node and not self.conf.auto_preview then
|
|
-- Focus is called manually through keybinding from sidebar.lua. This
|
|
-- should only be used on second toggle_preview call in the case of no
|
|
-- auto-preview.
|
|
self:focus()
|
|
else
|
|
self:update(node)
|
|
end
|
|
|
|
self.last_node = node
|
|
end
|
|
|
|
function LivePreview:close()
|
|
if self.win ~= nil then
|
|
vim.api.nvim_win_close(self.win, true)
|
|
-- autocmd from setup is not triggered here?
|
|
self.win = nil
|
|
self.s.code.win = self.codewin
|
|
end
|
|
end
|
|
|
|
function LivePreview:toggle()
|
|
self:show()
|
|
end
|
|
|
|
return Preview
|