[mini.files] traverse three styles: Left, center and right

[abeldekat]

mini_files_layouts.mp4

The new module, mini.input, allows the user to traverse the various styles of the view. It is mentioned in the 'Miscellaneous' section of :h MiniInput.default_key().

This is my attempt to have something similar in mini.files. The styles are "L", "C" and "R".
It's mostly for fun, but could be practical when an important piece of text is hidden by the explorer.

I admire the "custom side-scrolling layout" introduced in this discussion. That layout is, with some changes, included as style "C". Thanks @edisj for a great idea!

Since this commit, the implementation of the "custom side-scrolling layout" can be approached a bit differently. Now, when a MiniFilesWindowUpdate fires, all windows have already been processed:

• It's a bit easier to find the focused window. No need for vim.api.nvim_buf_get_name(ev.data.buf_id):match('^minifiles://%d+/(.*)$').
• Instead of working with "depth offset", it's possible to calculate the position of each col in one pass.

@echasnovski, would you accept a PR adding an extra MiniFilesExplorerUpdate event? Its data could contain the index of the focused window in state.windows. Its purpose is similar to MiniFilesWindowUpdate, but it only fires once instead of per window.

One downside of the centered layout is it being more difficult to determine that all files in a directory are shown. Perhaps it would be nice to have a footer showing a symbol when that is not the case.

The code:

files.lua

---@diagnostic disable: undefined-global
-- Left and right border to take into account
local x_margin = 2
-- Layout
local layout_current, layout_next = 'C', { L = 'C', C = 'R', R = 'L' }
-- Center vertically
local vert = { enable = true, height_focus = 22, height = 20, threshold = 6 }

-- Copied from mini.files to change first visible title when expected first window is hidden
local is_windows = vim.loop.os_uname().sysname == 'Windows_NT'
local fs_normalize_path = function(path) return (path:gsub('/+', '/'):gsub('(.)/$', '%1')) end
if is_windows then
  fs_normalize_path = function(path)
    return (path:gsub('\\', '/'):gsub('([^/:])/+', '%1/'):gsub('([^:])/+$', '%1'):gsub('^(%a):/+([^/])', '%1://%2'))
  end
end
local fit_to_width = function(text, width)
  local t_width = vim.fn.strchars(text)
  return t_width <= width and text or ('…' .. vim.fn.strcharpart(text, t_width - width + 1, width - 1))
end
local sanitize_string = function(x) return ((x or ''):gsub('\n', '<NL>'):gsub('%z', '')) end
local fs_shorten_path = function(path)
  path = fs_normalize_path(path)
  local home_dir = fs_normalize_path(vim.loop.os_homedir() or '~')
  return (path:gsub('^' .. vim.pesc(home_dir), '~'))
end
-- End copied from mini.files

local add_buffer_mappings = function(args)
  local traverse_layout = function()
    layout_current = layout_next[layout_current]
    MiniFiles.refresh()
  end
  vim.keymap.set('n', '<C-s>', traverse_layout, { buffer = args.data.buf_id, desc = 'Traverse layout' })
end

local center_update_first_visible_title = function(windows, idx)
  local win = windows[idx]
  local config = vim.api.nvim_win_get_config(win.win_id)
  if not type(config.title) == string then return end

  config.title = ' ' .. sanitize_string(fs_shorten_path(win.path)) .. ' '
  config.title = fit_to_width(config.title, config.width)
  vim.api.nvim_win_set_config(win.win_id, config)
end

local center_set_config = function(config, win_id, show, is_focused, vert_enable)
  if vert_enable then
    config.height = is_focused and vert.height_focus or vert.height
    config.row = math.floor(0.5 * (vim.o.lines - config.height))
  end
  config.height = not show and 1 or config.height

  local line_count = vim.api.nvim_buf_line_count(vim.api.nvim_win_get_buf(win_id))
  local footer = ''
  if line_count > config.height then
    footer = string.format(' %d/%d ', vim.api.nvim_win_get_cursor(win_id)[1], line_count)
  end
  config.footer = { { footer, 'MiniFilesTitle' } }
  config.footer_pos = 'right'
  
  vim.api.nvim_win_set_config(win_id, config)
end

local get_win_data = function(windows, idx)
  local win_id = windows[idx].win_id
  local config = vim.api.nvim_win_get_config(win_id)
  return win_id, config, config.width + x_margin
end

local center = function(windows, idx_focused)
  local is_vert = vert.enable and (vim.o.lines - vert.height_focus >= vert.threshold)
  local _, _, width_focused = get_win_data(windows, idx_focused)
  if vim.o.columns <= width_focused then return end

  local col_focused = math.floor((vim.o.columns - width_focused) * 0.5)
  -- From focused to left edge
  local hidden = {}
  local col = col_focused + width_focused
  for i = idx_focused, 1, -1 do
    local win_id, config, width = get_win_data(windows, i)
    local show = i == idx_focused or col >= width

    config.col = show and col - width or col_focused
    center_set_config(config, win_id, show, i == idx_focused, is_vert)
    if not show then table.insert(hidden, i) end
    col = show and config.col or 0
  end
  if #hidden > 0 then center_update_first_visible_title(windows, hidden[1] + 1) end

  -- From focused + 1 to right edge
  col = col_focused + width_focused
  for i = idx_focused + 1, #windows do
    local win_id, config, width = get_win_data(windows, i)
    local show = (vim.o.columns - col) >= width

    config.col = show and col or col_focused
    center_set_config(config, win_id, show, false, is_vert)
    col = show and config.col + width or vim.o.columns
  end
end

local right = function(windows, _)
  -- In the default layout, the first window is aligned to the left edge of the editor
  -- Here, the last window is aligned to the right edge of the editor
  local config_last_window = vim.api.nvim_win_get_config(windows[#windows].win_id)
  local offset = (vim.o.columns - config_last_window.col) - config_last_window.width - x_margin
  for _, win in ipairs(windows) do
    local win_id = win.win_id
    local config = vim.api.nvim_win_get_config(win_id)
    config.col = offset + config.col
    vim.api.nvim_win_set_config(win_id, config)
  end
end

local ensure_layout = function(args)
  if layout_current == 'L' then return end

  local state = MiniFiles.get_explorer_state()
  if state == nil then return end

  -- Return when event is not for focused window
  local focused_path = state.branch[state.depth_focus]
  local idx_focused
  for i, win in ipairs(state.windows) do
    if win.path == focused_path and win.win_id == args.data.win_id then idx_focused = i end
  end
  if idx_focused == nil then return end

  local layout_fn = layout_current == 'C' and center or right
  layout_fn(state.windows, idx_focused)
end

require('mini.files').setup({ windows = { preview = true } })

local gr = vim.api.nvim_create_augroup('custom-config', {})
local new_autocmd = function(event, pattern, callback, desc)
  local opts = { group = gr, pattern = pattern, callback = callback, desc = desc }
  vim.api.nvim_create_autocmd(event, opts)
end
new_autocmd('User', 'MiniFilesBufferCreate', add_buffer_mappings, 'Add buffer mappings')
new_autocmd('User', 'MiniFilesWindowUpdate', ensure_layout, 'Ensure layout')

A suggestion of the "center" layout when added to mini.files itself:

mini.files.lua

-- Renamed H.compute_visible_depth_range(explorer, explorer.opts):
H.compute_visible = function(explorer, opts)
-- Some trivial changes...
end

-- New function to center:
H.compute_visible_centered = function(explorer, opts)
  -- Compute maximum number of windows possible to fit in current Neovim width
  -- Add 2 to widths to take into account width of left and right borders
  local x_margin = 2
  local width_focus, width_nofocus = opts.windows.width_focus + x_margin, opts.windows.width_nofocus + x_margin
  local depth_focus, branch_depth, branch = explorer.depth_focus, #explorer.branch, explorer.branch
  local res = { from = depth_focus, to = depth_focus, x_initial_offset = 0, x_margin = x_margin }

  if vim.o.columns <= width_focus then return res end

  local pos_focus = math.floor((vim.o.columns - width_focus) * 0.5)
  res.x_initial_offset = pos_focus

  for i = depth_focus - 1, 1, -1 do
    if not (branch[i] and res.x_initial_offset >= width_nofocus) then break end
    res.from = res.from - 1
    res.x_initial_offset = res.x_initial_offset - width_nofocus
  end

  local has_preview = explorer.opts.windows.preview and depth_focus < branch_depth
  local width_preview = opts.windows.width_preview + x_margin
  local right_remaining = vim.o.columns - (pos_focus + width_focus)

  for i = depth_focus + 1, branch_depth do
    local width = has_preview and i == depth_focus + 1 and width_preview or width_nofocus

    if not (branch[i] and right_remaining >= width) then break end
    res.to = res.to + 1
    right_remaining = right_remaining - width
  end

  return res
end

-- Added: x_margin to support layouts
H.explorer_refresh = function(explorer, opts)

    -- Existing code....

    -- Compute depth range which is possible to show in current Neovim width
    local to_show = explorer.opts.windows.style == 'C' and H.compute_visible_centered(explorer, explorer.opts)
    or H.compute_visible(explorer, explorer.opts)

    -- Refresh window for every target depth keeping track of position column
    local cur_win_col, cur_win_count, opened_windows = to_show.x_initial_offset, 0, {}
    for depth = to_show.from, to_show.to do
        cur_win_count = cur_win_count + 1
        local cur_width, was_opened = H.explorer_refresh_depth_window(explorer, depth, cur_win_count, cur_win_col)
        opened_windows[explorer.windows[cur_win_count]] = was_opened

        -- Add x_margin to account for left and right borders
        cur_win_col = cur_win_col + cur_width + to_show.x_margin
    end

    -- More existing code....
end

[echasnovski]

@echasnovski, would you accept a PR adding an extra MiniFilesExplorerUpdate event? Its data could contain the index of the focused window in state.windows. Its purpose is similar to MiniFilesWindowUpdate, but it only fires once instead of per window.

I don't immediately like the idea of this type of event. Probably mostly because it leads to a duplication of events (if always essentially triggered after the last MiniFilesWindowUpdate). Also because there are plans to make the whole layout management more first class (like with MiniFiles.config.layout function).

So it is not a "no", but "I don't think I like this at the moment".

[abeldekat]

I updated the code a little bit.

If a window cannot be shown, I am using the col of the focused window, setting the height to 1. As such, I do not need to also set a zindex.

If a window cannot show all content, I am adding a footer displaying the number of lines in the buffer:

  -- Added to center_set_config:

  local line_count = vim.api.nvim_buf_line_count(vim.api.nvim_win_get_buf(win_id))
  local footer = ''
  if line_count > config.height then
    footer = string.format(' %d/%d ', vim.api.nvim_win_get_cursor(win_id)[1], line_count)
  end
  config.footer = { { footer, 'MiniFilesTitle' } }
  config.footer_pos = 'right'

[edisj]

this is a neat idea... I wouldn't use a "L" or "R" style, but it got me thinking what about a "F" (fullscreen) toggle, where the open explorer windows fill up the whole view? It would be useful when opening mini.files as a netrw replacement

[abeldekat]

Interesting!

[abeldekat]

On MiniFilesWindowUpdate, we know for sure that all state.windows 'fit' from left to right given their default widths. The algorithm would only need to increase each window by a certain factor, and maximize the height.

[abeldekat]

mini_files_full_screen.mp4

MiniFiles with full-screen toggle. Also uses full screen when neovim is started with a directory.

I "stubbed" the C and R layouts to fallback to L, in order to focus on the full-screen code.

What do you think? Currently, the widths are equalized. The focused window could be more prominent.

The code

---@diagnostic disable: undefined-global
local layout_current, layout_next = 'L', { L = 'R', R = 'L' }
local is_full_screen = false
local full_screen_max_number = 3 -- math.huge

-- Left and right border to take into account. Col position vs inner width
local x_margin = 2

-- Copied from mini.files to support full screen
local window_get_max_height = function()
  local has_tabline = vim.o.showtabline == 2 or (vim.o.showtabline == 1 and #vim.api.nvim_list_tabpages() > 1)
  local has_statusline = vim.o.laststatus > 0
  -- Remove 2 from maximum height to account for top and bottom borders
  return vim.o.lines - vim.o.cmdheight - (has_tabline and 1 or 0) - (has_statusline and 1 or 0) - 2
end
-- End copied from mini.files

local get_win_data = function(windows, idx)
  local win_id = windows[idx].win_id
  local config = vim.api.nvim_win_get_config(win_id)
  return win_id, config, config.width + x_margin
end

local center = function(windows, idx_focused)
  -- Dummy for full screen demo. Fall back to 'L'
end
local right = function(windows, _) -- idx_focused
  -- Dummy for full screen demo. Fall back to 'L'
end

local full_screen = function(windows, _)
  local nr_of_windows = #windows
  -- All windows have max_height
  local height = window_get_max_height()
  -- All windows have (almost) the same width
  local col_distance = math.floor(vim.o.columns / nr_of_windows)

  local col = 0
  for i = 1, nr_of_windows do
    local win_id, config, _ = get_win_data(windows, i)
    -- Set the col to the new position
    col = (i == 1 and config.col) or (col + col_distance)

    config.col, config.height = col, height
    -- Set the width, and ensure there is no gap after last window
    config.width = (i == nr_of_windows and (vim.o.columns - col) or col_distance) - x_margin
    vim.api.nvim_win_set_config(win_id, config)
  end
end

require('mini.files').setup({ windows = { preview = true } })

local gr = vim.api.nvim_create_augroup('custom-config', {})
local new_autocmd = function(event, pattern, callback, desc)
  local opts = { group = gr, pattern = pattern, callback = callback, desc = desc }
  vim.api.nvim_create_autocmd(event, opts)
end

local full_screen_toggle = function()
  is_full_screen = not is_full_screen
  local max_number = MiniFiles.config.windows.max_number
  max_number = is_full_screen and full_screen_max_number or max_number
  MiniFiles.refresh({ windows = { max_number = max_number } })
end

local full_screen_reset = function() is_full_screen = false end

local full_screen_vim_enter = function(args)
  if vim.fn.isdirectory(args.file) ~= 1 then return end
  vim.schedule(full_screen_toggle)
end

local add_buffer_mappings = function(args)
  local traverse_layout = function()
    layout_current = layout_next[layout_current]
    MiniFiles.refresh()
  end
  vim.keymap.set('n', '<C-s>', traverse_layout, { buffer = args.data.buf_id, desc = 'Traverse layout' })
  vim.keymap.set('n', 'gf', full_screen_toggle, { buffer = args.data.buf_id, desc = 'Toggle full screen' })
end

local ensure_layout = function(args)
  -- Built-in layout, return early
  if layout_current == 'L' and not is_full_screen then return end

  -- If there is no state, return early
  local state = MiniFiles.get_explorer_state()
  if state == nil then return end

  -- If event is not for focused window, return early
  local focused_path = state.branch[state.depth_focus]
  local idx_focused
  for i, win in ipairs(state.windows) do
    if win.path == focused_path and win.win_id == args.data.win_id then idx_focused = i end
  end
  if idx_focused == nil then return end

  -- Make explorer appear full screen
  if is_full_screen then return full_screen(state.windows, idx_focused) end

  -- Apply center or right in all other cases
  local layout_fn = layout_current == 'C' and center or right
  layout_fn(state.windows, idx_focused)
end

new_autocmd('User', 'MiniFilesExplorerClose', full_screen_reset, 'Reset full screen')
new_autocmd('VimEnter', '*', full_screen_vim_enter, 'Full screen on vim <dir>')
new_autocmd('User', 'MiniFilesBufferCreate', add_buffer_mappings, 'Add buffer mappings')
new_autocmd('User', 'MiniFilesWindowUpdate', ensure_layout, 'Ensure layout')