//! UI state, bounded selections and rendering widget storage. use color_eyre::Result; use ratatui::{ style::Color, widgets::{LineGauge, List, ListState}, }; use serialport::SerialPortInfo; use std::path::PathBuf; use strum::EnumCount; use strum::FromRepr; use crate::{ error::{AppError, UiError}, scan::{LiveState, ScanState}, }; use tiny_wb::{config::Config, protocol::ScanRequest}; /// Color of a selected border pub(crate) const SELECTED_COLOR: Color = Color::White; /// Color of an unselected item pub(crate) const UNSELECTED_COLOR: Color = Color::DarkGray; /// This struct holds the current state of the app. #[derive(Debug)] pub(crate) struct App { /// Whether the user requested exit. pub(crate) should_quit: bool, /// Selectable baud rates. pub(crate) baudrate: BaudRateList, /// Enumerated serial ports. pub(crate) port_list: PortList, /// Current screen and focused field. pub(crate) flow_state: AppState, /// Cached widgets rebuilt during screen initialization. pub(crate) menu_items: MenuItems, /// Application version shown above the controls. pub(crate) status_message: String, /// Requested start frequency, in MHz. pub(crate) start_frequency: NumericInput, /// Requested stop frequency, in MHz. pub(crate) stop_frequency: NumericInput, /// Requested number of samples. pub(crate) points: NumericInput, /// Measurements per point. pub(crate) repeat: NumericInput, /// Shared acquisition telemetry; request settings are passed separately. pub(crate) scan_state: ScanState, /// Shared repeated-snapshot state used only by `--live` sessions. pub(crate) live_state: LiveState, /// Whether scans launched from the settings screen should run continuously. pub(crate) live_enabled: bool, /// Last live generation copied into the plot. pub(crate) live_generation: u64, /// Whether the UI should exit after live recovery and final export. pub(crate) live_exit_requested: bool, /// Whether the plot overlays the strongest sample in the visible frequency range. pub(crate) show_peak_info: bool, /// Validated settings retained when the selection is saved. pub(crate) config: Config, /// Explicit settings path selected at startup. pub(crate) config_path: PathBuf, /// Last launched request and settings, retained for one-key repetition. pub(crate) last_scan: Option<(ScanRequest, Config)>, /// Whether this session may acquire, as opposed to viewing a standalone CSV. pub(crate) can_acquire: bool, /// Plot currently shown by the renderer; a collection boundary for future tabs. pub(crate) plot: Option, } /// One named plot and its independently navigable frequency viewport. #[derive(Debug)] pub(crate) struct Plot { /// User-facing source name. pub(crate) label: String, /// Samples in MHz and dBm, ordered by frequency. pub(crate) data: Vec<(f64, f64)>, /// Current and complete horizontal bounds. pub(crate) viewport: FrequencyViewport, } impl Plot { /// Construct a plot whose initial viewport contains all samples. pub(crate) fn new(label: impl Into, data: Vec<(f64, f64)>) -> Self { let viewport = FrequencyViewport::from_samples(&data); Self { label: label.into(), data, viewport, } } /// Replace samples without resetting a compatible live viewport. pub(crate) fn replace_data(&mut self, label: impl Into, data: Vec<(f64, f64)>) { let replacement = FrequencyViewport::from_samples(&data); if self.viewport.full_min != replacement.full_min || self.viewport.full_max != replacement.full_max { self.viewport = replacement; } self.label = label.into(); self.data = data; } /// Return the strongest sample inside the current horizontal viewport. pub(crate) fn visible_peak(&self) -> Option<(f64, f64)> { let [minimum, maximum] = self.viewport.bounds(); self.data .iter() .copied() .filter(|(frequency, _)| (minimum..=maximum).contains(frequency)) .reduce(|peak, sample| if sample.1 > peak.1 { sample } else { peak }) } } /// Horizontal chart bounds with zoom and pan clamped to the source data. #[derive(Debug, Clone, Copy, PartialEq)] pub(crate) struct FrequencyViewport { /// Complete lower bound, in MHz. full_min: f64, /// Complete upper bound, in MHz. full_max: f64, /// Visible lower bound, in MHz. visible_min: f64, /// Visible upper bound, in MHz. visible_max: f64, /// Smallest permitted visible span. min_span: f64, } impl FrequencyViewport { /// Derive safe increasing chart bounds from an ordered sample set. fn from_samples(samples: &[(f64, f64)]) -> Self { let first = samples.first().map_or(0.0, |sample| sample.0); let last = samples.last().map_or(first, |sample| sample.0); let (full_min, full_max) = if first < last { (first, last) } else { let padding = (first.abs() * 1e-6).max(0.001); (first - padding, first + padding) }; let span = full_max - full_min; let sample_spacing = samples .windows(2) .filter_map(|pair| { let spacing = pair[1].0 - pair[0].0; (spacing > 0.0).then_some(spacing) }) .min_by(f64::total_cmp); Self { full_min, full_max, visible_min: full_min, visible_max: full_max, min_span: sample_spacing.unwrap_or(span).min(span).max(f64::EPSILON), } } /// Current `[minimum, maximum]` bounds in MHz. pub(crate) fn bounds(self) -> [f64; 2] { [self.visible_min, self.visible_max] } /// Halve the visible span around its center, down to the resolution floor. pub(crate) fn zoom_in(&mut self) { self.set_span(((self.visible_max - self.visible_min) / 2.0).max(self.min_span)); } /// Double the visible span around its center, up to the complete range. pub(crate) fn zoom_out(&mut self) { self.set_span(((self.visible_max - self.visible_min) * 2.0).min(self.full_span())); } /// Move by one quarter of the visible span and clamp at the data edge. pub(crate) fn pan(&mut self, direction: InputDirection) { let span = self.visible_max - self.visible_min; let shift = match direction { InputDirection::Left => -span / 4.0, InputDirection::Right => span / 4.0, _ => return, }; let new_min = (self.visible_min + shift).clamp(self.full_min, self.full_max - span); self.visible_min = new_min; self.visible_max = new_min + span; } /// Restore the complete source range. pub(crate) fn reset(&mut self) { self.visible_min = self.full_min; self.visible_max = self.full_max; } /// Update the visible span while retaining the current center when possible. fn set_span(&mut self, span: f64) { let span = span.clamp(self.min_span, self.full_span()); let center = (self.visible_min + self.visible_max) / 2.0; let new_min = (center - span / 2.0).clamp(self.full_min, self.full_max - span); self.visible_min = new_min; self.visible_max = new_min + span; } /// Width of the complete frequency range. fn full_span(self) -> f64 { self.full_max - self.full_min } } #[derive(Debug)] /// Numeric input state with bounded keyboard increments. pub(crate) struct NumericInput { /// Current bounded value. value: usize, /// Keyboard increment. increment: usize, /// Inclusive lower bound. min_clamp: usize, /// Inclusive upper bound. max_clamp: usize, /// Digits being entered directly; `None` retains step-based behavior. edit_buffer: Option, /// Whether the current buffer failed bounds or integer validation. invalid_edit: bool, } impl NumericInput { /// Change the value depending on selection pub(crate) fn change_value(&mut self, direction: InputDirection) { match direction { InputDirection::Up => { self.value = self .value .saturating_add(self.increment) .clamp(self.min_clamp, self.max_clamp) } InputDirection::Down => { self.value = self .value .saturating_sub(self.increment) .clamp(self.min_clamp, self.max_clamp) } _ => (), } } /// Create bounded input, clamping a supplied value to validated bounds. pub(crate) fn new(value: usize, increment: usize, min_clamp: usize, max_clamp: usize) -> Self { Self { value: value.clamp(min_clamp, max_clamp), increment, max_clamp, min_clamp, edit_buffer: None, invalid_edit: false, } } /// Read the current value. pub(crate) fn value(&self) -> usize { self.value } /// Start or extend direct decimal entry without changing the committed value. pub(crate) fn push_digit(&mut self, digit: char) { if !digit.is_ascii_digit() { return; } let buffer = self.edit_buffer.get_or_insert_with(String::new); if buffer.len() < 20 { buffer.push(digit); } self.invalid_edit = false; } /// Remove the last typed digit while retaining edit mode. pub(crate) fn backspace(&mut self) { if let Some(buffer) = self.edit_buffer.as_mut() { buffer.pop(); self.invalid_edit = false; } } /// Commit direct entry when it is an integer inside the field's bounds. pub(crate) fn commit_edit(&mut self) -> bool { let parsed = self .edit_buffer .as_deref() .filter(|buffer| !buffer.is_empty()) .and_then(|buffer| buffer.parse::().ok()); if let Some(value) = parsed.filter(|value| (self.min_clamp..=self.max_clamp).contains(value)) { self.value = value; self.edit_buffer = None; self.invalid_edit = false; true } else { self.invalid_edit = true; false } } /// Abandon direct entry and restore the previously committed value. pub(crate) fn cancel_edit(&mut self) { self.edit_buffer = None; self.invalid_edit = false; } /// Whether keystrokes currently belong to the inline editor. pub(crate) fn is_editing(&self) -> bool { self.edit_buffer.is_some() } } #[derive(Debug)] /// The inner state of the app, useful for display and keystrokes pub(crate) enum AppState { /// Initial config, baudrate and port SelectingConnection(SelectedConnection), /// Final config, frequencies and points SelectingScan(SelectedScan), /// The end window for confirmation Complete, /// Acquisition and export progress. Scanning, /// Repeated complete snapshots displayed while acquisition continues. Live, /// Error window Error, } impl Default for AppState { fn default() -> Self { Self::SelectingConnection(SelectedConnection::default()) } } /// The selected item in the config #[derive(Debug, Default, EnumCount, FromRepr, Clone, Copy)] pub(crate) enum SelectedConnection { /// Selects the ports #[default] Port, /// Selects the baudrate Baudrate, } /// The selected item in the final menu #[derive(Debug, Default, EnumCount, FromRepr, Copy, Clone)] pub(crate) enum SelectedScan { /// Selects the start frequency #[default] StartFreq, /// Selects the final frequency FinalFreq, /// Selects the number of points Points, /// Selects the repeat Repeat, } /// Configured baud rates and their selected index. #[derive(Debug)] pub(crate) struct BaudRateList { /// Choices loaded from validated settings. pub(crate) baudrates: Vec, /// Selection state used by Ratatui. pub(crate) state: ListState, } impl BaudRateList { /// Construct choices with the configured rate selected. pub(crate) fn new(config: &Config) -> Self { Self { baudrates: config.serial.baudrates.clone(), state: ListState::default().with_selected( config .serial .baudrates .iter() .position(|rate| *rate == config.baudrate), ), } } /// Format values for the list widget. pub(crate) fn to_vecstr(&self) -> Vec { self.baudrates.iter().map(u32::to_string).collect() } /// Move without selecting an index beyond the configured choices. pub(crate) fn change_cursor(&mut self, direction: InputDirection) { move_list_selection(&mut self.state, self.baudrates.len(), direction); } /// Resolve the selected value safely even if the list changed. pub(crate) fn selected_baudrate(&self) -> Result { self.state .selected() .and_then(|index| self.baudrates.get(index)) .copied() .ok_or(UiError::MenuSelection) } } /// A wrapper over the list of ports #[derive(Debug)] pub(crate) struct PortList { /// The list of found ports pub(crate) ports: Vec, /// The inner state of the widget pub(crate) state: ListState, } impl PortList { /// Make a port list from a serial reading pub(crate) fn from_serial(info: Vec, config: &Config) -> Self { let ports: Vec = info.into_iter().map(|port| port.port_name).collect(); let selected = find_best_port(&ports, config); Self { ports, state: ListState::default().with_selected(selected), } } /// Convert the list of ports pub(crate) fn to_vecstr(&self) -> Vec { self.ports.clone() } /// Change the selected item pub(crate) fn change_cursor(&mut self, direction: InputDirection) { move_list_selection(&mut self.state, self.ports.len(), direction); } /// Returns the final selected port pub(crate) fn selected_port(&self) -> Result { self.state .selected() .and_then(|index| self.ports.get(index)) .cloned() .ok_or(UiError::NoPortSelected) } } #[derive(Debug, Default)] /// Cached widgets; none borrow mutable application data. pub(crate) struct MenuItems { /// Cached list widget. pub(crate) portlist: Option>, /// Cached list widget. pub(crate) baudlist: Option>, /// The progress bar pub(crate) progress_bar: Option>, } /// Prefer the saved device, then configured candidates, then the first port. fn find_best_port(ports: &[String], config: &Config) -> Option { std::iter::once(&config.port) .chain(config.serial.preferred_ports.iter()) .find_map(|candidate| ports.iter().position(|port| port == candidate)) .or_else(|| (!ports.is_empty()).then_some(0)) } /// Keep selection valid without relying on a later draw to clamp its index. fn move_list_selection(state: &mut ListState, length: usize, direction: InputDirection) { if length == 0 { state.select(None); return; } let current = state.selected().unwrap_or(0).min(length - 1); let next = match direction { InputDirection::Up => current.saturating_sub(1), InputDirection::Down => current.saturating_add(1).min(length - 1), _ => current, }; state.select(Some(next)); } impl App { /// Build validated settings from the current selection, preserving all sections. pub(crate) fn selected_config(&self) -> Result { let config = Config { port: self.port_list.selected_port()?, baudrate: self.baudrate.selected_baudrate()?, start_frequency: self.start_frequency.value(), stop_frequency: self.stop_frequency.value(), points: self.points.value(), repeat: self.repeat.value(), ..self.config.clone() }; config.validate().map_err(AppError::from)?; Ok(config) } } /// Navigation intent independent of terminal key codes. #[derive(Debug, Clone, Copy)] pub(crate) enum InputDirection { /// Increase a numeric value or move toward the first list item. Up, /// Increase a list index or decrease a numeric value. Down, /// Select the next field. Right, /// Select the previous field. Left, } impl std::fmt::Display for NumericInput { fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { if let Some(buffer) = &self.edit_buffer { if self.invalid_edit { write!( formatter, "{}_ (enter {}–{})", buffer, self.min_clamp, self.max_clamp ) } else if buffer.is_empty() { formatter.write_str("_") } else { write!(formatter, "{buffer}_") } } else { self.value.fmt(formatter) } } } #[cfg(test)] mod tests { use super::*; #[test] fn numeric_input_clamps_and_saturates_without_overflow() { let mut field = NumericInput::new(999, 10, 0, 100); assert_eq!(field.value(), 100); field.change_value(InputDirection::Up); assert_eq!(field.value(), 100); field.change_value(InputDirection::Down); assert_eq!(field.value(), 90); let mut field = NumericInput::new(usize::MAX - 1, 10, 0, usize::MAX); field.change_value(InputDirection::Up); assert_eq!(field.value(), usize::MAX); let mut field = NumericInput::new(1, 10, 0, 100); field.change_value(InputDirection::Down); assert_eq!(field.value(), 0); } #[test] fn numeric_input_edits_commits_and_cancels_typed_values() { let mut field = NumericInput::new(240, 10, 0, 5_400); for digit in "1234".chars() { field.push_digit(digit); } assert!(field.is_editing()); assert_eq!(field.to_string(), "1234_"); assert!(field.commit_edit()); assert_eq!(field.value(), 1234); for digit in "9999".chars() { field.push_digit(digit); } assert!(!field.commit_edit()); assert_eq!(field.value(), 1234); assert!(field.to_string().contains("enter 0–5400")); field.backspace(); field.cancel_edit(); assert_eq!(field.to_string(), "1234"); } #[test] fn viewport_zooms_pans_clamps_and_resets() { let mut viewport = FrequencyViewport::from_samples(&[ (100.0, -1.0), (125.0, -1.5), (150.0, -2.0), (175.0, -1.5), (200.0, -1.0), ]); assert_eq!(viewport.bounds(), [100.0, 200.0]); viewport.zoom_in(); assert_eq!(viewport.bounds(), [125.0, 175.0]); viewport.pan(InputDirection::Right); assert_eq!(viewport.bounds(), [137.5, 187.5]); for _ in 0..20 { viewport.pan(InputDirection::Right); } assert_eq!(viewport.bounds(), [150.0, 200.0]); viewport.zoom_out(); assert_eq!(viewport.bounds(), [100.0, 200.0]); viewport.reset(); assert_eq!(viewport.bounds(), [100.0, 200.0]); } #[test] fn maximum_zoom_uses_the_finest_positive_sample_spacing() { let mut viewport = FrequencyViewport::from_samples(&[ (100.0, -1.0), (100.0, -2.0), (100.01, -3.0), (100.02, -4.0), (200.0, -5.0), ]); for _ in 0..32 { viewport.zoom_in(); } let [minimum, maximum] = viewport.bounds(); assert!(((maximum - minimum) - 0.01).abs() < 1e-12); } #[test] fn viewport_for_one_sample_still_has_increasing_bounds() { let viewport = FrequencyViewport::from_samples(&[(240.0, -64.0)]); let [minimum, maximum] = viewport.bounds(); assert!(minimum < 240.0 && maximum > 240.0); } #[test] fn visible_peak_tracks_the_zoomed_and_panned_viewport() { let mut plot = Plot::new( "test", vec![ (100.0, -30.0), (125.0, -10.0), (150.0, -20.0), (200.0, -5.0), ], ); assert_eq!(plot.visible_peak(), Some((200.0, -5.0))); plot.viewport.zoom_in(); assert_eq!(plot.visible_peak(), Some((125.0, -10.0))); plot.viewport.pan(InputDirection::Right); assert_eq!(plot.visible_peak(), Some((150.0, -20.0))); } #[test] fn empty_and_stale_port_selections_return_errors() { let mut list = PortList::from_serial(Vec::new(), &Config::default()); list.change_cursor(InputDirection::Down); assert!(list.state.selected().is_none()); assert!(matches!(list.selected_port(), Err(UiError::NoPortSelected))); list.state.select(Some(100)); assert!(list.selected_port().is_err()); } #[test] fn saved_port_precedes_preferences_and_unavailable_ports_fall_back() { let mut config = Config::default(); let ports = vec!["other".into(), "COM3".into(), "saved".into()]; assert_eq!(find_best_port(&ports, &config), Some(1)); config.port = "saved".into(); assert_eq!(find_best_port(&ports, &config), Some(2)); assert_eq!(find_best_port(&["other".into()], &config), Some(0)); assert_eq!(find_best_port(&[], &config), None); } #[test] fn custom_baud_choices_are_bounded_before_rendering() { let config = Config::from_toml("baudrate = 9600\n[serial]\nbaudrates = [9600, 19200]").unwrap(); let mut list = BaudRateList::new(&config); assert_eq!(list.selected_baudrate().unwrap(), 9600); for _ in 0..100 { list.change_cursor(InputDirection::Down); } assert_eq!(list.selected_baudrate().unwrap(), 19200); for _ in 0..100 { list.change_cursor(InputDirection::Up); } assert_eq!(list.selected_baudrate().unwrap(), 9600); } }