canopus 0.4.0 → 0.5.0

data/lib/canopus/workspace/view.rb

@@ -3,16 +3,15 @@
 module Canopus
   # A viewport is one element; only visible document rows become draw commands.
   class Workspace::View < Zaniah::Element
-    attr_reader :editor_bounds, :row_layouts, :regions, :accessibility
+    attr_reader :editor_bounds, :minimap_bounds, :row_layouts, :regions, :accessibility
     attr_accessor :keymap
     def initialize(workspace)
       super()
       @workspace = workspace
-      @editor_bounds, @row_layouts, @regions, @accessibility = {}, {}, [], []
+      @editor_bounds, @minimap_bounds, @row_layouts, @regions, @accessibility = {}, {}, {}, [], []
       @project_scroll = 0
       reset_blink
       @revealed_cursors, @line_widths, @code_caches = {}, {}, {}
-      @frame_diagnostics = {}
     end
     def reset_blink(now = Process.clock_gettime(Process::CLOCK_MONOTONIC))
       @blink_started, @cursor_visible = now, true
@@ -33,12 +32,15 @@ module Canopus
       @font_size = @workspace.settings["font_size"]
       @line_height = (@font_size * 1.55).ceil
       @line_height = 20 if @cx.window.is_a?(Zaniah::Platform::TUI::Window)
+      @frame_id = @frame_id.to_i + 1
+      @workspace.minimap.begin_frame(@frame_id, text_system: @cx.text_system, font_size: @font_size,
+        font_family: @workspace.settings["font_family"], scale_factor: @cx.window.scale_factor)
       @regions.clear
       @row_layouts.clear
       @overlay_rows = []
       @editor_bounds.clear
+      @minimap_bounds.clear
       @accessibility.clear
-      @frame_diagnostics.clear
       visible_editors = @workspace.panes.map(&:active)
       @revealed_cursors.delete_if { |editor, _| !visible_editors.include?(editor) }
       @line_widths.delete_if { |editor, _| !visible_editors.include?(editor) }
@@ -46,7 +48,7 @@ module Canopus
       fill(bounds, :background)
       left_panels = drawable_panels(:left)
       bottom_panels = drawable_panels(:bottom)
-      bottom_visible = @workspace.docks[:bottom][:visible] && (@workspace.terminal_visible || !bottom_panels.empty?)
+      bottom_visible = @workspace.docks[:bottom][:visible] && (@workspace.task_output_visible || @workspace.terminal_visible || !bottom_panels.empty?)
       bottom = bottom_visible ? [bounds.height * 0.7, @workspace.docks[:bottom][:size]].min : 0
       left_visible = @workspace.docks[:left][:visible] && (@workspace.show_project || !left_panels.empty?)
       sidebar = left_visible && bounds.width >= 620 ? [@workspace.docks[:left][:size], bounds.width * 0.4].min : 0
@@ -63,7 +65,13 @@ module Canopus
       paint_layout(@workspace.layout, body)
       if bottom.positive?
         area = Zaniah::Bounds.new(sidebar, body.height, body.width, bottom)
-        @workspace.terminal_visible ? paint_terminal(area) : paint_panels(:bottom, area)
+        if @workspace.task_output_visible
+          paint_task_output(area)
+        elsif @workspace.terminal_visible
+          paint_terminal(area)
+        else
+          paint_panels(:bottom, area)
+        end
       end
       paint_panels(:right, Zaniah::Bounds.new(bounds.width - right, 0, right, bounds.height - 26)) if right.positive?
       region(Zaniah::Bounds.new(sidebar - 3, 0, 6, body.height), role: :separator, label: "Resize left dock", action: [:dock_resize, :left, bounds]) if sidebar.positive?
@@ -101,6 +109,18 @@ module Canopus
     def project_scroll(delta)
       @project_scroll = [@project_scroll + delta, 0].max
     end
+    def minimap_scroll(editor, point)
+      entry = @minimap_bounds[editor]
+      return false unless entry && @workspace.panes.include?(entry[:pane]) && entry[:pane].active.equal?(editor)
+
+      bounds = entry[:bounds]
+      fraction = ((point.y - bounds.y).to_f / [bounds.height, 1].max).clamp(0, 1)
+      source_row = (fraction * editor.buffer.line_count).floor.clamp(0, editor.buffer.line_count - 1)
+      display_row = editor.display_map.to_display(editor.buffer.rope.line_start(source_row)).row
+      target = (display_row - editor.viewport_rows / 2.0).clamp(0, [editor.display_map.row_count - editor.viewport_rows, 0].max)
+      editor.scroll(dy: target - editor.scroll_y)
+      true
+    end
 
     private
     def paint_notifications(bounds)
@@ -197,7 +217,7 @@ module Canopus
       end
     end
     def drawable_panels(side)
-      @workspace.panels.active(side).reject { |definition| %w[terminal explorer search].include?(definition.id) }
+      @workspace.panels.active(side).reject { |definition| %w[terminal output explorer search].include?(definition.id) }
     end
     def paint_layout(node, bounds)
       return paint_pane(node[:pane], bounds) if node[:pane]
@@ -222,7 +242,8 @@ module Canopus
       @scene.clip(bounds) do
         x = bounds.x
         pane.editors.each do |editor|
-          name = editor.buffer.path ? File.basename(editor.buffer.path) : "Untitled"
+          name = editor.buffer.instance_variable_get(:@display_name) ||
+            (editor.buffer.path ? File.basename(editor.buffer.path) : "Untitled")
           name += " *" if editor.buffer.dirty?
           name = "[#{name}]" if pane.pinned.include?(editor)
           width = [[name.length * 7.5 + 30, 100].max, 240].min
@@ -247,19 +268,36 @@ module Canopus
         return
       end
       area = Zaniah::Bounds.new(bounds.x, bounds.y + 34, bounds.width, [bounds.height - 34, 0].max)
-      @editor_bounds[editor] = area
-      region(area, role: :textbox, label: editor.buffer.path || "Untitled document", action: [:editor, pane, editor])
-      paint_editor(editor, area, pane == @workspace.active_pane)
+      minimap = @workspace.minimap_settings(editor)
+      minimap_width = if minimap["enabled"] && !@cx.window.is_a?(Zaniah::Platform::TUI::Window) &&
+          area.height.positive? && area.width >= minimap["width"] + gutter(editor) + 80
+        minimap["width"]
+      else 0
+      end
+      editor_area = Zaniah::Bounds.new(area.x, area.y, area.width - minimap_width, area.height)
+      minimap_area = Zaniah::Bounds.new(editor_area.right, area.y, minimap_width, area.height)
+      breadcrumbs = @workspace.breadcrumb_context(editor)
+      breadcrumb_height = breadcrumbs && editor_area.height >= @line_height * 2 ? @line_height : 0
+      content = Zaniah::Bounds.new(editor_area.x, editor_area.y + breadcrumb_height, editor_area.width,
+        [editor_area.height - breadcrumb_height, 0].max)
+      decorations = prepare_editor_map(editor, content)
+      sticky = prepare_sticky_scroll(editor, content)
+      sticky_height = sticky.length * @line_height
+      body = Zaniah::Bounds.new(content.x, content.y + sticky_height, content.width,
+        [content.height - sticky_height, 0].max)
+      @editor_bounds[editor] = body
+      region(body, role: :textbox, label: editor.buffer.path || "Untitled document", action: [:editor, pane, editor])
+      overview = paint_editor(editor, body, pane == @workspace.active_pane, decorations)
+      paint_sticky_scroll(editor, pane,
+        Zaniah::Bounds.new(content.x, content.y, content.width, sticky_height), sticky) unless sticky.empty?
+      paint_breadcrumbs(editor, pane,
+        Zaniah::Bounds.new(editor_area.x, editor_area.y, editor_area.width, breadcrumb_height), breadcrumbs) if breadcrumb_height.positive?
+      paint_minimap(editor, pane, minimap_area, overview, minimap) if minimap_width.positive?
       fill(Zaniah::Bounds.new(bounds.right - 1, bounds.y, 1, bounds.height), :border)
     end
     def gutter(editor) = [editor.buffer.line_count.to_s.length * @font_size * 0.6 + 24, 52].max
-    def paint_editor(editor, bounds, active)
-      @selection_spans = {}
-      editor.viewport_rows = [(bounds.height / @line_height).floor, 1].max
-      map, first = editor.display_map, editor.scroll_y.floor
-      last = [first + editor.viewport_rows + 1, map.row_count].min
-      cursor_offset = @workspace.settings["vim_mode"] && active ? @workspace.vim.cursor_position : editor.primary.head
-      cursor = map.to_display(cursor_offset)
+    def prepare_editor_map(editor, bounds)
+      map = editor.display_map
       if map.wrap_map.width && !editor.buffer.read_only
         width = [bounds.width - gutter(editor) - 16, 1].max
         if @cx.window.is_a?(Zaniah::Platform::TUI::Window)
@@ -272,19 +310,76 @@ module Canopus
             @workspace.message = "Soft wrap disabled: #{error.message}"
           end
         end
-        last = [first + editor.viewport_rows + 1, map.row_count].min
-        cursor = map.to_display(cursor_offset)
       end
+      prepare_editor_decorations(editor, bounds)
+    end
+    def prepare_editor_decorations(editor, bounds)
+      map = editor.display_map
+      rows = [(bounds.height / @line_height).floor, 1].max
+      first = editor.scroll_y.clamp(0, [map.row_count - rows, 0].max).floor
+      last = [first + rows + 1, map.row_count].min
       decorations = decorations_for_display_rows(editor, map, first, last)
+      overlays = decorations.select { |item| %i[inline block].include?(item.kind) }
+      if map.set_overlays(overlays, font: @cx.text_system.respond_to?(:font) ? @cx.text_system.font : nil,
+        font_size: @font_size, line_height: @line_height)
+        first = editor.scroll_y.clamp(0, [map.row_count - rows, 0].max).floor
+        last = [first + rows + 1, map.row_count].min
+        decorations = (decorations + decorations_for_display_rows(editor, map, first, last)).uniq.sort_by(&:priority).freeze
+        overlays = decorations.select { |item| %i[inline block].include?(item.kind) }
+        map.set_overlays(overlays, font: @cx.text_system.respond_to?(:font) ? @cx.text_system.font : nil,
+          font_size: @font_size, line_height: @line_height)
+      end
+      decorations
+    end
+    def prepare_sticky_scroll(editor, bounds)
+      rows = [(bounds.height / @line_height).floor, 1].max
+      sticky, scroll = [], editor.scroll_y
+      loop do
+        candidate = @workspace.sticky_context(editor, scroll.floor)
+        candidate = candidate.last([[rows - 1, 0].max, candidate.length].min)
+        viewport = [rows - candidate.length, 1].max
+        clamped = scroll.clamp(0, [editor.display_map.row_count - viewport, 0].max)
+        break sticky = candidate if candidate == sticky && clamped == scroll
+        sticky, scroll = candidate, clamped
+      end
+      editor.viewport_rows = [rows - sticky.length, 1].max
+      editor.scroll(dy: scroll - editor.scroll_y)
+      sticky
+    end
+    def paint_editor(editor, bounds, active, decorations = nil)
+      @selection_spans = {}
+      editor.viewport_rows = [(bounds.height / @line_height).floor, 1].max
+      editor.scroll
+      map, first = editor.display_map, editor.scroll_y.floor
+      last = [first + editor.viewport_rows + 1, map.row_count].min
+      vim_cursor = @workspace.settings["vim_mode"] && active
+      cursor_offsets = vim_cursor ? [@workspace.vim.cursor_position] : editor.selections.map(&:head)
+      cursor_offset = cursor_offsets.last
+      cursor = map.to_display(cursor_offset)
+      cursors = cursor_offsets.map { |offset| map.to_display(offset) }
+      decorations ||= decorations_for_display_rows(editor, map, first, last)
       if map.set_overlays(decorations.select { |item| %i[inline block].include?(item.kind) },
-        font: @cx.text_system&.font, font_size: @font_size, line_height: @line_height)
+        font: @cx.text_system.respond_to?(:font) ? @cx.text_system.font : nil,
+        font_size: @font_size, line_height: @line_height)
+        editor.scroll
+        first = editor.scroll_y.floor
         last = [first + editor.viewport_rows + 1, map.row_count].min
         cursor = map.to_display(cursor_offset)
-        decorations = decorations_for_display_rows(editor, map, first, last)
+        cursors = cursor_offsets.map { |offset| map.to_display(offset) }
+        decorations = (decorations + decorations_for_display_rows(editor, map, first, last)).uniq.sort_by(&:priority).freeze
       end
       gutter_items = decorations.select { |item| item.kind == :gutter }
       highlight_items = decorations.select { |item| item.kind == :highlight }
       line_items = decorations.select { |item| item.kind == :line }
+      foreground_items, guide_items = highlight_items.partition do |item|
+        item.style.is_a?(Hash) && item.style[:foreground]
+      end
+      guide_items, highlight_items = guide_items.partition do |item|
+        item.style.is_a?(Hash) && item.style[:guide]
+      end
+      foreground_by_row = foreground_items.group_by { |item| map.to_display(item.range.begin).row }
+      guides_by_row = guide_items.map { |item| [item, map.to_display(item.range.begin)] }
+        .group_by { |_item, point| point.row }
       cursor_row = map.row(cursor.row)
       cursor_line = @cx.text_system&.layout_line(cursor_row.text, size: @font_size)
       brackets = []
@@ -316,12 +411,15 @@ module Canopus
             style = item.style.is_a?(Hash) ? item.style : {color: item.style, rows: 1}
             next unless source_row.between?(item.row, item.row + style.fetch(:rows, 1) - 1)
 
-            marker = Zaniah::Bounds.new(bounds.x + 2, y - 1, 3, @line_height)
+            marker = Zaniah::Bounds.new(bounds.x + style.fetch(:gutter_offset, 2), y - 1,
+              style.fetch(:gutter_width, 3), @line_height)
             paint_instrumented_fill(marker, style.fetch(:color, :accent),
               "syrma:decoration:gutter:#{source_row}:#{instrumentation_component(item.source)}")
             if row.kind == :text && item.on_click
-              region(Zaniah::Bounds.new(bounds.x, y - 1, 10, @line_height), role: :button,
-                label: item.content.to_s, action: [:decoration, item.on_click, editor, source_row])
+              action = item.on_click.respond_to?(:right_click) ? :context_decoration : :decoration
+              region(Zaniah::Bounds.new(bounds.x + style.fetch(:hit_offset, 0), y - 1,
+                style.fetch(:hit_width, 10), @line_height), role: :button,
+                label: item.content.to_s, action: [action, item.on_click, editor, source_row])
             end
           end
           number = editor.relative_line_numbers ? (source_row - editor.buffer.rope.point_at(editor.primary.head).row).abs : source_row + 1
@@ -340,7 +438,7 @@ module Canopus
             fill(Zaniah::Bounds.new(left + x, y + @line_height - 2, width, 2), :accent)
           end
           if row.kind == :text && line && @cx.text_system
-            spans = code_spans(editor, source_row, row)
+            spans = code_spans(editor, source_row, row, foreground_by_row[index] || [])
             @cx.text_system.paint_line(@scene, line, x: left, y: y + line.ascent, color: @theme[:foreground], spans: spans)
             @cx.window.text_runs << [left, y, row.text, @theme[:foreground]]
           elsif row.kind == :overlay_block
@@ -353,16 +451,21 @@ module Canopus
             end
             text(row.text, left, y, color: color)
           end
-          paint_diagnostics(editor, index, row, line, left, y) if row.kind == :text
+          paint_whitespace(editor, map, index, source_row, row, line, left, y, bounds) if row.kind == :text
           paint_overlays&.call
-          if cursor.row == index && active
-            x = left + column_x(row.text, line, cursor.column)
-            width = @workspace.settings["vim_mode"] && @workspace.vim.mode != :insert ? @font_size * 0.6 : 1.5
-            fill(Zaniah::Bounds.new(x, y, width, @line_height - 2), width > 2 ? "#e9a66177" : :cursor) if @cursor_visible || editor.composition
-            @cx.window.ime_state = Zaniah::Bounds.new(x, y, 2, @line_height)
-            if editor.composition && !editor.composition.text.empty?
-              composition = text(editor.composition.text, x, y, color: :accent)
-              fill(Zaniah::Bounds.new(x, y + @line_height - 2, composition&.width || 20, 1), :accent)
+          paint_indent_guides(row, line, left, y, guides_by_row[index] || [])
+          if active
+            cursors.each_with_index do |caret, caret_index|
+              next unless caret.row == index
+              x = left + column_x(row.text, line, caret.column)
+              width = vim_cursor && @workspace.vim.mode != :insert ? @font_size * 0.6 : 1.5
+              fill(Zaniah::Bounds.new(x, y, width, @line_height - 2), width > 2 ? "#e9a66177" : :cursor) if @cursor_visible || editor.composition
+              next unless caret_index == cursors.length - 1
+              @cx.window.ime_state = Zaniah::Bounds.new(x, y, 2, @line_height)
+              if editor.composition && !editor.composition.text.empty?
+                composition = text(editor.composition.text, x, y, color: :accent)
+                fill(Zaniah::Bounds.new(x, y + @line_height - 2, composition&.width || 20, 1), :accent)
+              end
             end
           end
         end
@@ -370,10 +473,130 @@ module Canopus
       previous_width = @line_widths[editor]
       measured_width = [measured_width, previous_width.last].max if previous_width && previous_width.first == editor.buffer.version
       @line_widths[editor] = [editor.buffer.version, measured_width]
-      overview = @workspace.decorations.items_for(editor.buffer, 0...editor.buffer.line_count, context: editor)
-      paint_scrollbars(editor, bounds, measured_width, overview.select { |item| item.kind == :gutter })
+      overview = @workspace.decorations.items_for(editor.buffer, 0...editor.buffer.line_count)
+      paint_scrollbars(editor, bounds, measured_width, overview)
+      overview
+    end
+    def paint_sticky_scroll(editor, pane, bounds, symbols)
+      fill(bounds, :panel)
+      left = bounds.x + gutter(editor) - editor.scroll_x
+      generation = @workspace.document_symbol_generation(editor)
+      @scene.clip(bounds) do
+        symbols.each_with_index do |symbol, index|
+          y = bounds.y + index * @line_height
+          row = editor.buffer.rope.point_at(symbol.selection.begin).row
+          text(row + 1, bounds.x + 12, y + 4, color: :muted, size: @font_size - 1)
+          text(symbol.name, left, y + 4, color: :foreground)
+          area = Zaniah::Bounds.new(bounds.x, y, bounds.width, @line_height)
+          region(area, role: :button, label: "Go to #{symbol.name}",
+            action: [:sticky, pane, editor, symbol.selection.begin, editor.buffer.version, generation])
+        end
+      end
+      fill(Zaniah::Bounds.new(bounds.x, bounds.bottom - 1, bounds.width, 1), :border)
+    end
+    def paint_breadcrumbs(editor, pane, bounds, context)
+      fill(bounds, :panel)
+      items = context[:items].first(3)
+      slot = bounds.width / items.length
+      @scene.clip(bounds) do
+        items.each_with_index do |item, index|
+          area = Zaniah::Bounds.new(bounds.x + slot * index, bounds.y, slot, bounds.height)
+          inset = index.zero? ? 8 : 20
+          text("›", area.x + 5, area.y + 3, color: :muted, size: 12) unless index.zero?
+          label = clip_breadcrumb(item[:label], [area.width - inset - 6, 0].max, 12)
+          next if label.empty?
+
+          text(label, area.x + inset, area.y + 3, color: :foreground, size: 12)
+          region(area, role: :button, label: "Choose siblings for #{item[:label]}",
+            action: [:breadcrumb, pane, editor, item, context])
+        end
+      end
+      fill(Zaniah::Bounds.new(bounds.x, bounds.bottom - 1, bounds.width, 1), :border)
     end
-    def paint_scrollbars(editor, bounds, content_width, gutter_items)
+    def paint_minimap(editor, pane, bounds, overview, settings)
+      fill(bounds, :panel)
+      @minimap_bounds[editor] = {pane: pane, bounds: bounds}.freeze
+      rows = minimap_rows(editor.buffer.line_count, bounds.height)
+      @scene.clip(bounds) do
+        rows.each do |row|
+          texture = @workspace.minimap.texture(editor.buffer, row, width: bounds.width.to_i)
+          next unless texture
+
+          y = bounds.y + bounds.height * row / [editor.buffer.line_count, 1].max
+          @scene.sprite(bounds.x, y, bounds.width, 2, texture: texture, color: @theme[:muted])
+        end
+        paint_minimap_markers(editor, bounds, overview, settings)
+        paint_minimap_viewport(editor, bounds)
+      end
+      region(bounds, role: :scrollbar, label: "Document minimap", action: [:minimap, pane, editor])
+      fill(Zaniah::Bounds.new(bounds.x, bounds.y, 1, bounds.height), :border)
+      @cx.window.request_frame if @workspace.minimap.pending?
+    end
+    def minimap_rows(line_count, height)
+      count = [[(height / 2).floor, line_count, Minimap::ENTRY_LIMIT].min, 1].max
+      return [0] if count == 1
+
+      count.times.map { |index| index * (line_count - 1) / (count - 1) }.uniq
+    end
+    def paint_minimap_markers(editor, bounds, overview, settings)
+      pixels = {}
+      overview.each_with_index do |item, index|
+        break if index >= 10_000
+        if item.source == :git && item.row
+          style = item.style.is_a?(Hash) ? item.style : {color: item.style, rows: 1}
+          minimap_marker(pixels, bounds, editor.buffer.line_count, item.row, style.fetch(:rows, 1), style.fetch(:color, :accent))
+        elsif settings["show_diagnostics"] && item.source == :diagnostics && item.range
+          row = editor.buffer.rope.point_at(item.range.begin).row
+          style = item.style.is_a?(Hash) ? item.style : {color: item.style}
+          minimap_marker(pixels, bounds, editor.buffer.line_count, row, 1, style.fetch(:color, :error))
+        end
+      end
+      @workspace.minimap.search_rows(editor.buffer, editor.buffer.version).each do |row|
+        minimap_marker(pixels, bounds, editor.buffer.line_count, row, 1, :accent)
+      end
+      pixels.each { |y, color| fill(Zaniah::Bounds.new(bounds.right - 5, y, 5, 1), color) }
+    end
+    def minimap_marker(pixels, bounds, line_count, row, count, color)
+      first = (bounds.y + bounds.height * row / [line_count, 1].max).floor
+      last = (bounds.y + bounds.height * (row + count) / [line_count, 1].max).ceil - 1
+      first.clamp(bounds.y.ceil, bounds.bottom.ceil - 1).upto(last.clamp(bounds.y.ceil, bounds.bottom.ceil - 1)) do |y|
+        pixels[y] = color
+      end
+    end
+    def paint_minimap_viewport(editor, bounds)
+      map = editor.display_map
+      first = editor.scroll_y.floor.clamp(0, map.row_count - 1)
+      last = [first + editor.viewport_rows - 1, map.row_count - 1].min
+      top = bounds.y + bounds.height * map.source_row(first) / [editor.buffer.line_count, 1].max
+      bottom = bounds.y + bounds.height * (map.source_row(last) + 1) / [editor.buffer.line_count, 1].max
+      height = [bottom - top, 8].max.clamp(0, bounds.bottom - top)
+      @scene.quad(bounds.x, top, bounds.width, height, color: "#ffffff12", border_width: 1, border_color: @theme[:accent])
+    end
+    def clip_breadcrumb(value, maximum, size)
+      source = value.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).scrub
+      return "" unless maximum.positive?
+
+      layout = @cx.text_system&.layout_line(source, size: size)
+      width = layout&.width || Zaniah::Unicode.width(source) * size * 0.6
+      return source if width <= maximum
+
+      ellipsis = "…"
+      ellipsis_width = @cx.text_system&.layout_line(ellipsis, size: size)&.width || size * 0.6
+      return "" if ellipsis_width > maximum
+
+      shown = +""
+      bytes = 0
+      shown_width = 0
+      source.each_grapheme_cluster do |grapheme|
+        bytes += grapheme.bytesize
+        grapheme_width = layout ? layout.x_for_index(bytes) : shown_width + Zaniah::Unicode.width(grapheme) * size * 0.6
+        break if grapheme_width + ellipsis_width > maximum
+        shown << grapheme
+        shown_width = grapheme_width
+      end
+      shown << ellipsis
+    end
+    def paint_scrollbars(editor, bounds, content_width, decorations)
       track = Zaniah::Bounds.new(bounds.right - 9, bounds.y, 9, [bounds.height - 9, 0].max)
       total = editor.display_map.row_count
       maximum = [total - editor.viewport_rows, 0].max
@@ -381,15 +604,15 @@ module Canopus
         height = [24, track.height * editor.viewport_rows / total].max.clamp(0, track.height)
         thumb = Zaniah::Bounds.new(track.x + 2, track.y + (track.height - height) * editor.scroll_y / maximum, 5, height)
         fill(thumb, :muted)
-        gutter_items.first(500).each do |item|
+        decorations.select { |item| item.kind == :gutter }.first(500).each do |item|
           y = track.y + track.height * item.row / [editor.buffer.line_count, 1].max
           fill(Zaniah::Bounds.new(track.x, y, 3, 2), :accent)
         end
-        frame_diagnostics(editor.buffer).first(500).each do |diagnostic|
-          row = diagnostic.dig("range", "start", "line")
-          next unless row.is_a?(Integer) && row >= 0
+        decorations.select { |item| item.source == :diagnostics && item.kind == :highlight }.first(500).each do |item|
+          row = editor.buffer.rope.point_at(item.range.begin).row
+          style = item.style.is_a?(Hash) ? item.style : {}
           y = track.y + track.height * row / [editor.buffer.line_count, 1].max
-          fill(Zaniah::Bounds.new(track.x + 5, y, 4, 2), :error)
+          fill(Zaniah::Bounds.new(track.x + 5, y, 4, 2), style.fetch(:color, :error))
         end
         region(track, role: :scrollbar, label: "Vertical scroll", action: [:scrollbar, editor, :vertical, track, thumb, maximum])
       end
@@ -405,6 +628,61 @@ module Canopus
     def column_x(value, line, column)
       line ? line.x_for_index(value[0, column].to_s.bytesize) : column * @font_size * 0.6
     end
+    def paint_whitespace(editor, map, index, source_row, row, line, left, y, bounds)
+      settings = @workspace.settings
+      language = settings["languages"].fetch(editor.language_document.definition.name, {})
+      mode = language.fetch("render_whitespace", settings["render_whitespace"])
+      ideographic = language.fetch("render_ideographic_space", settings["render_ideographic_space"])
+      return if mode == "none" && !ideographic
+
+      rope = editor.buffer.rope
+      source_lines = {source_row => [rope.line_start(source_row), rope.line(source_row)]}
+      byte = column = cells = 0
+      row.text.each_grapheme_cluster do |grapheme|
+        if grapheme == " " || grapheme == "　"
+          offset = map.to_buffer(DisplayPoint.new(index, column))
+          point = rope.point_at(offset)
+          start, source = source_lines[point.row] ||= [rope.line_start(point.row), rope.line(point.row)]
+          local = offset - start
+          character = source.byteslice(local..)&.each_char&.first
+          marker = whitespace_marker(character, mode, ideographic, source, local, offset, editor.selections)
+          if marker && (character != "\t" || whitespace_origin?(map, index, column, offset))
+            x = line ? line.x_for_index(byte) : cells * @font_size * 0.6
+            right = line ? line.x_for_index(byte + grapheme.bytesize) : x + Zaniah::Unicode.width(grapheme) * @font_size * 0.6
+            text(marker, left + x, y, color: :muted) if left + right > bounds.x + gutter(editor) && left + x < bounds.right
+          end
+        end
+        byte += grapheme.bytesize
+        column += grapheme.length
+        cells += grapheme.ascii_only? ? grapheme.length : Zaniah::Unicode.width(grapheme)
+      end
+    end
+    def whitespace_origin?(map, row, column, offset)
+      point = map.to_display(offset)
+      point == DisplayPoint.new(row, column) || column.zero? && point.row + 1 == row &&
+        point.column == map.row(point.row).text.length
+    end
+    def whitespace_marker(character, mode, ideographic, source, local, offset, selections)
+      return "□" if character == "　" && ideographic
+      return unless character == " " || character == "\t"
+      return unless mode == "all" ||
+        mode == "boundary" && (character == "\t" || whitespace_boundary?(source, local)) ||
+        mode == "selection" && selections.any? { |selection| !selection.empty? && selection.start < offset + character.bytesize && offset < selection.end }
+
+      character == "\t" ? "→" : "·"
+    end
+    def whitespace_boundary?(source, offset)
+      following = offset + 1
+      offset.zero? || following == source.bytesize || whitespace_before?(source, offset) || whitespace_at?(source, following)
+    end
+    def whitespace_before?(source, offset)
+      byte = source.getbyte(offset - 1)
+      byte == 32 || byte == 9 || source.byteslice(offset - 3, 3) == "　"
+    end
+    def whitespace_at?(source, offset)
+      byte = source.getbyte(offset)
+      byte == 32 || byte == 9 || source.byteslice(offset, 3) == "　"
+    end
     def decorations_for_display_rows(editor, map, first, last)
       rows = (first...last).flat_map do |index|
         row = map.row(index)
@@ -487,23 +765,33 @@ module Canopus
         Zaniah::Text.new(ui_text(item.content), size: [@font_size - 2, 1].max, color: color)
       end
       element = Zaniah::Div.new.w(width).h(height).items_center.child(content)
+      element.style(padding: [0, style.fetch(:padding_right, 0), 0, style.fetch(:padding_left, 0)])
       element.bg(style[:background]) if style[:background]
       element
     end
     def register_overlay_region(editor, item, bounds)
       return unless item.on_click
       offset = item.range&.begin || editor.buffer.rope.line_start(item.row)
+      action = item.on_click.respond_to?(:right_click) ? :context_decoration : :decoration
       region(bounds, role: :button, label: item.content.to_s,
-        action: [:decoration, item.on_click, editor, offset])
+        action: [action, item.on_click, editor, offset])
     end
-    def code_spans(editor, source_row, row)
+    def code_spans(editor, source_row, row, highlight_items = [])
       return [] if editor.buffer.rope.respond_to?(:lazy?) && editor.buffer.rope.lazy?
       raw = editor.language_document.tokens_for(source_row)
       semantic_state = @workspace.semantic_styles&.[](editor.buffer)
       semantic_state = nil unless semantic_state && semantic_state.first == editor.buffer.version
+      base = editor.buffer.rope.line_start(source_row)
+      foreground = highlight_items.each_with_object({}) do |item, colors|
+        style = item.style.is_a?(Hash) ? item.style : nil
+        next unless item.range && style&.[](:foreground)
+        next unless item.range.begin.between?(base + row.offsets.first, base + row.offsets.last)
+        colors[item.range.begin - base] = @theme[style.fetch(:color)]
+      end
       cache = @code_caches[editor] ||= {}
       cached = cache[row.object_id]
-      return cached[3] if cached && cached[4].equal?(row) && cached[0] == raw && cached[1].equal?(@theme) && cached[2].equal?(semantic_state)
+      return cached[4] if cached && cached[5].equal?(row) && cached[0] == raw && cached[1].equal?(@theme) &&
+        cached[2].equal?(semantic_state) && cached[3] == foreground
       offset = 0
       tokens = raw.map do |token, value|
         start = offset
@@ -519,6 +807,7 @@ module Canopus
         color = tokens[index] && original >= tokens[index][0] ? tokens[index][2] : @theme[:foreground]
         overlay = semantic.find { |first, last, _| original >= first && original < last }
         color = overlay[2] if overlay
+        color = foreground[original] if foreground.key?(original)
         if spans.last && spans.last[2] == color
           spans.last[1] += length
         else
@@ -528,27 +817,9 @@ module Canopus
       end
       cache.shift if cache.length >= 512
       spans.each(&:freeze).freeze
-      cache[row.object_id] = [raw, @theme, semantic_state, spans, row]
+      cache[row.object_id] = [raw, @theme, semantic_state, foreground, spans, row]
       spans
     end
-    def paint_diagnostics(editor, index, row, line, left, y)
-      frame_diagnostics(editor.buffer).each do |diagnostic|
-        range = diagnostic["range"]
-        first = editor.display_map.to_display(LSP::Protocol.offset(editor.buffer.rope, range.fetch("start")))
-        last = editor.display_map.to_display(LSP::Protocol.offset(editor.buffer.rope, range.fetch("end")))
-        next unless index.between?(first.row, last.row)
-        from = index == first.row ? first.column : 0
-        to = index == last.row ? last.column : row.text.length
-        x = column_x(row.text, line, from)
-        width = [column_x(row.text, line, to) - x, 6].max
-        @scene.underline(left + x, y + @line_height - 2, width, color: @theme[:error], wave: true)
-      rescue RangeError, KeyError
-        next # Stale server positions must not break a frame after a local edit.
-      end
-    end
-    def frame_diagnostics(buffer)
-      @frame_diagnostics[buffer] ||= @workspace.diagnostics_for(buffer)
-    end
     def paint_highlights(editor, index, row, line, left, y, items)
       items.each do |item|
         range = item.range
@@ -561,7 +832,9 @@ module Canopus
           from = row.offsets.bsearch_index { |offset| offset >= first } || row.text.length
           to = row.offsets.bsearch_index { |offset| offset >= last } || row.text.length
           x = column_x(row.text, line, from)
-          fill(Zaniah::Bounds.new(left + x, y - 1, column_x(row.text, line, to) - x, @line_height), item.style)
+          width = column_x(row.text, line, to) - x
+          paint_highlight(item, left + x, y, width)
+          register_highlight_region(editor, item, left + x, y, width)
           next
         end
         span = highlight_span(editor, item, index)
@@ -575,8 +848,39 @@ module Canopus
           before && right > before[0] && right <= before[1] ? 0 : 3,
           after && right > after[0] && right <= after[1] ? 0 : 3,
           after && x >= after[0] && x < after[1] ? 0 : 3]
-        color = item.style.is_a?(Symbol) ? @theme[item.style] : item.style
-        @scene.quad(left + x, y - 1, right - x, @line_height, color: color, radius: radii)
+        paint_highlight(item, left + x, y, right - x, radii: radii)
+        register_highlight_region(editor, item, left + x, y, right - x)
+      end
+    end
+    def register_highlight_region(editor, item, x, y, width)
+      return unless item.on_click && width.positive?
+
+      region(Zaniah::Bounds.new(x, y - 1, width, @line_height), role: :link, label: item.content.to_s,
+        action: [:decoration, item.on_click, editor, item.range.begin])
+    end
+    def paint_indent_guides(row, line, left, y, items)
+      items.each do |item, point|
+        style = item.style
+        x = column_x(row.text, line, point.column)
+        color = style.fetch(:color, :muted)
+        color = @theme[color] if color.is_a?(Symbol)
+        if @cx.window.is_a?(Zaniah::Platform::TUI::Window)
+          column = [point.column - 1, 0].max
+          text("│", left + column_x(row.text, line, column), y, color: color)
+        else
+          @scene.quad(left + x, y - 1, style[:active] ? 2 : 1, @line_height, color: color)
+        end
+      end
+    end
+    def paint_highlight(item, x, y, width, radii: 0)
+      style = item.style.is_a?(Hash) ? item.style : {}
+      color = style.fetch(:color, item.style.is_a?(Symbol) ? item.style : :selection)
+      color = @theme[color] if color.is_a?(Symbol)
+      if style[:underline]
+        @scene.underline(x, y + @line_height - 2, [width, 6].max, color: color,
+          thickness: style.fetch(:thickness, 1), wave: style[:underline] == :wave)
+      else
+        @scene.quad(x, y - 1, width, @line_height, color: color, radius: radii)
       end
     end
     def highlight_span(editor, item, index)
@@ -592,11 +896,16 @@ module Canopus
       x = column_x(row.text, line, from)
       right = column_x(row.text, line, [to, row.text.length].min)
       right += @font_size * 0.6 if to > row.text.length
+      minimum = item.style.is_a?(Hash) && item.style[:underline] && (!item.on_click || to > from) ? 6 : 0
+      right = [right, x + minimum].max
       cache[index] = right > x ? [x, right] : nil
     end
     def paint_terminal(bounds)
       render_terminal(bounds)
     end
+    def paint_task_output(bounds)
+      render_task_output(bounds)
+    end
     def paint_status(bounds)
       fill(bounds, :status)
       editor = @workspace.editor
@@ -607,13 +916,20 @@ module Canopus
       branch = @workspace.git&.branch
       left = "#{branch}    #{left}" if branch
       left = ":#{@workspace.vim.command_line}" if @workspace.settings["vim_mode"] && @workspace.vim.command_line
-      diagnostics = frame_diagnostics(editor.buffer).length
+      diagnostic_counts = @workspace.diagnostics.counts
+      diagnostics = "#{diagnostic_counts[:error].zero? ? '' : "E#{diagnostic_counts[:error]} "}" \
+        "#{diagnostic_counts[:warning].zero? ? '' : "W#{diagnostic_counts[:warning]} "}"
       language = editor.language_document.definition.name
-      lsp = @workspace.clients[language]
-      right = "#{diagnostics.zero? ? '' : "!#{diagnostics}  "}#{language}#{lsp ? " LSP:#{lsp.state}" : ''}   #{point.row + 1}:#{point.column + 1}   #{editor.use_tabs ? 'Tab' : 'Spaces'}:#{editor.tab_size}   #{editor.buffer.encoding.name}"
+      servers = @workspace.language_server_states(language)
+      lsp = servers.empty? ? "" : " LSP:#{servers.map { |server| "#{server[:name]}=#{server[:state]}" }.join(',')}"
+      newline = editor.buffer.mixed_line_endings? ? "mixed" : editor.buffer.newline.to_s.upcase
+      right = "#{diagnostics}#{language}#{lsp}   #{point.row + 1}:#{point.column + 1}   #{editor.use_tabs ? 'Tab' : 'Spaces'}:#{editor.tab_size}   #{editor.buffer.encoding.name} #{newline}"
       @scene.clip(bounds) do
         text(left, 12, bounds.y + 6, color: :foreground, size: 12)
-        text(right, [bounds.width - right.length * 7.2 - 16, bounds.width * 0.5].max, bounds.y + 6, color: :muted, size: 12)
+        x = [bounds.width - right.length * 7.2 - 16, bounds.width * 0.5].max
+        text(right, x, bounds.y + 6, color: :muted, size: 12)
+        region(Zaniah::Bounds.new(x, bounds.y, bounds.width - x, bounds.height), role: :button,
+          label: "Encoding #{editor.buffer.encoding.name}, line endings #{newline}", action: [:buffer_format, editor.buffer])
       end
     end
     def paint_hover(bounds)
@@ -737,7 +1053,11 @@ module Canopus
       fill(bounds, "#0007")
       @scene.shadow(box.x, box.y, box.width, box.height, color: "#0008", blur: 14)
       @scene.quad(box.x, box.y, box.width, box.height, color: @theme[:panel], radius: 8, border_width: 1, border_color: @theme[:border])
-      labels = {commands: "Command palette", files: "Open file", search: "Find in buffer", save_as: "Save as", confirm_close: "Unsaved changes"}
+      labels = {commands: "Command palette", files: "Open file", search: "Find in buffer", save_as: "Save as",
+                confirm_close: "Unsaved changes", breakpoint_actions: "Breakpoint", breakpoint_edit: "Breakpoint value",
+                git_file_history: "File history", git_commit_history: "Commit history", git_commit_paths: "Changed files",
+                git_revision_compare: "Compare revisions (FROM..TO)", git_remotes: "Git remote",
+                git_credentials: palette[:stage] == :username ? "Git username (blank for token)" : "Git credential"}
       title = labels.fetch(palette[:kind], palette[:kind].to_s)
       if palette[:search_options]
         title += "  Ctrl+Alt " + {regexp: "R:regex", case_sensitive: "C:case", whole_word: "W:word", selection_only: "S:selection"}.filter_map do |key, label|
@@ -745,7 +1065,8 @@ module Canopus
         end.join(" ")
       end
       @scene.clip(box) { text(title, box.x + 16, box.y + 12, color: :muted, size: palette[:search_options] ? 10 : 12) }
-      text(palette[:query].empty? ? "Type here…" : palette[:query], box.x + 16, box.y + 36, color: palette[:query].empty? ? :muted : :foreground)
+      query = palette_query_text(palette)
+      text(query.empty? ? "Type here…" : query, box.x + 16, box.y + 36, color: query.empty? ? :muted : :foreground)
       @scene.clip(box) do
         matches.each_with_index do |match, index|
           row = Zaniah::Bounds.new(box.x + 6, box.y + 74 + index * 28, list_width - 12, 28)
@@ -774,6 +1095,10 @@ module Canopus
         end
       end
     end
+
+    def palette_query_text(palette)
+      palette[:secret] && !palette[:query].empty? ? "•" * [palette[:query].length, 64].min : palette[:query]
+    end
   end
 end