vanken 0.1.0 → 0.3.0

data/lib/vanken/ui/application.rb

@@ -11,34 +11,52 @@ require_relative "selection"
 require_relative "dialogs"
 require_relative "actions"
 require_relative "packet_source"
+require_relative "navigation_operations"
+require_relative "coloring_operations"
+require_relative "column_operations"
+require_relative "settings_operations"
+require_relative "analysis_dialogs"
 require_relative "../gateway/interfaces"
 require_relative "../gateway/capture_filter"
+require_relative "../gateway/resolver"
 require_relative "../app/capture_controller"
 require_relative "../config/log"
+require_relative "../config/messages"
+require_relative "../config/sessions"
 
 module Vanken
   module UI
     class Application
       include FileOperations, FilterOperations, Selection, Dialogs
+      include NavigationOperations, ColoringOperations
+      include ColumnOperations
+      include SettingsOperations
+      include AnalysisDialogs
       attr_reader :app, :window, :preferences, :table, :tree, :hex, :filter_field, :capture,
-                  :dialog_kind, :packet_source, :interface_infos
+                  :dialog_kind, :packet_source, :interface_infos, :interface_traffic
 
-      def initialize(backend: nil, preferences: Config::Preferences.new, debug: false)
-        @preferences = preferences
+      def initialize(backend: nil, preferences: nil, debug: false, session_parent: nil)
+        @profiles = Config::Profiles.new(directory: preferences&.directory || Config::Paths.config)
+        @preferences = preferences ||= @profiles.preferences
         @log = Config::Log.open(debug: debug, directory: File.join(preferences.directory, "logs"))
         @app = Zaniah::App.new
         @entity = @app.new_entity { {document: nil, number: nil, node: nil, details: [], bytes: "".b, error: nil} }
         @selection_generation, @file_generation, @filter_generation = 0, 0, 0
         @pool_mutex = Mutex.new
+        @resolver_mutex = Mutex.new
+        @resolution_changes = {}
         @autoscroll = false
         @backend = backend || (RUBY_PLATFORM.match?(/darwin/) ? :mac : RUBY_PLATFORM.match?(/mingw|mswin/) ? :windows : :linux)
-        @filter_field = Zaniah::UI::TextField.new("", placeholder: "表示フィルタ", clearable: false).test_id("vk.filter.input")
+        @session_parent = session_parent || Dir.tmpdir
+        @filter_field = Zaniah::UI::TextField.new("", placeholder: t("表示フィルタ"), clearable: false).test_id("vk.filter.input")
         @filter_field.completion(CompletionProvider.new(self)).on_change { |text, _| validate_filter(text) }
         @packet_source = PacketSource.new(self)
         @capture = App::CaptureController.new(preferences: preferences,
           on_document: ->(document) { @app.executor.post { attach_document(document) unless @closing } },
           on_update: ->(*) { @app.executor.post { changed unless @closing } })
         @window = @app.open_window(backend: @backend, width: preferences.get("layout.width"), height: preferences.get("layout.height"), title: "Vanken")
+        coloring_rules
+        column_settings
         unless @backend == :tui
           @window.text_system = Zaniah::TextSystem::Renderer.new
           @window.text_system.scale_factor = @window.scale_factor
@@ -59,6 +77,7 @@ module Vanken
         change_theme(preferences.get("appearance.theme"), persist: false)
         @main_view = MainView.new(self).test_id("vk.main")
         @window.draw { @main_view }
+        start_interface_monitor unless @backend == :headless
         show_error(Vanken::ConfigError.new(preferences.warning)) if preferences.warning
         @app.executor.background do
           infos = Gateway::Interfaces.list
@@ -71,9 +90,16 @@ module Vanken
         rescue StandardError => error
           @app.executor.post { @interface_error = error.message; changed }
         end
+        if @backend != :headless || session_parent
+          @app.executor.background do
+            sessions = Config::Sessions.candidates(parent: @session_parent)
+            @app.executor.post { recovery_dialog(sessions) if !@closing && !sessions.empty? && !@dialog }
+          end
+        end
       end
 
       def document = @app.read(@entity)[:document]
+      def t(text, **values) = Config::Messages.translate(text, language: @preferences.get("appearance.language"), **values)
       def selected_number = @app.read(@entity)[:number]
       def selected_node = @app.read(@entity)[:node]
       def detail_nodes = @app.read(@entity)[:details]
@@ -83,6 +109,19 @@ module Vanken
       end
       def changed
         return if @closing
+        apply_analysis_settings
+        if @reanalysis_in_flight && @reanalysis_task&.done? && document&.complete?
+          @reanalysis_in_flight = false
+          @packet_source.reset
+        end
+        if @reanalysis_selection && document&.complete? && !@reanalysis_in_flight
+          saved_doc, number, generation = @reanalysis_selection
+          @reanalysis_selection = nil
+          number = selected_number if generation != @selection_generation
+          select_packet(number) if document.equal?(saved_doc) && number && number <= document.count
+        end
+        begin_reanalysis if @pending_reanalysis
+        refresh_analysis
         @packet_source.refresh do
           next if @closing
           error = document&.error || @capture.error
@@ -96,9 +135,15 @@ module Vanken
       end
       def attach_document(value)
         return if @closing
+        wait_reanalysis
+        @pending_reanalysis = @reanalysis_selection = nil
+        @reanalysis_in_flight = false
+        close_analysis
+        cancel_packet_search
         value.scanner = ->(payload) { filter_pool.submit(payload) } if value
         @selection_generation += 1
         update { |state| state.merge!(document: value, number: nil, node: nil, details: [], bytes: "".b) }
+        configure_document_columns if value
         @packet_source.reset
         @tree&.replace([])
         @hex.bytes = "".b if @hex
@@ -108,9 +153,13 @@ module Vanken
         @table.scroll_to(0) if @table && value&.displayed_count&.positive? && !@autoscroll
         @window.title = "Vanken#{value&.path ? " — #{File.basename(value.path)}" : ""}" if @window.respond_to?(:title=)
       end
-      def run = @app.run
+      def run
+        return @app.run unless @backend == :tui
+        @window.on_tick { @app.executor.drain }
+        @window.run
+      end
       def native? = !%i[headless tui].include?(@backend)
-      def monospace_font = @window.text_system&.font
+      def monospace_font = @window.text_system.respond_to?(:font) ? @window.text_system.font : nil
       def install_panes(table, tree, hex) = (@table, @tree, @hex = table, tree, hex)
       def filter_pool
         @pool_mutex.synchronize do
@@ -125,6 +174,11 @@ module Vanken
       def close
         return if @closed
         @closing = true
+        stop_interface_monitor
+        reset_resolver
+        wait_reanalysis
+        close_analysis
+        cancel_packet_search
         @packet_source.reset
         @selection_generation += 1
         @filter_generation += 1
@@ -147,6 +201,7 @@ module Vanken
         theme = theme.with(typography: theme.typography.with(size_md: size, size_sm: size - 1, size_xs: size - 2))
         @app.global(:theme, theme)
         @preferences.set("appearance.theme", name) if persist
+        @packet_source.reset
         @window.request_frame
       end
       def zoom(delta = nil)
@@ -187,19 +242,138 @@ module Vanken
       end
       def status_text
         doc = document
-        return "キャプチャファイルを開くか、インタフェースを選んで開始してください" unless doc
+        return t("キャプチャファイルを開くか、インタフェースを選んで開始してください") unless doc
         dropped = @capture.stats.fetch("dropped", @capture.stats.fetch(:dropped, 0))
         total = doc.store.durable_count
-        "#{doc.loading? ? '読み込み中' : 'パケット'} #{@packet_source.packet_count} / #{total}   表示 #{@packet_source.count}   ドロップ #{dropped}#{doc.progress ? "   #{(doc.progress * 100).round}%" : ''}"
+        t("%{label} %{count} / %{total}   表示 %{displayed}   ドロップ %{dropped}%{progress}",
+          label: t(doc.loading? ? "読み込み中" : "パケット"), count: @packet_source.packet_count, total: total,
+          displayed: @packet_source.count, dropped: dropped, progress: doc.progress ? "   #{(doc.progress * 100).round}%" : "")
       end
       def copy_text(text) = @window.write_clipboard([Zaniah::Clipboard::Item.new({"text/plain" => text})])
       def show_error(error)
         @log.error("#{error.class}: #{error.message}")
         @last_error = error
+        dismiss_dialog
         @dialog_kind = :error
-        @dialog = Zaniah::UI::Dialog.new(Zaniah::UI::Label.new(error.message, wrap: :word), title: "操作を完了できません").test_id("vk.error")
+        @dialog_reopen = -> { show_error(error) }
+        @dialog = Zaniah::UI::Dialog.new(Zaniah::UI::Label.new(error.message, wrap: :word), title: t("操作を完了できません"), close_label: t("閉じる")).test_id("vk.error")
+          .on_close { dismiss_dialog }
         @window.request_frame
       end
+
+      def start_interface_monitor
+        return if @traffic_thread
+        @traffic_mutex, @traffic_condition = Mutex.new, ConditionVariable.new
+        @traffic_thread = Thread.new do
+          previous, history = nil, {}
+          loop do
+            break if @closing
+            sample = Gateway::Interfaces.sample_traffic(previous: previous, history: history)
+            previous, history = sample.values_at(:previous, :history)
+            post = @traffic_mutex.synchronize do
+              @traffic_sample = sample
+              !@traffic_posted && (@traffic_posted = true)
+            end
+            if post
+              @app.executor.post do
+                value = @traffic_mutex.synchronize { @traffic_posted = false; @traffic_sample }
+                next if @closing
+                @interface_traffic = value
+                @app.update(@entity) { |_state, cx| cx.notify }
+              end
+            end
+            @traffic_mutex.synchronize { @traffic_condition.wait(@traffic_mutex, 1) unless @closing }
+          end
+        end
+      end
+
+      def stop_interface_monitor
+        return unless @traffic_thread
+        @traffic_mutex.synchronize { @traffic_condition.broadcast }
+        @traffic_thread.join
+        @traffic_thread = nil
+      end
+
+      def resolve_address(address, document:, number:)
+        resolver = @resolver_mutex.synchronize do
+          next if @closing || !@preferences.get("name_resolution.enabled")
+          @resolver ||= Gateway::Resolver.new(timeout: @preferences.get("name_resolution.timeout"), limit: @preferences.get("name_resolution.cache_size"))
+        end
+        return address unless resolver
+        resolver.request(address) do |_name|
+          post = @resolver_mutex.synchronize do
+            next false if @closing || !resolver.equal?(@resolver)
+            (@resolution_changes[document] ||= Set.new).add(number)
+            !@resolution_posted && (@resolution_posted = true)
+          end
+          next unless post
+          @app.executor.post do
+            changes = @resolver_mutex.synchronize do
+              saved, @resolution_changes = @resolution_changes, {}
+              @resolution_posted = false
+              saved
+            end
+            next if @closing
+            numbers = changes[self.document]
+            @packet_source.invalidate_rows(numbers) if numbers && !numbers.empty?
+          end
+        end
+      end
+
+      def reset_resolver
+        old = @resolver_mutex.synchronize do
+          previous, @resolver = @resolver, nil
+          @resolution_changes = {}
+          @resolution_posted = false
+          previous
+        end
+        return unless old
+        @closing ? old.close : @app.executor.background { old.close }
+      end
+
+      def recovery_dialog(sessions)
+        content = Zaniah::Div.new.flex_col.gap(8)
+        sessions.each do |directory|
+          content.child(Zaniah::Div.new.flex_col.gap(4)
+            .child(Zaniah::UI::Label.new(directory, wrap: :word))
+            .child(Zaniah::Div.new.flex_row.gap(8)
+              .child(Zaniah::UI::Button.new(t("復旧")).on_click { recover_session(directory) })
+              .child(Zaniah::UI::Button.new(t("破棄"), variant: :danger).on_click do
+                Config::Sessions.discard(directory, parent: @session_parent)
+                remaining = sessions.reject { |value| value == directory }
+                remaining.empty? ? dismiss_dialog : recovery_dialog(remaining)
+              rescue StandardError => error
+                show_error(error)
+              end)))
+        end
+        show_dialog(:recovery, t("前回のキャプチャを復旧"), Zaniah::ScrollView.new.h(240).child(content), reopen: -> { recovery_dialog(sessions) })
+      end
+
+      def recover_session(directory)
+        request_destructive do
+          previous = document
+          attach_document(nil)
+          dismiss_dialog
+          @file_generation += 1
+          generation = @file_generation
+          preferences = @preferences
+          @app.executor.background do
+            previous&.close
+            doc = Config::Sessions.recover(directory, parent: @session_parent, preferences: preferences,
+              on_update: ->(updated) { @app.executor.post { changed if !@closing && document.equal?(updated) } })
+            @app.executor.post do
+              if !@closing && generation == @file_generation
+                attach_document(doc)
+                changed
+              else
+                doc.close
+              end
+            end
+          rescue StandardError => error
+            @app.executor.post { show_error(error) if !@closing && generation == @file_generation }
+          end
+        end
+      end
     end
   end
 end

data/lib/vanken/ui/coloring_operations.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "../core/coloring"
+
+module Vanken
+  module UI
+    module ColoringOperations
+      def coloring_rules = @coloring_rules ||= load_coloring_rules
+      def reload_coloring_rules
+        @coloring_rules = load_coloring_rules
+        @packet_source.reset
+        @window.request_frame
+      end
+      def replace_coloring_rules(payload)
+        rules = Core::Coloring::RuleSet.new(payload, catalog: document&.catalog)
+        rules.save(File.join(@preferences.directory, "coloring_rules.yml"))
+        @coloring_rules = rules
+        @packet_source.reset
+        @window.request_frame
+        rules
+      end
+      def coloring_enabled? = @preferences.get("packet_list.coloring")
+      def toggle_coloring
+        @preferences.set("packet_list.coloring", !coloring_enabled?)
+        @packet_source.reset
+        @window.request_frame
+      end
+
+      def coloring_dialog
+        @coloring_draft ||= coloring_rules.to_h
+        rules = @coloring_draft.fetch("rules")
+        @coloring_index = (@coloring_index || 0).clamp(0, [rules.size - 1, 0].max)
+        content = Zaniah::Div.new.flex_col.gap(12)
+        unless rules.empty?
+          content.child(Zaniah::UI::Select.new(rules.each_with_index.map { |rule, index| ["#{index + 1}. #{rule.fetch('name')}", index] }, label: t("ルール"), value: @coloring_index)
+            .on_change { |value, *_| @coloring_index = value; coloring_dialog }.test_id("vk.coloring.rule"))
+          rule = rules[@coloring_index]
+          content.child(Zaniah::UI::TextField.new(rule.fetch("name"), label: t("名前")).on_change { |value, *_| rule["name"] = value }.test_id("vk.coloring.name"))
+          content.child(Zaniah::UI::TextField.new(rule.fetch("filter"), label: t("表示フィルタ")).on_change { |value, *_| rule["filter"] = value }.test_id("vk.coloring.filter"))
+          content.child(Zaniah::UI::Checkbox.new(t("有効"), value: rule.fetch("enabled")).on_change { |value, *_| rule["enabled"] = value })
+          %w[light dark].each do |theme|
+            content.child(Zaniah::Div.new.flex_row.gap(12).children(%w[fg bg].map do |key|
+              label = t("%{theme} %{part}", theme: t(theme == "light" ? "ライト" : "ダーク"), part: t(key == "fg" ? "文字" : "背景"))
+              Zaniah::UI::ColorPicker.new(rule.fetch(theme).fetch(key), label: label).on_change { |value, *_| rule.fetch(theme)[key] = value }.flex_1
+            end))
+          end
+          content.child(Zaniah::Div.new.flex_row.gap(8)
+            .child(Zaniah::UI::Button.new(t("上へ移動"), variant: :secondary).disabled(@coloring_index.zero?).on_click { move_coloring_rule(-1) })
+            .child(Zaniah::UI::Button.new(t("下へ移動"), variant: :secondary).disabled(@coloring_index == rules.size - 1).on_click { move_coloring_rule(1) })
+            .child(Zaniah::UI::Button.new(t("削除"), variant: :secondary).on_click { rules.delete_at(@coloring_index); coloring_dialog }))
+        end
+        content.child(Zaniah::Div.new.flex_row.gap(8)
+          .child(Zaniah::UI::Button.new(t("追加"), variant: :secondary).on_click do
+            rules << {"name" => t("新しいルール"), "filter" => "tcp", "enabled" => true, "light" => {"fg" => "#12272E", "bg" => "#E7E6FF"}, "dark" => {"fg" => "#E7E6FF", "bg" => "#24233A"}}
+            @coloring_index = rules.size - 1
+            coloring_dialog
+          end)
+          .child(Zaniah::UI::Button.new(t("インポート"), variant: :secondary).on_click { import_coloring_rules })
+          .child(Zaniah::UI::Button.new(t("エクスポート"), variant: :secondary).on_click { export_coloring_rules }))
+        content.child(Zaniah::Div.new.flex_row.gap(8)
+          .child(Zaniah::UI::Button.new(t("適用")).test_id("vk.coloring.apply").on_click do
+            replace_coloring_rules(@coloring_draft)
+            @coloring_draft = nil
+            dismiss_dialog
+          rescue StandardError => error
+            show_error(error)
+          end)
+          .child(Zaniah::UI::Button.new(t("キャンセル"), variant: :secondary).on_click { @coloring_draft = nil; dismiss_dialog }))
+        viewport = Zaniah::ScrollView.new.h([(@window.content_size.height * 0.9) - 100, 120].max).child(content)
+        show_dialog(:coloring, t("色付けルール"), viewport, reopen: -> { coloring_dialog })
+      end
+
+      def import_coloring_rules
+        path_dialog(t("色付けルールの読み込み先")) do |path|
+          @coloring_draft = Core::Coloring::RuleSet.load(path, catalog: document&.catalog).to_h
+          @coloring_index = 0
+          coloring_dialog
+        end
+      end
+      def export_coloring_rules
+        path_dialog(t("色付けルールの保存先")) do |path|
+          Core::Coloring::RuleSet.new(@coloring_draft || coloring_rules.to_h, catalog: document&.catalog).save(path)
+          coloring_dialog
+        end
+      end
+
+      private
+      def load_coloring_rules
+        path = File.join(@preferences.directory, "coloring_rules.yml")
+        File.file?(path) ? Core::Coloring::RuleSet.load(path, catalog: document&.catalog) : Core::Coloring::RuleSet.defaults(catalog: document&.catalog)
+      rescue Vanken::ConfigError => error
+        show_error(error)
+        Core::Coloring::RuleSet.defaults(catalog: document&.catalog)
+      end
+      def move_coloring_rule(delta)
+        rules = @coloring_draft.fetch("rules")
+        target = @coloring_index + delta
+        rules[@coloring_index], rules[target] = rules[target], rules[@coloring_index]
+        @coloring_index = target
+        coloring_dialog
+      end
+    end
+  end
+end

data/lib/vanken/ui/column_operations.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "../config/columns"
+
+module Vanken
+  module UI
+    module ColumnOperations
+      def column_settings
+        if !@column_settings || @columns_directory != @preferences.directory
+          @columns_directory = @preferences.directory
+          @column_settings = Config::Columns.load(directory: @columns_directory, legacy: @preferences.get("layout.columns"))
+        end
+        @column_settings
+      rescue ConfigError => error
+        show_error(error)
+        @column_settings = Config::Columns.new
+      end
+
+      def reload_columns
+        @column_settings = nil
+        column_settings
+        configure_document_columns
+      end
+
+      def configure_document_columns
+        document.custom_columns = column_settings.custom if document
+        @packet_source.reset
+      end
+
+      def persist_columns_layout(items)
+        column_settings.update_layout(items)
+        column_settings.save(@preferences.directory)
+        configure_document_columns
+      rescue StandardError => error
+        show_error(error)
+      end
+
+      def add_field_column(field, label: field, width: 120)
+        if document && !Core::DisplayFilter::FieldResolver.new(document.catalog).resolve(field).known
+          raise Vanken::ConfigError, "unknown field: #{field}"
+        end
+        key = column_settings.add(field, label: label, width: width)
+        apply_columns
+        key
+      end
+
+      def remove_column(key)
+        column_settings.remove(key)
+        apply_columns
+      end
+
+      def field_menu(node)
+        menu = selection_menu(node.filter)
+        return menu unless node.field
+        @app.actions.register(:context_apply_column, title: column_text("列として適用")) { add_field_column(node.field) }
+        added = Zaniah::Menu.build { item(:context_apply_column) }
+        Zaniah::Menu.new(menu.items + added.items)
+      end
+
+      def columns_dialog
+        rows = Zaniah::Div.new.flex_col.gap(6)
+        @table.columns.each_with_index do |column, index|
+          key = column[:key]
+          width = Zaniah::UI::NumberInput.new(column[:width], min: 40, max: 4096, step: 8, label: column_text("幅"))
+            .w(100).test_id("vk.columns.width.#{key}")
+          width.on_change do |*_|
+            amount = width.number
+            if amount && amount.finite? && amount.between?(40, 4096)
+              width.status(:none)
+              @table.resize_column(key, amount)
+            else
+              width.status(:error, message: column_text("幅は40から4096の範囲で指定してください"))
+            end
+          end
+          row = Zaniah::Div.new.flex_row.items_center.gap(6)
+            .child(Zaniah::UI::Checkbox.new(column[:label], value: column[:visible]).flex_1
+              .on_change { |value, *_| @table.column_visible(key, value) })
+            .child(width)
+            .child(Zaniah::UI::Button.new(column_text("上へ移動"), size: :sm).disabled(index.zero?).on_click { @table.move_column(key, index - 1); columns_dialog })
+            .child(Zaniah::UI::Button.new(column_text("下へ移動"), size: :sm).disabled(index == @table.columns.size - 1).on_click { @table.move_column(key, index + 1); columns_dialog })
+          row.child(Zaniah::UI::Button.new(column_text("削除"), size: :sm).on_click { remove_column(key); columns_dialog }) if key.to_s.start_with?("field:")
+          rows.child(row)
+        end
+        field = Zaniah::UI::TextField.new("", label: column_text("フィールド名")).test_id("vk.columns.field")
+        label = Zaniah::UI::TextField.new("", label: column_text("列名 (空欄: フィールド名)")).test_id("vk.columns.label")
+        content = Zaniah::Div.new.flex_col.gap(8)
+          .child(Zaniah::ScrollView.new.h(280).child(rows)).child(field).child(label)
+          .child(Zaniah::UI::Button.new(column_text("追加")).test_id("vk.columns.add").on_click do
+            name = field.value.strip
+            add_field_column(name, label: label.value.empty? ? name : label.value)
+            columns_dialog
+          rescue StandardError => error
+            show_error(error)
+          end)
+        show_dialog(:columns, column_text("表示する列"), content, reopen: -> { columns_dialog })
+      end
+
+      private
+
+      def column_text(text) = respond_to?(:t) ? t(text) : text
+
+      def apply_columns
+        column_settings.save(@preferences.directory)
+        configure_document_columns
+        selected = selected_number
+        rebuild_view
+        index = document&.displayed_index(selected)
+        if index
+          @table.select(index)
+          @table.scroll_to(index, align: :nearest)
+        end
+      end
+    end
+  end
+end

data/lib/vanken/ui/dialogs.rb

@@ -5,18 +5,23 @@ module Vanken
     module Dialogs
       def dialog = @dialog
       def dismiss_dialog
+        close_analysis if respond_to?(:close_analysis)
         @dialog&.close
-        @dialog = @dialog_kind = @pending_destructive = nil
+        @dialog = @dialog_kind = @pending_destructive = @dialog_reopen = nil
         @window.request_frame
       end
-      def show_dialog(kind, title, content)
+      def reopen_dialog
+        @dialog_reopen&.call
+      end
+      def show_dialog(kind, title, content, reopen: nil)
         dismiss_dialog
         @dialog_kind = kind
-        @dialog = Zaniah::UI::Dialog.new(content, title: title).on_close { dismiss_dialog }.test_id("vk.#{kind}")
+        @dialog_reopen = reopen
+        @dialog = Zaniah::UI::Dialog.new(content, title: title, close_label: t("閉じる")).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")
+      def path_dialog(title, value: "", &operation)
+        field = Zaniah::UI::TextField.new(value, label: t(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
@@ -25,32 +30,42 @@ module Vanken
             rescue StandardError => error
               show_error(error)
             end)
-            .child(Zaniah::UI::Button.new("キャンセル", variant: :secondary).on_click { dismiss_dialog }))
-        show_dialog(:path, title, content)
+            .child(Zaniah::UI::Button.new(t("キャンセル"), variant: :secondary).on_click { dismiss_dialog }))
+        show_dialog(:path, t(title), content, reopen: -> { path_dialog(title, value: field.value, &operation) })
       end
-      def capture_options(interface: nil)
+      def capture_options(interface: nil, values: {})
         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 = Zaniah::UI::Select.new(choices, label: t("インタフェース"), 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)
+        [["filter", t("キャプチャフィルタ (BPF)"), ""], ["snaplen", "Snaplen", @preferences.get("capture.snaplen").to_s],
+          ["buffer_size", t("バッファサイズ (bytes)"), @preferences.get("capture.buffer_size").to_s]].each do |key, label, value|
+          fields[key] = Zaniah::UI::TextField.new(values.fetch(key, value), label: label)
           content.child(fields[key])
         end
-        promiscuous = Zaniah::UI::Checkbox.new("プロミスキャスモード", value: @preferences.get("capture.promiscuous"))
+        advanced = Zaniah::Div.new.flex_col.gap(6)
+        {"stop_count" => t("停止件数 (0: 無制限)"), "stop_duration" => t("停止までの秒数 (0: 無制限)"), "stop_bytes" => t("停止サイズ (bytes、0: 無制限)"),
+          "ring_path" => t("リング保存先 (空欄: 保存しない)"), "ring_max_bytes" => t("リングファイル上限 (bytes)"), "ring_interval" => t("リング切替間隔 (秒)"), "ring_file_count" => t("リングファイル数")}.each do |key, label|
+          fields[key] = Zaniah::UI::TextField.new(values.fetch(key, @preferences.get("capture.#{key}").to_s), label: label).test_id("vk.capture.#{key}")
+          advanced.child(fields[key])
+        end
+        content.child(Zaniah::ScrollView.new.h(160).child(advanced))
+        promiscuous = Zaniah::UI::Checkbox.new(t("プロミスキャスモード"), value: values.fetch("promiscuous", @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)
+        direction = values.fetch("direction", @preferences.get("capture.direction"))
+        content.child(Zaniah::UI::Select.new([[t("送受信"), "inout"], [t("受信"), "in"], [t("送信"), "out"]], label: t("方向"), value: direction).on_change { |value, *_| direction = value })
+        status = Zaniah::UI::Label.new(infos.empty? ? (@interface_error || t("インタフェースを取得中です。")) : t("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
+        content.child(Zaniah::UI::Button.new(t("開始")).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")}
+          %w[stop_count stop_bytes ring_max_bytes ring_file_count].each { |key| options[key] = Integer(fields.fetch(key).value, 10) }
+          %w[stop_duration ring_interval].each { |key| options[key] = Float(fields.fetch(key).value) }
+          options["ring_path"] = fields.fetch("ring_path").value
           # Compilation and privileged helper startup both happen away from the UI thread.
           @app.executor.background do
             metadata = infos.find { |item| item[:name] == selected }
@@ -62,27 +77,27 @@ module Vanken
         rescue ArgumentError => error
           show_error(error)
         end)
-        show_dialog(:capture_options, "キャプチャオプション", content)
+        show_dialog(:capture_options, t("キャプチャオプション"), content, reopen: -> { capture_options(interface: selected, values: fields.transform_values(&:value).merge("promiscuous" => promiscuous.value, "direction" => direction)) })
       end
       def preferences_dialog
-        theme = Zaniah::UI::Select.new(%w[system dark light high_contrast], label: "テーマ", value: @preferences.get("appearance.theme"))
+        theme = Zaniah::UI::Select.new({"システム設定" => "system", "ダーク" => "dark", "ライト" => "light", "ハイコントラスト" => "high_contrast"}.map { |label, value| [t(label), value] }, label: t("テーマ"), 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"))
+        time = Zaniah::UI::Select.new({"相対時刻" => "relative", "絶対時刻" => "absolute", "前パケットとの差" => "delta", "前表示パケットとの差" => "delta_displayed", "エポック時刻" => "epoch"}.map { |label, value| [t(label), value] }, label: t("時刻表示"), 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)
+          .child(Zaniah::Div.new.flex_row.gap(8).child(Zaniah::UI::Button.new(t("文字を小さく")).on_click { zoom(-1) })
+            .child(Zaniah::UI::Button.new(t("文字を大きく")).on_click { zoom(1) }))
+        show_dialog(:preferences, t("設定"), content, reopen: -> { preferences_dialog })
       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 }))
+            .child(Zaniah::UI::Button.new(t("上へ移動"), size: :sm).disabled(index.zero?).on_click { @table.move_column(column[:key], index - 1); columns_dialog })
+            .child(Zaniah::UI::Button.new(t("下へ移動"), size: :sm).disabled(index == @table.columns.size - 1).on_click { @table.move_column(column[:key], index + 1); columns_dialog }))
         end
-        show_dialog(:columns, "表示する列", content)
+        show_dialog(:columns, t("表示する列"), content, reopen: -> { columns_dialog })
       end
     end
   end