300 lines
10 KiB
Lua
Executable File
300 lines
10 KiB
Lua
Executable File
-- mod-version:1
|
|
local command = require "core.command"
|
|
local common = require "core.common"
|
|
local config = require "core.config"
|
|
local style = require "core.style"
|
|
local DocView = require "core.docview"
|
|
|
|
-- General plugin settings
|
|
config.minimap_enabled = true
|
|
config.minimap_width = 100
|
|
config.minimap_instant_scroll = false
|
|
config.minimap_syntax_highlight = true
|
|
config.minimap_scale = 1
|
|
|
|
-- how many spaces one tab is equivalent to
|
|
config.minimap_tab_width = 4
|
|
|
|
config.minimap_draw_background = true
|
|
|
|
-- Configure size for rendering each char in the minimap
|
|
local char_height = 1 * SCALE * config.minimap_scale
|
|
local char_spacing = 0.8 * SCALE * config.minimap_scale
|
|
local line_spacing = 2 * SCALE * config.minimap_scale
|
|
|
|
-- Overloaded since the default implementation adds a extra x3 size of hotspot for the mouse to hit the scrollbar.
|
|
local prev_scrollbar_overlaps_point = DocView.scrollbar_overlaps_point
|
|
DocView.scrollbar_overlaps_point = function(self, x, y)
|
|
if not config.minimap_enabled then
|
|
return prev_scrollbar_overlaps_point(self, x, y)
|
|
end
|
|
|
|
local sx, sy, sw, sh = self:get_scrollbar_rect()
|
|
return x >= sx and x < sx + sw and y >= sy and y < sy + sh
|
|
end
|
|
|
|
-- Helper function to determine if current file is too large to be shown fully inside the minimap area.
|
|
local function is_file_too_large(self)
|
|
local line_count = #self.doc.lines
|
|
local _, _, _, sh = self:get_scrollbar_rect()
|
|
|
|
-- check if line count is too large to fit inside the minimap area
|
|
local max_minmap_lines = math.floor(sh / line_spacing)
|
|
return line_count > 1 and line_count > max_minmap_lines
|
|
end
|
|
|
|
-- Overloaded with an extra check if the user clicked inside the minimap to automatically scroll to that line.
|
|
local prev_on_mouse_pressed = DocView.on_mouse_pressed
|
|
DocView.on_mouse_pressed = function(self, button, x, y, clicks)
|
|
if not config.minimap_enabled then
|
|
return prev_on_mouse_pressed(self, button, x, y, clicks)
|
|
end
|
|
|
|
-- check if user clicked in the minimap area and jump directly to that line
|
|
-- unless they are actually trying to perform a drag
|
|
local minimap_hit = self:scrollbar_overlaps_point(x, y)
|
|
if minimap_hit then
|
|
local line_count = #self.doc.lines
|
|
local minimap_height = line_count * line_spacing
|
|
|
|
-- check if line count is too large to fit inside the minimap area
|
|
local is_too_large = is_file_too_large(self)
|
|
if is_too_large then
|
|
local _, _, _, sh = self:get_scrollbar_rect()
|
|
minimap_height = sh
|
|
end
|
|
|
|
-- calc which line to jump to
|
|
local dy = y - self.position.y
|
|
local jump_to_line = math.floor((dy / minimap_height) * line_count) + 1
|
|
|
|
local _, cy, _, cy2 = self:get_content_bounds()
|
|
local lh = self:get_line_height()
|
|
local visible_lines_count = math.max(1, (cy2 - cy) / lh)
|
|
local visible_lines_start = math.max(1, math.floor(cy / lh))
|
|
|
|
-- calc if user hit the currently visible area
|
|
local hit_visible_area = true
|
|
if is_too_large then
|
|
|
|
local visible_height = visible_lines_count * line_spacing
|
|
local scroll_pos = (visible_lines_start - 1) /
|
|
(line_count - visible_lines_count - 1)
|
|
scroll_pos = math.min(1.0, scroll_pos) -- 0..1
|
|
local visible_y = self.position.y + scroll_pos *
|
|
(minimap_height - visible_height)
|
|
|
|
local t = (line_count - visible_lines_start) / visible_lines_count
|
|
if t <= 1 then visible_y = visible_y + visible_height * (1.0 - t) end
|
|
|
|
if y < visible_y or y > visible_y + visible_height then
|
|
hit_visible_area = false
|
|
end
|
|
else
|
|
|
|
-- If the click is on the currently visible line numbers,
|
|
-- ignore it since then they probably want to initiate a drag instead.
|
|
if jump_to_line < visible_lines_start or jump_to_line > visible_lines_start +
|
|
visible_lines_count then hit_visible_area = false end
|
|
end
|
|
|
|
-- if user didn't click on the visible area (ie not dragging), scroll accordingly
|
|
if not hit_visible_area then
|
|
self:scroll_to_line(jump_to_line, false, config.minimap_instant_scroll)
|
|
return
|
|
end
|
|
|
|
end
|
|
|
|
return prev_on_mouse_pressed(self, button, x, y, clicks)
|
|
end
|
|
|
|
-- Overloaded with pretty much the same logic as original DocView implementation,
|
|
-- with the exception of the dragging scrollbar delta. We want it to behave a bit snappier
|
|
-- since the "scrollbar" essentially represents the lines visible in the content view.
|
|
local prev_on_mouse_moved = DocView.on_mouse_moved
|
|
DocView.on_mouse_moved = function(self, x, y, dx, dy)
|
|
if not config.minimap_enabled then
|
|
return prev_on_mouse_moved(self, x, y, dx, dy)
|
|
end
|
|
|
|
if self.dragging_scrollbar then
|
|
local line_count = #self.doc.lines
|
|
local lh = self:get_line_height()
|
|
local delta = lh / line_spacing * dy
|
|
|
|
if is_file_too_large(self) then
|
|
local _, sy, _, sh = self:get_scrollbar_rect()
|
|
delta = (line_count * lh) / sh * dy
|
|
end
|
|
|
|
self.scroll.to.y = self.scroll.to.y + delta
|
|
end
|
|
|
|
-- we need to "hide" that the scrollbar is dragging so that View doesnt does its own scrolling logic
|
|
local t = self.dragging_scrollbar
|
|
self.dragging_scrollbar = false
|
|
local r = prev_on_mouse_moved(self, x, y, dx, dy)
|
|
self.dragging_scrollbar = t
|
|
return r
|
|
end
|
|
|
|
-- Overloaded since we want the mouse to interact with the full size of the minimap area,
|
|
-- not juse the scrollbar.
|
|
local prev_get_scrollbar_rect = DocView.get_scrollbar_rect
|
|
DocView.get_scrollbar_rect = function(self)
|
|
if not config.minimap_enabled then return prev_get_scrollbar_rect(self) end
|
|
|
|
return self.position.x + self.size.x - config.minimap_width * SCALE,
|
|
self.position.y, config.minimap_width * SCALE, self.size.y
|
|
end
|
|
|
|
-- Overloaded so we can render the minimap in the "scrollbar area".
|
|
local prev_draw_scrollbar = DocView.draw_scrollbar
|
|
DocView.draw_scrollbar = function(self)
|
|
if not config.minimap_enabled then return prev_draw_scrollbar(self) end
|
|
|
|
local x, y, w, h = self:get_scrollbar_rect()
|
|
|
|
local highlight = self.hovered_scrollbar or self.dragging_scrollbar
|
|
local visual_color = highlight and style.scrollbar2 or style.scrollbar
|
|
|
|
local _, cy, _, cy2 = self:get_content_bounds()
|
|
local lh = self:get_line_height()
|
|
local visible_lines_count = math.max(1, (cy2 - cy) / lh)
|
|
local visible_lines_start = math.max(1, math.floor(cy / lh))
|
|
local scroller_height = visible_lines_count * line_spacing
|
|
local line_count = #self.doc.lines
|
|
|
|
local visible_y = self.position.y + (visible_lines_start - 1) * line_spacing
|
|
|
|
-- check if file is too large to fit inside the minimap area
|
|
local max_minmap_lines = math.floor(h / line_spacing)
|
|
local minimap_start_line = 1
|
|
if is_file_too_large(self) then
|
|
|
|
local scroll_pos = (visible_lines_start - 1) /
|
|
(line_count - visible_lines_count - 1)
|
|
scroll_pos = math.min(1.0, scroll_pos) -- 0..1, procent of visual area scrolled
|
|
|
|
local scroll_pos_pixels = scroll_pos * (h - scroller_height)
|
|
visible_y = self.position.y + scroll_pos_pixels
|
|
|
|
-- offset visible area if user is scrolling past end
|
|
local t = (line_count - visible_lines_start) / visible_lines_count
|
|
if t <= 1 then visible_y = visible_y + scroller_height * (1.0 - t) end
|
|
|
|
minimap_start_line = visible_lines_start -
|
|
math.floor(scroll_pos_pixels / line_spacing)
|
|
minimap_start_line = math.max(1, math.min(minimap_start_line,
|
|
line_count - max_minmap_lines))
|
|
end
|
|
|
|
if config.minimap_draw_background then
|
|
renderer.draw_rect(x, y, w, h, style.minimap_background or style.background)
|
|
end
|
|
-- draw visual rect
|
|
renderer.draw_rect(x, visible_y, w, scroller_height, visual_color)
|
|
|
|
-- time to draw the actual code, setup some local vars that are used in both highlighted and plain renderind.
|
|
local line_y = y
|
|
|
|
-- when not using syntax highlighted rendering, just use the normal color but dim it 50%.
|
|
local color = style.syntax["normal"]
|
|
color = {color[1], color[2], color[3], color[4] * 0.5}
|
|
|
|
-- we try to "batch" characters so that they can be rendered as just one rectangle instead of one for each.
|
|
local batch_width = 0
|
|
local batch_start = x
|
|
local minimap_cutoff_x = x + config.minimap_width * SCALE
|
|
local batch_syntax_type = nil
|
|
local function flush_batch(type)
|
|
local old_color = color
|
|
color = style.syntax[batch_syntax_type]
|
|
if config.minimap_syntax_highlight and color ~= nil then
|
|
-- fetch and dim colors
|
|
color = {color[1], color[2], color[3], color[4] * 0.5}
|
|
else
|
|
color = old_color
|
|
end
|
|
if batch_width > 0 then
|
|
renderer.draw_rect(batch_start, line_y, batch_width, char_height, color)
|
|
end
|
|
batch_syntax_type = type
|
|
batch_start = batch_start + batch_width
|
|
batch_width = 0
|
|
end
|
|
|
|
-- render lines with syntax highlighting
|
|
if config.minimap_syntax_highlight then
|
|
|
|
-- keep track of the highlight type, since this needs to break batches as well
|
|
batch_syntax_type = nil
|
|
|
|
-- per line
|
|
local endidx = minimap_start_line + max_minmap_lines
|
|
endidx = math.min(endidx, line_count)
|
|
for idx = minimap_start_line, endidx do
|
|
batch_syntax_type = nil
|
|
batch_start = x
|
|
batch_width = 0
|
|
|
|
-- per token
|
|
for _, type, text in self.doc.highlighter:each_token(idx) do
|
|
-- flush prev batch
|
|
if not batch_syntax_type then batch_syntax_type = type end
|
|
if batch_syntax_type ~= type then flush_batch(type) end
|
|
|
|
-- per character
|
|
for char in common.utf8_chars(text) do
|
|
if char == " " or char == "\n" then
|
|
flush_batch(type)
|
|
batch_start = batch_start + char_spacing
|
|
elseif char == " " then
|
|
flush_batch(type)
|
|
batch_start = batch_start + (char_spacing * config.minimap_tab_width)
|
|
elseif batch_start + batch_width > minimap_cutoff_x then
|
|
flush_batch(type)
|
|
break
|
|
else
|
|
batch_width = batch_width + char_spacing
|
|
end
|
|
|
|
end
|
|
end
|
|
flush_batch(nil)
|
|
line_y = line_y + line_spacing
|
|
end
|
|
|
|
else -- render lines without syntax highlighting
|
|
for idx = 1, line_count - 1 do
|
|
batch_start = x
|
|
batch_width = 0
|
|
|
|
for char in common.utf8_chars(self.doc.lines[idx]) do
|
|
if char == " " or char == "\n" then
|
|
flush_batch()
|
|
batch_start = batch_start + char_spacing
|
|
elseif batch_start + batch_width > minimap_cutoff_x then
|
|
flush_batch()
|
|
else
|
|
batch_width = batch_width + char_spacing
|
|
end
|
|
end
|
|
flush_batch()
|
|
line_y = line_y + line_spacing
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
command.add(nil, {
|
|
["minimap:toggle-visibility"] = function()
|
|
config.minimap_enabled = not config.minimap_enabled
|
|
end,
|
|
["minimap:toggle-syntax-highlighting"] = function()
|
|
config.minimap_syntax_highlight = not config.minimap_syntax_highlight
|
|
end
|
|
})
|