Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

neovim/lua/bugabinga/image.lua

Raw
-- Modified from folke/snacks.nvim (Apache-2.0); see lua/bugabinga/image/NOTICE.
local auto = require 'std.auto'
local kitty = require 'bugabinga.image.kitty'
local raster = require 'bugabinga.image.raster'
local terminal = require 'bugabinga.image.terminal'
local geometry = require 'bugabinga.image.geometry'

local patterns = { '*.[pP][nN][gG]', '*.[jJ][pP][gG]', '*.[jJ][pP][eE][gG]', '*.[wW][eE][bB][pP]', '*.[gG][iI][fF]' }
local buffers, resources, placements = {}, {}, {}
local queued, measuring, suspended, exiting = false, false, false, false
local redrawing = false
local reconcile

local function text(buf, message)
  if not vim.api.nvim_buf_is_valid(buf) then return end
  local readonly = vim.bo[buf].readonly
  vim.bo[buf].readonly = false
  vim.bo[buf].modifiable = true
  local lines = message and vim.split(message:gsub('\r\n', '\n'), '\n', { plain = true }) or {}
  vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
  vim.bo[buf].modified = false
  vim.bo[buf].modifiable = false
  vim.bo[buf].readonly = readonly
end

local function remove(win)
  local placement = placements[win]
  if placement then
    kitty.delete(placement.image, placement.id)
    placements[win] = nil
  end
end

local function hide()
  for win in pairs(placements) do remove(win) end
end

local function schedule()
  if queued or exiting then return end
  queued = true
  vim.schedule(function()
    queued = false
    if not exiting then reconcile() end
  end)
end

local function forget(resource)
  if resource.uploaded then kitty.delete(resource.id); resource.uploaded = false end
end

local function refresh(invalidate)
  if exiting or not next(buffers) then return end
  hide()
  if invalidate then for _, resource in pairs(resources) do forget(resource) end end
  measuring = true
  terminal.refresh(function(size, err)
    if exiting then return end
    measuring = false
    for buf, state in pairs(buffers) do
      if state.resource and not state.resource.failed then
        if state.error ~= err then
          state.error = err
          text(buf, err and ('Image: ' .. err) or nil)
        end
      end
    end
    if size then schedule() end
  end)
end

local function release(buf)
  local state = buffers[buf]
  if not state then return end
  buffers[buf] = nil
  if state.cancel then state.cancel() end
  for win, placement in pairs(placements) do
    if placement.buf == buf then remove(win) end
  end
  local resource = state.resource
  if resource then
    resource.references = resource.references - 1
    if resource.references == 0 then
      forget(resource)
      resources[resource.key] = nil
    end
  end
end

local function response(ev)
  local fields, message = ev.data.sequence:match('^\27_G([^;]+);(.+)')
  local id = fields and tonumber((',' .. fields):match(',i=(%d+)'))
  if not id or message == 'OK' then return end
  for _, resource in pairs(resources) do
    if resource.id == id then
      if message:match('^ENOENT') and not resource.failed then
        resource.uploaded = false
        for win, placement in pairs(placements) do
          if placement.image == id then remove(win) end
        end
      else
        resource.failed = true
        for buf, state in pairs(buffers) do
          if state.resource == resource then state.error = message; text(buf, 'Image: ' .. message) end
        end
      end
      schedule()
      return
    end
  end
end

local function load(buf)
  release(buf)
  local state = {}
  buffers[buf] = state
  vim.bo[buf].swapfile = false
  vim.bo[buf].readonly = true
  vim.bo[buf].filetype = 'image'
  text(buf, 'Loading image…')
  if not terminal.available() then
    state.error = 'Image viewing requires a Neovim terminal UI with Kitty graphics'
    text(buf, state.error)
    return
  end
  state.cancel = raster.prepare(vim.api.nvim_buf_get_name(buf), function(err, result)
    if exiting or buffers[buf] ~= state or not vim.api.nvim_buf_is_valid(buf) then return end
    state.cancel = nil
    if err then
      state.error = tostring(err)
      text(buf, 'Image: ' .. state.error)
      return
    end
    local resource = resources[result.key]
    if not resource then
      resource = vim.tbl_extend('force', result, { id = kitty.new_id(), references = 0 })
      resources[result.key] = resource
    end
    resource.references = resource.references + 1
    state.resource = resource
    text(buf)
    refresh(false)
  end)
end

local function floating_rect(win, config)
  local pos = vim.api.nvim_win_get_position(win)
  local border = config.border and config.border ~= 'none' and 2 or 0
  return { row = pos[1] + 1, col = pos[2] + 1,
    cols = vim.api.nvim_win_get_width(win) + border, rows = vim.api.nvim_win_get_height(win) + border }
end

reconcile = function()
  if not next(buffers) or suspended or measuring or not terminal.available() then return end
  local cells = terminal.get()
  if not cells then return end
  local desired, floats = {}, {}
  for _, win in ipairs(vim.api.nvim_tabpage_list_wins(0)) do
    local config = vim.api.nvim_win_get_config(win)
    if not config.hide and not config.external then
      if config.relative ~= '' then
        floats[#floats + 1] = floating_rect(win, config)
      else
        local buf = vim.api.nvim_win_get_buf(win)
        local state = buffers[buf]
        if state and state.resource and not state.error then
          local info = vim.fn.getwininfo(win)[1]
          local rect = geometry.rectangle(info, state.resource, cells)
          if rect then desired[win] = { buf = buf, resource = state.resource, rect = rect } end
        end
      end
    end
  end
  for win, wanted in pairs(desired) do
    for _, rect in ipairs(floats) do
      if geometry.overlaps(wanted.rect, rect) then desired[win] = nil; break end
    end
  end
  for win, placement in pairs(placements) do
    local wanted = desired[win]
    if not wanted or placement.image ~= wanted.resource.id then remove(win) end
  end
  for win, wanted in pairs(desired) do
    local resource = wanted.resource
    if not resource.uploaded then
      local ok, err = kitty.upload(resource.id, resource.path)
      if not ok then
        buffers[wanted.buf].error = tostring(err)
        text(wanted.buf, 'Image: ' .. tostring(err))
        remove(win)
        break
      end
      resource.uploaded = true
    end
    local placement = placements[win]
    if not placement then
      placement = { id = kitty.new_id(), image = resource.id, buf = wanted.buf }
      placements[win] = placement
    end
    if redrawing or not vim.deep_equal(placement.rect, wanted.rect) then
      local ok, err = kitty.place(resource.id, placement.id, wanted.rect)
      if ok then
        placement.rect = wanted.rect
      else
        remove(win)
        text(wanted.buf, 'Image: ' .. tostring(err))
      end
    end
  end
  local visible = {}
  for _, placement in pairs(placements) do visible[placement.image] = true end
  for _, resource in pairs(resources) do if not visible[resource.id] then forget(resource) end end
  redrawing = false
end

local register = auto 'bugabinga_image'
register {
  { events = 'TermResponse', command = response },
  { events = 'BufReadCmd', pattern = patterns, command = function(ev) load(ev.buf) end },
  { events = 'BufWriteCmd', pattern = patterns, command = function() error('Image buffers are read-only') end },
  { events = { 'BufUnload', 'BufWipeout' }, command = function(ev) release(ev.buf) end },
  { events = { 'BufWinEnter', 'BufWinLeave', 'WinEnter', 'WinNew', 'WinClosed', 'WinResized', 'TabEnter',
    'SessionLoadPost' }, command = schedule },
  { events = 'OptionSet', pattern = { 'number', 'relativenumber', 'numberwidth', 'signcolumn', 'foldcolumn',
    'statuscolumn', 'winbar', 'showtabline', 'laststatus', 'cmdheight' }, command = schedule },
  { events = 'VimResized', command = function() refresh(false) end },
  { events = { 'VimResume', 'FocusGained' }, command = function()
    suspended = false
    refresh(true)
  end },
  { events = 'VimSuspend', command = function() suspended = true; hide() end },
  { events = 'VimLeavePre', command = function()
    exiting = true
    hide()
    for buf in pairs(buffers) do release(buf) end
  end },
}

local namespace = vim.api.nvim_create_namespace('bugabinga_image')
vim.api.nvim_set_decoration_provider(namespace, {
  on_end = function()
    if next(buffers) then redrawing = true; schedule() end
  end,
})

_G.BugabingaImage = { refresh = function() refresh(true) end }
return BugabingaImage