vanken 0.1.0

data/lib/vanken/ui/dialogs.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Vanken
+  module UI
+    module Dialogs
+      def dialog = @dialog
+      def dismiss_dialog
+        @dialog&.close
+        @dialog = @dialog_kind = @pending_destructive = nil
+        @window.request_frame
+      end
+      def show_dialog(kind, title, content)
+        dismiss_dialog
+        @dialog_kind = kind
+        @dialog = Zaniah::UI::Dialog.new(content, title: title).on_close { dismiss_dialog }.test_id("vk.#{kind}")
+        @window.request_frame
+      end
+      def path_dialog(title, &operation)
+        field = Zaniah::UI::TextField.new("", label: title).test_id("vk.path.input")
+        content = Zaniah::Div.new.flex_col.gap(12).child(field)
+          .child(Zaniah::Div.new.flex_row.gap(8)
+            .child(Zaniah::UI::Button.new("OK").on_click do
+              next if field.value.empty?
+              operation.call(field.value)
+            rescue StandardError => error
+              show_error(error)
+            end)
+            .child(Zaniah::UI::Button.new("キャンセル", variant: :secondary).on_click { dismiss_dialog }))
+        show_dialog(:path, title, content)
+      end
+      def capture_options(interface: nil)
+        fields = {}
+        infos = @interface_infos || []
+        choices = infos.map { |item| ["#{item.fetch(:name)}  #{item[:description]}", item.fetch(:name)] }
+        selected = choices.any? { |choice| choice.last == interface } ? interface : choices.first&.last
+        selector = Zaniah::UI::Select.new(choices, label: "インタフェース", value: selected)
+        selector.on_change { |value, *_| selected = value }
+        content = Zaniah::Div.new.flex_col.gap(10).child(selector)
+        [["filter", "キャプチャフィルタ (BPF)", ""], ["snaplen", "Snaplen", @preferences.get("capture.snaplen").to_s],
+          ["buffer_size", "バッファサイズ (bytes)", @preferences.get("capture.buffer_size").to_s]].each do |key, label, value|
+          fields[key] = Zaniah::UI::TextField.new(value, label: label)
+          content.child(fields[key])
+        end
+        promiscuous = Zaniah::UI::Checkbox.new("プロミスキャスモード", value: @preferences.get("capture.promiscuous"))
+        content.child(promiscuous)
+        direction = @preferences.get("capture.direction")
+        content.child(Zaniah::UI::Select.new([["送受信", "inout"], ["受信", "in"], ["送信", "out"]], label: "方向", value: direction).on_change { |value, *_| direction = value })
+        status = Zaniah::UI::Label.new(infos.empty? ? (@interface_error || "インタフェースを取得中です。") : "GUI は通常ユーザーで動作し、取得ヘルパーに必要な権限を渡します。", wrap: :word, tone: :muted)
+        content.child(status)
+        content.child(Zaniah::UI::Button.new("開始").test_id("vk.capture.start").disabled(infos.empty?).on_click do
+          options = {"interface" => selected, "snaplen" => Integer(fields.fetch("snaplen").value, 10),
+            "buffer_size" => Integer(fields.fetch("buffer_size").value, 10), "filter" => fields.fetch("filter").value,
+            "promiscuous" => promiscuous.value, "direction" => direction, "backend" => @preferences.get("capture.backend")}
+          # Compilation and privileged helper startup both happen away from the UI thread.
+          @app.executor.background do
+            metadata = infos.find { |item| item[:name] == selected }
+            Gateway::CaptureFilter.compile(options["filter"], linktype: metadata.fetch(:linktype), live: RUBY_PLATFORM.include?("linux"), snaplen: options["snaplen"]) unless options["filter"].empty?
+            @app.executor.post { start_capture(options) unless @closing }
+          rescue StandardError => error
+            @app.executor.post { show_error(error) unless @closing }
+          end
+        rescue ArgumentError => error
+          show_error(error)
+        end)
+        show_dialog(:capture_options, "キャプチャオプション", content)
+      end
+      def preferences_dialog
+        theme = Zaniah::UI::Select.new(%w[system dark light high_contrast], label: "テーマ", value: @preferences.get("appearance.theme"))
+          .on_change { |value, *_| change_theme(value) }
+        time = Zaniah::UI::Select.new(%w[relative absolute delta delta_displayed epoch], label: "時刻表示", value: @preferences.get("packet_list.time_format"))
+          .on_change { |value, *_| time_format(value) }
+        content = Zaniah::Div.new.flex_col.gap(12).child(theme).child(time)
+          .child(Zaniah::Div.new.flex_row.gap(8).child(Zaniah::UI::Button.new("文字を小さく").on_click { zoom(-1) })
+            .child(Zaniah::UI::Button.new("文字を大きく").on_click { zoom(1) }))
+        show_dialog(:preferences, "設定", content)
+      end
+      def columns_dialog
+        content = Zaniah::Div.new.flex_col.gap(8)
+        @table.columns.each_with_index do |column, index|
+          content.child(Zaniah::Div.new.flex_row.gap(8)
+            .child(Zaniah::UI::Checkbox.new(column[:label], value: column[:visible]).on_change { |value, *_| @table.column_visible(column[:key], value) }.flex_1)
+            .child(Zaniah::UI::Button.new("↑", size: :sm).disabled(index.zero?).on_click { @table.move_column(column[:key], index - 1); columns_dialog })
+            .child(Zaniah::UI::Button.new("↓", size: :sm).disabled(index == @table.columns.size - 1).on_click { @table.move_column(column[:key], index + 1); columns_dialog }))
+        end
+        show_dialog(:columns, "表示する列", content)
+      end
+    end
+  end
+end

data/lib/vanken/ui/file_operations.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Vanken
+  module UI
+    module FileOperations
+      CAPTURE_FILTERS = [{label: "Capture files", patterns: %w[*.pcapng *.pcap]}].freeze
+
+      def open_dialog
+        if @backend == :tui
+          path_dialog("ファイルを開く") { |path| open_file(path) }
+        else
+          paths = @window.prompt_for_paths(filters: CAPTURE_FILTERS)
+          open_file(paths.first) if paths && !paths.empty?
+        end
+      rescue StandardError => error
+        show_error(error)
+      end
+
+      def open_file(path)
+        request_destructive do
+          @file_generation += 1
+          generation = @file_generation
+          previous = document
+          attach_document(nil)
+          @app.executor.background do
+            previous&.close
+            doc = App::Document.new(preferences: @preferences, on_update: ->(updated) { @app.executor.post { changed if document.equal?(updated) } })
+            @app.executor.post do
+              if generation == @file_generation && !@closing
+                attach_document(doc)
+                @preferences.remember_file(path)
+              else
+                doc.close
+              end
+            end
+            doc.open(path)
+            if generation != @file_generation || @closing
+              doc.close
+            end
+          rescue StandardError => error
+            @app.executor.post { show_error(error) if generation == @file_generation && !@closing }
+          end
+        end
+      end
+
+      def save_dialog(after: nil)
+        return unless document
+        path = @backend == :tui ? nil : @window.prompt_for_paths(save: true,
+          default_name: "capture.pcapng", filters: CAPTURE_FILTERS)&.first
+        return path_dialog("名前を付けて保存") { |value| save_file(value, after: after) } if @backend == :tui
+        save_file(path, after: after) if path
+      rescue StandardError => error
+        show_error(error)
+      end
+
+      def save_file(path, after: nil)
+        path += ".pcapng" if File.extname(path).empty?
+        doc = document
+        @app.executor.background do
+          doc.save(path).wait_for_save
+          @app.executor.post do
+            next if @closing || !document.equal?(doc)
+            doc.error ? show_error(doc.error) : (dismiss_dialog; after&.call; changed)
+          end
+        end
+      end
+
+      def close_document
+        request_destructive do
+          old = document
+          @file_generation += 1
+          attach_document(nil)
+          @app.executor.background { @capture.stop; @capture.wait; old&.close }
+        end
+      end
+
+      def reload_file = document&.source == :file && document.path && open_file(document.path)
+
+      def request_destructive(&operation)
+        if @capture.running?
+          @dialog_kind = :capturing
+          content = Zaniah::Div.new.gap(12).child(Zaniah::UI::Label.new("キャプチャを停止してから操作してください。"))
+            .child(Zaniah::UI::Button.new("停止").on_click do
+              @capture.stop
+              dismiss_dialog
+              @app.executor.background { @capture.wait; @app.executor.post { request_destructive(&operation) unless @closing } }
+            end)
+          @dialog = Zaniah::UI::Dialog.new(content, title: "キャプチャ中").test_id("vk.capture.confirm")
+          @window.request_frame
+          return false
+        end
+        return operation.call unless document&.dirty?
+        @pending_destructive = operation
+        @dialog_kind = :unsaved
+        content = Zaniah::Div.new.flex_col.gap(12)
+          .child(Zaniah::UI::Label.new("このキャプチャはまだ保存されていません。"))
+          .child(Zaniah::Div.new.flex_row.gap(8)
+            .child(Zaniah::UI::Button.new("保存").test_id("vk.unsaved.save").on_click { save_dialog(after: @pending_destructive) })
+            .child(Zaniah::UI::Button.new("破棄", variant: :danger).test_id("vk.unsaved.discard").on_click { discard_changes })
+            .child(Zaniah::UI::Button.new("キャンセル", variant: :secondary).test_id("vk.unsaved.cancel").on_click { dismiss_dialog }))
+        @dialog = Zaniah::UI::Dialog.new(content, title: "キャプチャを保存しますか？", close_on_scrim: false).test_id("vk.unsaved")
+        @window.request_frame
+        false
+      end
+
+      def discard_changes
+        action = @pending_destructive
+        dismiss_dialog
+        action&.call
+      end
+    end
+  end
+end

data/lib/vanken/ui/filter_operations.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Vanken
+  module UI
+    class CompletionProvider
+      def initialize(ui) = @ui = ui
+      def complete(text, caret)
+        before = text.byteslice(0, caret)
+        prefix = before[/[a-zA-Z_][\w.]*\z/] || ""
+        items = []
+        if caret == text.bytesize && before == prefix
+          saved = @ui.preferences.bookmarks.to_a + @ui.preferences.history.map { |expression| [expression, expression] }
+          items = saved.select { |label, expression| label.start_with?(prefix) || expression.start_with?(prefix) }
+            .map { |label, expression| {label: label, insert_text: expression} }
+        end
+        names = @ui.document&.catalog&.names || Gateway::FieldCatalog.new.names
+        names += %w[frame.number frame.len frame.cap_len frame.time_relative frame.marked tcp.stream tcp.port udp.port ip.addr ipv6.addr expert.severity expert.code and or not contains matches in]
+        items += names.uniq.grep(/^#{Regexp.escape(prefix)}/).map { |name| {label: name} } unless prefix.empty?
+        return nil if items.empty?
+        Zaniah::UI::Completion.new(range: (caret - prefix.bytesize)...caret, items: items.first(40))
+      end
+    end
+
+    module FilterOperations
+      def set_filter(text)
+        @filter_field.buffer.replace(0...@filter_field.buffer.bytesize, text)
+        validate_filter(text)
+      end
+
+      def validate_filter(text)
+        @filter_generation += 1
+        generation = @filter_generation
+        catalog = document&.catalog
+        @validation_task&.cancel
+        @validation_task = @app.executor.background do
+          next unless generation == @filter_generation && !@closing
+          sleep(0.15)
+          next unless generation == @filter_generation && !@closing
+          begin
+            program = Core::DisplayFilter.compile(text, catalog: catalog)
+            status = text.empty? ? :none : program.warnings.empty? ? :success : :warning
+            message = program.warnings.join("\n")
+          rescue Core::DisplayFilter::SyntaxError => error
+            status = :error
+            message = "#{error.message} (位置 #{error.position + 1})"
+          end
+          @app.executor.post do
+            @filter_field.status(status, message: message) if generation == @filter_generation && !@closing
+          end
+        end
+      end
+
+      def apply_filter
+        doc = document
+        return unless doc
+        expression = @filter_field.value
+        doc.apply_filter(expression)
+        doc.sort(@table.sort_key, @table.sort_direction) if @table&.sort_key
+        @preferences.remember_filter(expression) unless expression.empty?
+        @packet_source.reset
+        @window.request_frame
+      rescue Core::DisplayFilter::SyntaxError => error
+        @filter_field.status(:error, message: "#{error.message} (位置 #{error.position + 1})")
+      end
+      def initial_filter(text)
+        set_filter(text)
+        @pending_filter = true
+        changed if document&.complete?
+      end
+
+      def clear_filter
+        set_filter("")
+        apply_filter
+      end
+      def filter_from_selection(mode = :selected, prepare: false)
+        filter_from_expression(selected_node&.filter, mode, prepare: prepare)
+      end
+      def filter_from_expression(expression, mode = :selected, prepare: false)
+        return unless expression
+        negative = mode.to_s.include?("not")
+        expression = "!(#{expression})" if negative
+        if mode.to_s.start_with?("and", "or") && !@filter_field.value.empty?
+          expression = "(#{@filter_field.value}) #{mode.to_s.start_with?('and') ? '&&' : '||'} (#{expression})"
+        end
+        set_filter(expression)
+        apply_filter unless prepare
+      end
+      def selection_menu(expression)
+        return Zaniah::Menu.new([]) unless expression
+        %i[filter prepare].each do |kind|
+          %i[selected not and and_not or or_not].each do |mode|
+            name = :"#{kind}_#{mode}"
+            @app.actions.register(:"context_#{name}", title: @app.actions.command(name).title) do
+              filter_from_expression(expression, mode, prepare: kind == :prepare)
+            end
+          end
+        end
+        @app.actions.register(:context_copy_filter, title: "フィルタとしてコピー") { copy_text(expression) }
+        Zaniah::Menu.build do
+          submenu("フィルタとして適用") { %i[selected not and and_not or or_not].each { |mode| item(:"context_filter_#{mode}") } }
+          submenu("フィルタを準備") { %i[selected not and and_not or or_not].each { |mode| item(:"context_prepare_#{mode}") } }
+          item(:context_copy_filter)
+        end
+      end
+      def bookmark_filter
+        path_dialog("フィルタの名前") do |name|
+          @preferences.bookmark(name, @filter_field.value) unless name.empty?
+          dismiss_dialog
+        end
+      end
+      def filter_history
+        items = @preferences.bookmarks.map { |name, expression| [name, expression] } + @preferences.history.map { |expression| [expression, expression] }
+        content = Zaniah::Div.new.flex_col.gap(4).children(items.first(60).map do |label, expression|
+          Zaniah::UI::Button.new(label, variant: :ghost).on_click { set_filter(expression); apply_filter; dismiss_dialog }
+        end)
+        show_dialog(:history, "表示フィルタ", content)
+      end
+    end
+  end
+end

data/lib/vanken/ui/main_view.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Vanken
+  module UI
+    class MainView < Zaniah::UI::Component
+      COLUMNS = [[:no, "No.", 64], [:time, "Time", 128], [:source, "Source", 164],
+        [:destination, "Destination", 164], [:protocol, "Protocol", 90], [:length, "Length", 76], [:info, "Info", 560]].freeze
+
+      def initialize(ui)
+        super()
+        @ui = ui
+        columns = COLUMNS.map { |key, label, width| {key: key, label: label, width: width, align: %i[no time length].include?(key) ? :end : :start} }
+        saved = ui.preferences.get("layout.columns")
+        unless saved.empty?
+          columns = columns.sort_by { |column| saved.index { |item| item["key"] == column[:key].to_s } || columns.size }.map do |column|
+            value = saved.find { |item| item["key"] == column[:key].to_s }
+            value ? column.merge(width: value["width"], visible: value["visible"]) : column
+          end
+        end
+        table = Zaniah::UI::VirtualTable.new(ui.packet_source, columns: columns, follow_tail: ui.autoscroll?)
+          .test_id("vk.packet_list").on_select { |index, *_| number = ui.packet_source.row_id(index); ui.select_packet(number) if number.is_a?(Integer) }
+          .on_sort { |key, direction, _| ui.document&.sort(key, direction) }
+          .on_columns_change { |items, _| ui.preferences.set("layout.columns", items.map { |item| {"key" => item[:key].to_s, "width" => item[:width], "visible" => item[:visible]} }) }
+        tree = Zaniah::UI::TreeView.new([]).test_id("vk.packet_details").on_select { |node, *_| ui.select_detail(node) }
+          .on_context_menu { |node, _| ui.selection_menu(node.filter) }
+        table.on_row_context_menu do |index, _|
+          number = ui.packet_source.row_id(index)
+          table.select(index) if number.is_a?(Integer)
+          ui.selection_menu(number.is_a?(Integer) ? "frame.number == #{number}" : nil)
+        end
+        hex = Zaniah::UI::HexView.new("".b).test_id("vk.packet_bytes").on_select { |range, _| ui.select_bytes(range) }
+          .on_copy { |range, _| ui.copy_text(ui.selected_bytes.byteslice(range).unpack1("H*").scan(/../).join(" ")) }
+        ui.install_panes(table, tree, hex)
+        ratios = ui.preferences.get("layout.ratios")
+        @lower = Zaniah::UI::SplitPane.new(pane("Packet details", tree), pane("Packet bytes", hex), ratio: ratios[1])
+          .on_change { |ratio, _| ratios[1] = ratio; ui.preferences.set("layout.ratios", ratios.dup) }
+        @split = Zaniah::UI::SplitPane.new(table, @lower, orientation: :vertical, ratio: ratios[0])
+          .on_change { |ratio, _| ratios[0] = ratio; ui.preferences.set("layout.ratios", ratios.dup) }
+      end
+
+      def build(cx)
+        ui = @ui
+        doc = ui.document
+        doc.frame_latency = cx.window.frame_stats.fetch(:frame_ms, 0) / 1000 if doc
+        height = [cx.window.content_size.height - 132, 120].max
+        table_height = [height * @split.ratio, 48].max
+        lower_height = [(height * (1 - @split.ratio)) - 32, 32].max
+        heights = [table_height, lower_height]
+        if heights != @heights
+          ui.table.viewport_height = table_height
+          ui.tree.viewport_height = lower_height
+          ui.hex.viewport_height = lower_height
+          @heights = heights
+        end
+        root = Zaniah::Div.new.w_full.h_full.flex_col.bg(cx.theme.colors.background)
+        root.child(Zaniah::UI::MenuBar.from(ui.app.menu_bar)) unless RUBY_PLATFORM.include?("darwin") && ui.native?
+        toolbar_items = [
+          button("開く", "vk.open") { ui.open_dialog },
+          button("保存", "vk.save", disabled: !doc) { ui.save_dialog },
+          button(ui.capture.running? ? "停止" : "開始", "vk.capture") { ui.capture_toggle },
+          button("再開", "vk.restart", disabled: !ui.capture.options) { ui.restart_capture },
+          button(ui.autoscroll? ? "末尾追従 ✓" : "末尾追従", "vk.autoscroll") { ui.toggle_autoscroll }]
+        if doc&.loading? && doc.source == :file
+          toolbar_items << button("読み込みを中止", "vk.file.cancel") { doc.cancel }
+        end
+        root.child(Zaniah::UI::Toolbar.new(*toolbar_items))
+        root.child(Zaniah::Div.new.flex_row.items_center.gap(6).p([4, 8])
+          .child(Zaniah::Div.new.flex_1.focusable(context: {in_display_filter: true}).child(ui.filter_field)).child(button("適用", "vk.filter.apply", disabled: !doc) { ui.apply_filter })
+          .child(button("クリア", "vk.filter.clear") { ui.clear_filter })
+          .child(button("履歴", "vk.filter.history") { ui.filter_history }))
+        root.child(doc ? @split.flex_1 : welcome(cx).flex_1)
+        root.child(Zaniah::UI::StatusBar.new(Zaniah::UI::Label.new(ui.status_text, size: :xs)).test_id("vk.status"))
+        root.child(ui.dialog) if ui.dialog
+        root.on_drop(types: ["text/uri-list"]) do |event, _|
+          event.content.formats.fetch("text/uri-list", "").each_line do |line|
+            next if line.start_with?("#") || line.strip.empty?
+            uri = URI.parse(line.strip)
+            next unless uri.scheme == "file" && [nil, "", "localhost"].include?(uri.host) && !uri.query && !uri.fragment
+            path = URI::DEFAULT_PARSER.unescape(uri.path).force_encoding(Encoding::UTF_8)
+            next unless path.start_with?("/") && path.valid_encoding? && !path.include?("\0")
+            ui.open_file(path)
+            break
+          end
+          true
+        rescue URI::InvalidURIError
+          false
+        end
+        root
+      end
+
+      private
+
+      def pane(title, body) = Zaniah::Div.new.w_full.h_full.flex_col.child(Zaniah::UI::Label.new(title, size: :xs, tone: :muted).p([4, 8])).child(body)
+      def button(label, id, disabled: false, &block) = Zaniah::UI::Button.new(label, size: :sm, variant: :secondary).disabled(disabled).test_id(id).on_click(&block)
+      def welcome(_cx)
+        content = Zaniah::Div.new.flex_col.p(24).gap(12).test_id("vk.welcome")
+          .child(Zaniah::UI::Label.new("Vanken", size: :xl))
+          .child(Zaniah::UI::Label.new("パケットキャプチャを開くか、インタフェースを選択してキャプチャを開始します。", tone: :muted, wrap: :word))
+          .child(Zaniah::UI::Button.new("キャプチャファイルを開く").on_click { @ui.open_dialog })
+          .child(Zaniah::UI::Button.new("インタフェースを選択").on_click { @ui.capture_options })
+        @ui.preferences.recent_files.first(10).each do |path|
+          content.child(Zaniah::UI::Button.new(path, size: :sm, variant: :ghost).on_click { @ui.open_file(path) })
+        end
+        (@ui.interface_infos || []).each do |info|
+          name = info.fetch(:name)
+          content.child(Zaniah::UI::Button.new("#{name}  #{info[:description]}", size: :sm, variant: :ghost)
+            .on_click { @ui.capture_options(interface: name) })
+        end
+        content
+      end
+    end
+  end
+end

data/lib/vanken/ui/packet_source.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Vanken
+  module UI
+    class PacketSource
+      def initialize(ui)
+        @ui = ui
+        reset
+      end
+      def reset
+        @document = @ui.document
+        @generation = (@generation || 0) + 1
+        @rows, @pending, @requests = {}, {}, {}
+        @batch_scheduled = false
+        @refresh_pending = @refresh_again = nil
+        @time_format = @ui.preferences.get("packet_list.time_format")
+        @precision = {"milli" => 3, "micro" => 6, "nano" => 9}.fetch(@ui.preferences.get("packet_list.time_precision"))
+        @limit = @ui.preferences.get("packet_list.row_cache_rows")
+        refresh
+      end
+
+      # Called by posted document notifications, never once per rendered cell.
+      def refresh(&ready)
+        return reset.tap { ready&.call } unless @document.equal?(@ui.document)
+        count, packet_count = @document&.displayed_count || 0, @document&.count || 0
+        range = ready && @count && count > @count && @ui.autoscroll? && @ui.table&.body&.visible_range
+        if range && range.size.positive?
+          if @refresh_pending
+            @refresh_again = ready
+          else
+            refresh_tail(count, packet_count, range.size + 2, ready)
+          end
+        else
+          @refresh_pending = @refresh_again = nil
+          publish_counts(count, packet_count)
+          ready&.call
+        end
+        self
+      end
+
+      def count = @count
+      def packet_count = @packet_count
+      def row_id(index)
+        return [:pending, index] unless index.is_a?(Integer) && index.between?(0, @count - 1)
+        @numbers[index] ||= @document.number_at(index)
+      rescue IndexError
+        [:pending, index]
+      end
+      def index_of(id) = @numbers.key(id) || @document&.display_numbers&.index(id)
+      def cell(index, key)
+        text = value(index, key)
+        return nil if text.nil?
+        theme = @ui.app.global(:theme)
+        Zaniah::Text.new(text.to_s, font: @ui.monospace_font, size: theme.typography.size_sm, color: theme.colors.text)
+      end
+      def value(index, key)
+        number = row_id(index)
+        return "" unless number.is_a?(Integer)
+        return number.to_s if key == :no
+        request_row(number, index) unless @rows.key?(number) || @pending.key?(number)
+        @rows[number]&.fetch(key, "")
+      end
+
+      private
+
+      def publish_counts(count, packet_count)
+        @count, @packet_count, @numbers = count, packet_count, {}
+        if @time_format == "delta_displayed"
+          @generation += 1
+          @rows, @pending, @requests = {}, {}, {}
+          @batch_scheduled = false
+        end
+      end
+
+      def refresh_tail(count, packet_count, size, ready)
+        document, generation, format, precision = @document, @generation, @time_format, @precision
+        first = [count - size, 0].max
+        numbers = (first...count).to_h { |index| [index, document.number_at(index)] }
+        previous = format == "delta_displayed" && first.positive? && document.number_at(first - 1)
+        @refresh_pending = numbers
+        @ui.app.executor.background do
+          rows = numbers.to_h do |index, number|
+            values = row_values(document, number, index, format, precision, previous)
+            previous = number
+            [number, values]
+          end
+          @ui.app.executor.post do
+            next unless @refresh_pending.equal?(numbers) && generation == @generation && @ui.document.equal?(document)
+            again, @refresh_again, @refresh_pending = @refresh_again, nil, nil
+            publish_counts(count, packet_count)
+            @numbers = numbers
+            rows.each do |number, values|
+              @pending.delete(number)
+              @rows[number] = values if values
+            end
+            @rows.shift while @rows.size > @limit
+            if again && document.displayed_count == count && document.count == packet_count
+              ready, again = again, nil
+            end
+            published_generation = @generation
+            ready.call
+            refresh(&again) if again && published_generation == @generation && @ui.document.equal?(document)
+          end
+        end
+      rescue IndexError
+        refresh
+        ready.call
+      end
+
+      def request_row(number, index)
+        @pending[number] = @generation
+        @requests[number] = index
+        return if @batch_scheduled
+        @batch_scheduled = true
+        generation = @generation
+        @ui.app.executor.post { flush_rows if generation == @generation && @document.equal?(@ui.document) }
+      end
+
+      def flush_rows
+        document, generation, format, precision = @document, @generation, @time_format, @precision
+        requests, @requests = @requests, {}
+        @batch_scheduled = false
+        @ui.app.executor.background do
+          rows = requests.to_h do |number, index|
+            [number, row_values(document, number, index, format, precision)]
+          end
+          @ui.app.executor.post do
+            next unless generation == @generation && @ui.document.equal?(document)
+            rows.each do |number, values|
+              @pending.delete(number)
+              @rows[number] = values if values
+            end
+            @rows.shift while @rows.size > @limit
+            @ui.window.request_frame if rows.any? { |_, values| values }
+          end
+        end
+      end
+
+      def row_values(document, number, index, format, precision, previous = :current)
+        row = document.row(number)
+        values = row.slice(:source, :destination, :protocol, :length, :info).transform_values(&:to_s)
+        values[:time] = format_time(document, row, number, index, format, precision, previous)
+        values
+      rescue StandardError
+        nil
+      end
+
+      def format_time(document, row, number, index, format, precision, previous = :current)
+        timestamp = row.fetch(:timestamp_ns)
+        return Time.at(timestamp / 1_000_000_000, timestamp % 1_000_000_000, :nsec).strftime("%H:%M:%S.%#{precision}N") if format == "absolute"
+        value = if format == "delta_displayed"
+          previous = index.positive? && document.number_at(index - 1) if previous == :current
+          previous ? (timestamp - document.store.metadata(previous)[:timestamp_ns]) / 1e9 : 0.0
+        else
+          document.time_value(number, format.to_sym)
+        end
+        Kernel.format("%.*f", precision, value)
+      end
+    end
+  end
+end