fallensigh/xserial
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: remove pipeview-tui from workspace

Browse Source
This commit is contained in:
FallenSigh
2026-08-17 20:23:41 +08:00
parent f9be74257a
commit 81c0ce13c4
11 changed files with 50 additions and 5058 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1122
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

12
Cargo.toml
View File

@@ -3,7 +3,6 @@ resolver = "2"
members = [ members = [
"crates/pipeview-core", "crates/pipeview-core",
"crates/pipeview-client", "crates/pipeview-client",
"crates/pipeview-tui",
"crates/pipeview-gui", "crates/pipeview-gui",
] ]
@@ -30,21 +29,10 @@ thiserror = "2"
# ── 日志 ── # ── 日志 ──
tracing = "0.1" tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] } tracing-subscriber = { version = "0.3", features = ["env-filter"] }
tracing-appender = "0.2"
# ── 工具 ── # ── 工具 ──
hex = "0.4" hex = "0.4"
# ── 图像 ──
image = { version = "0.25", default-features = false, features = ["png"] }
# ── CLI ──
clap = { version = "4", features = ["derive"] }
# ── TUI ──
ratatui = "0.30"
crossterm = "0.28"
# ── GUI ── # ── GUI ──
egui = "0.34" egui = "0.34"
eframe = "0.34" eframe = "0.34"

6
README.md
View File

@@ -277,7 +277,7 @@ return {
``` ```
┌──────────────────────────────────────────────────┐ ┌──────────────────────────────────────────────────┐
│ pipeview-gui (egui) pipeview-tui (ratatui) │ │ pipeview-gui (egui) │
├──────────────────────────────────────────────────┤ ├──────────────────────────────────────────────────┤
│ pipeview-client │ │ pipeview-client │
│ SessionManager · Session · Config · History │ │ SessionManager · Session · Config · History │
@@ -293,9 +293,8 @@ return {
| `pipeview-core` | library | 传输层（Serial/TCP/UDP）、分帧器（Line/Fixed/Length/COBS/Mixed/Lua）、协议解码器（Text/Hex/Plot）、MultiPipeline | | `pipeview-core` | library | 传输层（Serial/TCP/UDP）、分帧器（Line/Fixed/Length/COBS/Mixed/Lua）、协议解码器（Text/Hex/Plot）、MultiPipeline |
| `pipeview-client` | library | Session 生命周期管理、SessionManager、事件广播（tokio broadcast）、RingBuffer 历史、Lua 运行时及会话 API | | `pipeview-client` | library | Session 生命周期管理、SessionManager、事件广播（tokio broadcast）、RingBuffer 历史、Lua 运行时及会话 API |
| `pipeview-gui` | binary | egui 桌面应用，包含 sidebar/config/console/text/hex/plot 面板、键盘快捷键、字体管理、性能分析 | | `pipeview-gui` | binary | egui 桌面应用，包含 sidebar/config/console/text/hex/plot 面板、键盘快捷键、字体管理、性能分析 |
| `pipeview-tui` | binary | ratatui 终端应用（功能未对齐 GUI，仍在开发中） |
**依赖方向：** `core ← client ← {gui, tui}` **依赖方向：** `core ← client ← gui`
**数据流：** **数据流：**
@@ -365,7 +364,6 @@ crates/
pipeview-core/ # 传输、分帧、协议 pipeview-core/ # 传输、分帧、协议
pipeview-client/ # 会话管理、Lua 运行时 pipeview-client/ # 会话管理、Lua 运行时
pipeview-gui/ # egui 桌面应用 pipeview-gui/ # egui 桌面应用
pipeview-tui/ # ratatui 终端应用
examples/ # Lua 脚本示例 examples/ # Lua 脚本示例
drone_plot.lua # 飞控遥测波形解码器 drone_plot.lua # 飞控遥测波形解码器
drone_text.lua # 飞控遥测文本解码器 drone_text.lua # 飞控遥测文本解码器

6
README_en.md
View File

@@ -265,7 +265,7 @@ More examples in `examples/`.
``` ```
┌──────────────────────────────────────────────────┐ ┌──────────────────────────────────────────────────┐
│ pipeview-gui (egui) pipeview-tui (ratatui) │ │ pipeview-gui (egui) │
├──────────────────────────────────────────────────┤ ├──────────────────────────────────────────────────┤
│ pipeview-client │ │ pipeview-client │
│ SessionManager · Session · Config · History │ │ SessionManager · Session · Config · History │
@@ -281,9 +281,8 @@ More examples in `examples/`.
| `pipeview-core` | library | Transport (Serial/TCP/UDP), framers (Line/Fixed/Length/COBS/Mixed/Lua), decoders (Text/Hex/Plot), MultiPipeline | | `pipeview-core` | library | Transport (Serial/TCP/UDP), framers (Line/Fixed/Length/COBS/Mixed/Lua), decoders (Text/Hex/Plot), MultiPipeline |
| `pipeview-client` | library | Session lifecycle, SessionManager, event broadcast (tokio broadcast), RingBuffer history, Lua runtime & session API | | `pipeview-client` | library | Session lifecycle, SessionManager, event broadcast (tokio broadcast), RingBuffer history, Lua runtime & session API |
| `pipeview-gui` | binary | egui desktop app: sidebar, config, console, text/hex/plot panels, keyboard shortcuts, font management, profiling | | `pipeview-gui` | binary | egui desktop app: sidebar, config, console, text/hex/plot panels, keyboard shortcuts, font management, profiling |
| `pipeview-tui` | binary | ratatui terminal app (feature-incomplete, under development) |
**Dependency flow:** `core ← client ← {gui, tui}` **Dependency flow:** `core ← client ← gui`
**Data flow:** **Data flow:**
@@ -349,7 +348,6 @@ crates/
pipeview-core/ # Transport, framing, protocol pipeview-core/ # Transport, framing, protocol
pipeview-client/ # Session management, Lua runtime pipeview-client/ # Session management, Lua runtime
pipeview-gui/ # egui desktop application pipeview-gui/ # egui desktop application
pipeview-tui/ # ratatui terminal application
examples/ # Lua script examples examples/ # Lua script examples
drone_plot.lua # Drone telemetry plot decoder drone_plot.lua # Drone telemetry plot decoder
drone_text.lua # Drone telemetry text decoder drone_text.lua # Drone telemetry text decoder

25
crates/pipeview-tui/Cargo.toml
View File

@@ -1,25 +0,0 @@
[package]
name = "pipeview-tui"
version = "0.1.0"
edition = "2024"
[[bin]]
name = "pipeview-tui"
path = "src/main.rs"
[dependencies]
pipeview-core = { path = "../pipeview-core" }
pipeview-client = { path = "../pipeview-client" }
tokio = { workspace = true }
ratatui = { workspace = true }
crossterm = { workspace = true }
tracing = { workspace = true }
tracing-subscriber = { workspace = true }
tracing-appender = { workspace = true }
clap = { workspace = true }
hex = { workspace = true }
image = { workspace = true }
mlua = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
ansitok = "0.3"

295
crates/pipeview-tui/src/ansi.rs
View File

@@ -1,295 +0,0 @@
use ansitok::{AnsiColor, ElementKind, VisualAttribute, parse_ansi, parse_ansi_sgr};
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::Span;
/// Parse ANSI-encoded text and return a Vec of styled Spans.
///
/// ANSI SGR sequences (colors, bold, italic, underline, strikethrough)
/// are converted to ratatui `Style` applied on top of `base_style`.
/// Non-SGR sequences (cursor movement, etc.) are silently ignored.
pub fn ansi_to_spans(text: &str, base_style: Style) -> Vec<Span<'static>> {
let mut spans = Vec::new();
let mut style = AnsiStyleStack::default();
for element in parse_ansi(text) {
match element.kind() {
ElementKind::Text => {
let slice = &text[element.start()..element.end()];
if !slice.is_empty() {
spans.push(Span::styled(
slice.to_string(),
style.merge(base_style),
));
}
}
ElementKind::Sgr => {
let sgr = &text[element.start()..element.end()];
apply_sgr_sequence(&mut style, sgr);
}
_ => {}
}
}
spans
}
/// Extract visible text from ANSI-encoded string (strips escape sequences).
///
/// This is the text that a user would actually see on a terminal —
/// useful for search, copy, and line counting.
pub fn ansi_visible_text(text: &str) -> String {
let mut visible = String::new();
for element in parse_ansi(text) {
if element.kind() == ElementKind::Text {
visible.push_str(&text[element.start()..element.end()]);
}
}
visible
}
// ── internal style stack ──
#[derive(Default, Clone)]
struct AnsiStyleStack {
fg: Option<Color>,
bg: Option<Color>,
bold: bool,
italic: bool,
underline: bool,
strikethrough: bool,
}
impl AnsiStyleStack {
fn apply_sgr_attr(&mut self, attr: VisualAttribute) {
match attr {
VisualAttribute::Reset(0) => *self = Self::default(),
VisualAttribute::Reset(22) => self.bold = false,
VisualAttribute::Reset(23) => self.italic = false,
VisualAttribute::Reset(24) => self.underline = false,
VisualAttribute::Reset(29) => self.strikethrough = false,
VisualAttribute::Reset(39) => self.fg = None,
VisualAttribute::Reset(49) => self.bg = None,
VisualAttribute::Reset(_) => {}
VisualAttribute::Bold => self.bold = true,
VisualAttribute::Faint => self.bold = false,
VisualAttribute::Italic => self.italic = true,
VisualAttribute::Underline => self.underline = true,
VisualAttribute::Crossedout => self.strikethrough = true,
VisualAttribute::FgColor(c) => self.fg = Some(ansi_color_to_ratatui(c)),
VisualAttribute::BgColor(c) => self.bg = Some(ansi_color_to_ratatui(c)),
_ => {}
}
}
fn apply_sgr(&mut self, sgr: &str) {
// Strip ESC[ ... m wrapper and delegate to ansitok's SGR parser
let params = sgr
.strip_prefix("\x1b[")
.and_then(|s| s.strip_suffix('m'))
.unwrap_or(sgr);
if params.is_empty() {
*self = Self::default();
return;
}
for output in parse_ansi_sgr(sgr) {
if let Some(attr) = output.as_escape() {
self.apply_sgr_attr(attr);
}
}
}
fn merge(&self, base: Style) -> Style {
let mut style = base;
if let Some(fg) = self.fg {
if self.bold {
style = style.fg(brighten(fg));
} else {
style = style.fg(fg);
}
}
if let Some(bg) = self.bg {
style = style.bg(bg);
}
if self.italic {
style = style.add_modifier(Modifier::ITALIC);
}
if self.underline {
style = style.add_modifier(Modifier::UNDERLINED);
}
if self.strikethrough {
style = style.add_modifier(Modifier::CROSSED_OUT);
}
if self.bold {
// Bold applied only when there's no explicit fg (brighten handles it otherwise)
style = style.add_modifier(Modifier::BOLD);
}
style
}
}
fn apply_sgr_sequence(style: &mut AnsiStyleStack, sgr: &str) {
style.apply_sgr(sgr);
}
// ── color conversion ──
fn ansi_color_to_ratatui(color: AnsiColor) -> Color {
match color {
AnsiColor::Bit4(c) => ansi_4bit(c),
AnsiColor::Bit8(c) => ansi_256(c),
AnsiColor::Bit24 { r, g, b } => Color::Rgb(r, g, b),
}
}
fn ansi_4bit(code: u8) -> Color {
match code {
30 => Color::Rgb(0, 0, 0),
31 => Color::Rgb(194, 54, 33),
32 => Color::Rgb(37, 188, 36),
33 => Color::Rgb(173, 173, 39),
34 => Color::Rgb(73, 46, 225),
35 => Color::Rgb(211, 56, 211),
36 => Color::Rgb(51, 187, 200),
37 => Color::Rgb(203, 204, 205),
90 => Color::Rgb(129, 131, 131),
91 => Color::Rgb(252, 57, 31),
92 => Color::Rgb(49, 231, 34),
93 => Color::Rgb(234, 236, 35),
94 => Color::Rgb(88, 51, 255),
95 => Color::Rgb(249, 53, 248),
96 => Color::Rgb(20, 240, 240),
97 => Color::Rgb(233, 235, 235),
// Background colors (same values as foreground but offset by 10)
40 => Color::Rgb(0, 0, 0),
41 => Color::Rgb(194, 54, 33),
42 => Color::Rgb(37, 188, 36),
43 => Color::Rgb(173, 173, 39),
44 => Color::Rgb(73, 46, 225),
45 => Color::Rgb(211, 56, 211),
46 => Color::Rgb(51, 187, 200),
47 => Color::Rgb(203, 204, 205),
100 => Color::Rgb(129, 131, 131),
101 => Color::Rgb(252, 57, 31),
102 => Color::Rgb(49, 231, 34),
103 => Color::Rgb(234, 236, 35),
104 => Color::Rgb(88, 51, 255),
105 => Color::Rgb(249, 53, 248),
106 => Color::Rgb(20, 240, 240),
107 => Color::Rgb(233, 235, 235),
_ => Color::Rgb(255, 255, 255),
}
}
fn ansi_256(code: u8) -> Color {
match code {
0..=15 => ansi_4bit(if code < 8 { code + 30 } else { code + 82 }),
16..=231 => {
let idx = code - 16;
let cube = [0, 95, 135, 175, 215, 255];
let r = cube[(idx / 36) as usize];
let g = cube[((idx / 6) % 6) as usize];
let b = cube[(idx % 6) as usize];
Color::Rgb(r, g, b)
}
232..=255 => {
let v = (code - 232) * 10 + 8;
Color::Rgb(v, v, v)
}
}
}
fn brighten(color: Color) -> Color {
match color {
Color::Rgb(r, g, b) => Color::Rgb(
((r as u32) * 13 / 10).min(255) as u8,
((g as u32) * 13 / 10).min(255) as u8,
((b as u32) * 13 / 10).min(255) as u8,
),
_ => color,
}
}
#[cfg(test)]
mod tests {
use super::*;
use ratatui::style::Style;
fn visible<'a>(spans: &[Span<'a>]) -> String {
spans.iter().map(|s| s.content.as_ref()).collect::<String>()
}
#[test]
fn plain_text_no_ansi() {
let spans = ansi_to_spans("hello", Style::default());
assert_eq!(spans.len(), 1);
assert_eq!(spans[0].content, "hello");
}
#[test]
fn fg_red_reset() {
let spans = ansi_to_spans("\x1b[31mred\x1b[0m plain", Style::default());
assert!(spans.len() >= 2);
assert_eq!(visible(&spans), "red plain");
}
#[test]
fn empty_sgr_resets_all() {
let base = Style::default().fg(Color::Rgb(1, 2, 3));
let spans = ansi_to_spans("\x1b[31mred\x1b[m plain", base);
assert_eq!(visible(&spans), "red plain");
assert!(spans.len() >= 2);
// First span should have red foreground
assert_ne!(spans[0].style.fg, Some(Color::Rgb(1, 2, 3)));
// Last span should have base foreground
assert_eq!(spans.last().unwrap().style.fg, Some(Color::Rgb(1, 2, 3)));
}
#[test]
fn bold_brightens_color() {
let spans = ansi_to_spans("\x1b[1;31mbold red\x1b[0m", Style::default());
assert_eq!(spans.len(), 1);
assert_eq!(visible(&spans), "bold red");
}
#[test]
fn strip_ansi_codes_from_output() {
let spans = ansi_to_spans("\x1b[32mgreen\x1b[0m", Style::default());
assert_eq!(visible(&spans), "green");
}
#[test]
fn visible_text_strips_ansi() {
assert_eq!(ansi_visible_text("plain"), "plain");
assert_eq!(ansi_visible_text("\x1b[31mred\x1b[0m"), "red");
assert_eq!(
ansi_visible_text("\x1b[1;32mbold green\x1b[0m plain"),
"bold green plain"
);
}
#[test]
fn xterm_256_color_cube() {
assert_eq!(ansi_256(16), Color::Rgb(0, 0, 0));
assert_eq!(ansi_256(21), Color::Rgb(0, 0, 255));
assert_eq!(ansi_256(52), Color::Rgb(95, 0, 0));
assert_eq!(ansi_256(67), Color::Rgb(95, 135, 175));
}
#[test]
fn true_color_24bit() {
let spans = ansi_to_spans(
"\x1b[38;2;100;200;50mtruecolor\x1b[0m",
Style::default(),
);
assert_eq!(visible(&spans), "truecolor");
assert_eq!(spans[0].style.fg, Some(Color::Rgb(100, 200, 50)));
}
}

1782
crates/pipeview-tui/src/app.rs
View File

File diff suppressed because it is too large Load Diff

169
crates/pipeview-tui/src/app_state.rs
View File

@@ -1,169 +0,0 @@
use std::env;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
use pipeview_client::SessionConfig;
use serde::{Deserialize, Serialize};
use tracing::warn;
use crate::app::{DisplayOptions, View, default_session_config};
const TUI_STATE_FILE_NAME: &str = "tui-state.json";
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersistedTuiState {
#[serde(default = "default_session")]
pub session: SessionConfig,
#[serde(default)]
pub active_view: PersistedView,
#[serde(default = "default_true")]
pub show_timestamp: bool,
#[serde(default = "default_true")]
pub show_direction: bool,
#[serde(default = "default_true")]
pub show_pipeline: bool,
}
impl Default for PersistedTuiState {
fn default() -> Self {
Self {
session: default_session(),
active_view: PersistedView::Text,
show_timestamp: true,
show_direction: true,
show_pipeline: true,
}
}
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, Default)]
pub enum PersistedView {
#[default]
Text,
Hex,
Plot,
}
impl From<View> for PersistedView {
fn from(value: View) -> Self {
match value {
View::Text => Self::Text,
View::Hex => Self::Hex,
View::Plot => Self::Plot,
}
}
}
impl From<PersistedView> for View {
fn from(value: PersistedView) -> Self {
match value {
PersistedView::Text => View::Text,
PersistedView::Hex => View::Hex,
PersistedView::Plot => View::Plot,
}
}
}
pub fn load_tui_state() -> PersistedTuiState {
match load_tui_state_from_path(&tui_state_path()) {
Ok(mut state) => {
if state.session.pipelines.is_empty() {
state.session = default_session();
}
state
}
Err(err) if err.kind() == io::ErrorKind::NotFound => PersistedTuiState::default(),
Err(err) => {
warn!(error = %err, "Failed to load persisted TUI state");
PersistedTuiState::default()
}
}
}
pub fn save_tui_state(session: &SessionConfig, view: View, display: DisplayOptions) {
let state = PersistedTuiState {
session: session.clone(),
active_view: view.into(),
show_timestamp: display.show_timestamp,
show_direction: display.show_direction,
show_pipeline: display.show_pipeline,
};
if let Err(err) = save_tui_state_to_path(&state, &tui_state_path()) {
warn!(error = %err, "Failed to persist TUI state");
}
}
fn default_session() -> SessionConfig {
default_session_config()
}
fn tui_state_path() -> PathBuf {
state_path_for_os_and_env(env::consts::OS, |key| env::var(key).ok())
}
pub fn config_dir() -> PathBuf {
tui_state_path()
.parent()
.map(Path::to_path_buf)
.unwrap_or_else(|| PathBuf::from("."))
}
fn state_path_for_os_and_env(os: &str, get_env: impl Fn(&str) -> Option<String>) -> PathBuf {
match os {
"windows" => {
if let Some(path) = get_env("APPDATA").filter(|path| !path.trim().is_empty()) {
return PathBuf::from(path)
.join("pipeview")
.join(TUI_STATE_FILE_NAME);
}
if let Some(path) = get_env("LOCALAPPDATA").filter(|path| !path.trim().is_empty()) {
return PathBuf::from(path)
.join("pipeview")
.join(TUI_STATE_FILE_NAME);
}
}
"macos" => {
if let Some(home) = get_env("HOME").filter(|path| !path.trim().is_empty()) {
return PathBuf::from(home)
.join("Library")
.join("Application Support")
.join("pipeview")
.join(TUI_STATE_FILE_NAME);
}
}
_ => {
if let Some(path) = get_env("XDG_CONFIG_HOME").filter(|path| !path.trim().is_empty()) {
return PathBuf::from(path)
.join("pipeview")
.join(TUI_STATE_FILE_NAME);
}
if let Some(home) = get_env("HOME").filter(|path| !path.trim().is_empty()) {
return PathBuf::from(home)
.join(".config")
.join("pipeview")
.join(TUI_STATE_FILE_NAME);
}
}
}
PathBuf::from(TUI_STATE_FILE_NAME)
}
fn load_tui_state_from_path(path: &Path) -> io::Result<PersistedTuiState> {
let text = fs::read_to_string(path)?;
serde_json::from_str(&text).map_err(io::Error::other)
}
fn save_tui_state_to_path(state: &PersistedTuiState, path: &Path) -> io::Result<()> {
if let Some(parent) = path.parent() {
fs::create_dir_all(parent)?;
}
let json = serde_json::to_string_pretty(state).map_err(io::Error::other)?;
fs::write(path, json)
}
const fn default_true() -> bool {
true
}

637
crates/pipeview-tui/src/buffers.rs
View File

@@ -1,637 +0,0 @@
use std::collections::VecDeque;
use std::time::{Duration, Instant};
use pipeview_client::{DecodedEntry, RingBuffer};
use pipeview_core::protocol::DecodedData;
use pipeview_core::protocol::plot::{PlotFormat, PlotFrame};
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum LineDirection {
In,
Out,
}
#[derive(Clone)]
pub struct ConsoleLine {
pub elapsed: Duration,
pub pipeline: String,
pub text: String,
pub direction: LineDirection,
}
pub struct TextBuffer {
started_at: Instant,
lines: RingBuffer<ConsoleLine>,
}
impl TextBuffer {
pub fn new(limit: usize) -> Self {
Self {
started_at: Instant::now(),
lines: RingBuffer::new(limit),
}
}
pub fn push(&mut self, entry: &DecodedEntry) {
if let DecodedData::Text(text) = &entry.data {
self.lines.push(ConsoleLine {
elapsed: self.started_at.elapsed(),
pipeline: entry.pipeline_name.clone(),
text: text.clone(),
direction: LineDirection::In,
});
}
}
pub fn push_outbound(&mut self, text: String) {
self.lines.push(ConsoleLine {
elapsed: self.started_at.elapsed(),
pipeline: String::from("OUT"),
text,
direction: LineDirection::Out,
});
}
pub fn get(&self, index: usize) -> Option<&ConsoleLine> {
self.lines.get(index)
}
pub fn len(&self) -> usize {
self.lines.len()
}
pub fn clear(&mut self) {
self.lines.clear();
}
pub fn set_limit(&mut self, limit: usize) {
self.lines.set_limit(limit);
}
}
#[derive(Clone)]
pub struct HexLine {
pub elapsed: Duration,
pub pipeline: String,
pub hex: String,
pub ascii: String,
pub direction: LineDirection,
}
pub struct HexBuffer {
started_at: Instant,
lines: RingBuffer<HexLine>,
}
impl HexBuffer {
pub fn new(limit: usize) -> Self {
Self {
started_at: Instant::now(),
lines: RingBuffer::new(limit),
}
}
pub fn push(&mut self, entry: &DecodedEntry) {
if let DecodedData::Hex(hex) = &entry.data {
self.lines.push(HexLine {
elapsed: self.started_at.elapsed(),
pipeline: entry.pipeline_name.clone(),
ascii: decode_ascii(hex),
hex: hex.clone(),
direction: LineDirection::In,
});
}
}
pub fn push_outbound(&mut self, hex: String) {
self.lines.push(HexLine {
elapsed: self.started_at.elapsed(),
pipeline: String::from("OUT"),
ascii: decode_ascii(&hex),
hex,
direction: LineDirection::Out,
});
}
pub fn get(&self, index: usize) -> Option<&HexLine> {
self.lines.get(index)
}
pub fn len(&self) -> usize {
self.lines.len()
}
pub fn clear(&mut self) {
self.lines.clear();
}
pub fn set_limit(&mut self, limit: usize) {
self.lines.set_limit(limit);
}
}
pub struct PlotSeries {
pub name: String,
points: VecDeque<[f64; 2]>,
next_x: f64,
}
impl PlotSeries {
fn new(name: String) -> Self {
Self {
name,
points: VecDeque::new(),
next_x: 0.0,
}
}
fn push_samples(&mut self, samples: &[f64], limit: usize) {
for sample in samples {
if !sample.is_finite() {
continue;
}
self.push_point([self.next_x, *sample], limit);
self.next_x += 1.0;
}
}
fn push_point(&mut self, point: [f64; 2], limit: usize) -> Option<[f64; 2]> {
self.points.push_back(point);
if self.points.len() > limit {
self.points.pop_front()
} else {
None
}
}
pub fn points(&self) -> impl Iterator<Item = [f64; 2]> + '_ {
self.points.iter().copied()
}
pub fn len(&self) -> usize {
self.points.len()
}
fn first_point(&self) -> Option<[f64; 2]> {
self.points.front().copied()
}
fn last_point(&self) -> Option<[f64; 2]> {
self.points.back().copied()
}
pub fn render_points_time_series(
&self,
x_min: f64,
x_max: f64,
max_points: usize,
) -> Vec<[f64; 2]> {
if self.points.is_empty() || max_points == 0 {
return Vec::new();
}
let mut exact_visible = Vec::with_capacity(max_points.min(self.points.len()));
for point in self.points.iter().copied() {
if point[0] < x_min {
continue;
}
if point[0] > x_max {
break;
}
exact_visible.push(point);
if exact_visible.len() > max_points {
exact_visible.clear();
break;
}
}
if !exact_visible.is_empty() {
return exact_visible;
}
let bucket_count = (max_points / 2).max(1);
let width = (x_max - x_min).max(1.0);
let bucket_width = width / bucket_count as f64;
let mut rendered = Vec::with_capacity(bucket_count * 2);
let mut points = self
.points
.iter()
.copied()
.skip_while(|point| point[0] < x_min)
.peekable();
for bucket_index in 0..bucket_count {
let bucket_start = x_min + bucket_width * bucket_index as f64;
let bucket_end = if bucket_index + 1 == bucket_count {
x_max
} else {
bucket_start + bucket_width
};
let mut min_point: Option<[f64; 2]> = None;
let mut max_point: Option<[f64; 2]> = None;
while let Some(point) = points.peek().copied() {
if point[0] > bucket_end {
break;
}
if point[0] >= bucket_start {
match min_point {
Some(current) if current[1] <= point[1] => {}
_ => min_point = Some(point),
}
match max_point {
Some(current) if current[1] >= point[1] => {}
_ => max_point = Some(point),
}
}
points.next();
}
match (min_point, max_point) {
(Some(a), Some(b)) if a[0] <= b[0] => {
rendered.push(a);
if a != b {
rendered.push(b);
}
}
(Some(a), Some(b)) => {
rendered.push(b);
if a != b {
rendered.push(a);
}
}
(Some(a), None) | (None, Some(a)) => rendered.push(a),
(None, None) => {}
}
}
if rendered.len() > max_points {
let stride = rendered.len().div_ceil(max_points);
rendered.into_iter().step_by(stride).collect()
} else {
rendered
}
}
pub fn render_points_xy(&self, max_points: usize) -> Vec<[f64; 2]> {
if self.points.is_empty() || max_points == 0 {
return Vec::new();
}
if self.points.len() <= max_points {
return self.points.iter().copied().collect();
}
let stride = self.points.len().div_ceil(max_points);
self.points.iter().copied().step_by(stride).collect()
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum PlotSeriesKind {
TimeSeries,
XY,
}
#[derive(Clone, Copy)]
struct BoundsRect {
min_x: f64,
max_x: f64,
min_y: f64,
max_y: f64,
}
impl BoundsRect {
fn from_point([x, y]: [f64; 2]) -> Option<Self> {
if !(x.is_finite() && y.is_finite()) {
return None;
}
Some(Self {
min_x: x,
max_x: x,
min_y: y,
max_y: y,
})
}
fn extend_with_point(&mut self, [x, y]: [f64; 2]) {
if !(x.is_finite() && y.is_finite()) {
return;
}
self.min_x = self.min_x.min(x);
self.max_x = self.max_x.max(x);
self.min_y = self.min_y.min(y);
self.max_y = self.max_y.max(y);
}
fn touches(&self, [x, y]: [f64; 2]) -> bool {
x == self.min_x || x == self.max_x || y == self.min_y || y == self.max_y
}
}
pub struct PlotBuffer {
limit: usize,
kind: PlotSeriesKind,
series: Vec<PlotSeries>,
time_series_y_bounds: Option<(f64, f64)>,
time_series_y_dirty: bool,
xy_bounds: Option<BoundsRect>,
xy_bounds_dirty: bool,
}
impl PlotBuffer {
pub fn new(limit: usize) -> Self {
Self {
limit,
kind: PlotSeriesKind::TimeSeries,
series: Vec::new(),
time_series_y_bounds: None,
time_series_y_dirty: false,
xy_bounds: None,
xy_bounds_dirty: false,
}
}
pub fn push(&mut self, entry: &DecodedEntry) {
if let DecodedData::Plot(frame) = &entry.data {
self.push_frame(&entry.pipeline_name, frame);
}
}
fn push_frame(&mut self, pipeline_name: &str, frame: &PlotFrame) {
let next_kind = match frame.format {
PlotFormat::XY => PlotSeriesKind::XY,
PlotFormat::Interleaved | PlotFormat::Block => PlotSeriesKind::TimeSeries,
};
if self.kind != next_kind {
self.invalidate_bounds();
}
self.kind = next_kind;
if matches!(frame.format, PlotFormat::XY) {
self.push_xy_frame(pipeline_name, frame);
return;
}
for (index, channel) in frame.channels.iter().enumerate() {
let series_name = if frame.channels.len() == 1 {
pipeline_name.to_owned()
} else {
format!("{pipeline_name}:ch{}", index + 1)
};
if let Some(series_index) = self
.series
.iter()
.position(|series| series.name == series_name)
{
for sample in channel {
if !sample.is_finite() {
continue;
}
let (point, removed) = {
let series = &mut self.series[series_index];
let point = [series.next_x, *sample];
let removed = series.push_point(point, self.limit);
series.next_x += 1.0;
(point, removed)
};
if let Some(removed) = removed {
self.note_time_series_removed(removed);
}
self.note_time_series_point(point);
}
} else {
let mut series = PlotSeries::new(series_name);
series.push_samples(channel, self.limit);
for point in series.points() {
self.note_time_series_point(point);
}
self.series.push(series);
}
}
}
fn push_xy_frame(&mut self, pipeline_name: &str, frame: &PlotFrame) {
if frame.channels.len() < 2 {
return;
}
let x = &frame.channels[0];
let y = &frame.channels[1];
let len = x.len().min(y.len());
let series_name = format!("{pipeline_name}:xy");
let series_index = if let Some(index) = self
.series
.iter()
.position(|series| series.name == series_name)
{
index
} else {
self.series.push(PlotSeries::new(series_name));
self.series.len() - 1
};
for index in 0..len {
if !x[index].is_finite() || !y[index].is_finite() {
continue;
}
let point = [x[index], y[index]];
let removed = {
let series = &mut self.series[series_index];
series.push_point(point, self.limit)
};
if let Some(removed) = removed {
self.note_xy_removed(removed);
}
self.note_xy_point(point);
}
}
pub fn clear(&mut self) {
self.series.clear();
self.invalidate_bounds();
}
pub fn set_limit(&mut self, limit: usize) {
self.limit = limit;
for series in &mut self.series {
while series.points.len() > self.limit {
series.points.pop_front();
}
}
self.invalidate_bounds();
}
pub fn is_empty(&self) -> bool {
self.series.is_empty()
}
pub fn kind(&self) -> PlotSeriesKind {
self.kind
}
pub fn iter(&self) -> impl Iterator<Item = &PlotSeries> {
self.series.iter()
}
pub fn series_len(&self) -> usize {
self.series.len()
}
pub fn total_points(&self) -> usize {
self.series.iter().map(PlotSeries::len).sum()
}
pub fn bounds(&mut self) -> Option<([f64; 2], [f64; 2])> {
match self.kind {
PlotSeriesKind::TimeSeries => self.time_series_bounds(),
PlotSeriesKind::XY => self.xy_bounds(),
}
}
fn invalidate_bounds(&mut self) {
self.time_series_y_bounds = None;
self.time_series_y_dirty = false;
self.xy_bounds = None;
self.xy_bounds_dirty = false;
}
fn note_time_series_point(&mut self, point: [f64; 2]) {
if !point[1].is_finite() {
return;
}
match &mut self.time_series_y_bounds {
Some((min_y, max_y)) => {
*min_y = min_y.min(point[1]);
*max_y = max_y.max(point[1]);
}
None => self.time_series_y_bounds = Some((point[1], point[1])),
}
}
fn note_time_series_removed(&mut self, removed: [f64; 2]) {
if let Some((min_y, max_y)) = self.time_series_y_bounds
&& (removed[1] == min_y || removed[1] == max_y)
{
self.time_series_y_dirty = true;
}
}
fn note_xy_point(&mut self, point: [f64; 2]) {
match &mut self.xy_bounds {
Some(bounds) => bounds.extend_with_point(point),
None => self.xy_bounds = BoundsRect::from_point(point),
}
}
fn note_xy_removed(&mut self, removed: [f64; 2]) {
if let Some(bounds) = self.xy_bounds
&& bounds.touches(removed)
{
self.xy_bounds_dirty = true;
}
}
fn time_series_bounds(&mut self) -> Option<([f64; 2], [f64; 2])> {
let mut min_x = f64::INFINITY;
let mut max_x = f64::NEG_INFINITY;
for series in &self.series {
if let Some([x, _]) = series.first_point() {
min_x = min_x.min(x);
}
if let Some([x, _]) = series.last_point() {
max_x = max_x.max(x);
}
}
if !(min_x.is_finite() && max_x.is_finite()) {
return None;
}
if self.time_series_y_dirty {
self.recompute_time_series_y_bounds();
}
let (mut min_y, mut max_y) = self.time_series_y_bounds?;
if min_y == max_y {
min_y -= 1.0;
max_y += 1.0;
}
Some(([min_x, min_y], [max_x, max_y]))
}
fn xy_bounds(&mut self) -> Option<([f64; 2], [f64; 2])> {
if self.xy_bounds_dirty {
self.recompute_xy_bounds();
}
let bounds = self.xy_bounds?;
let mut min_x = bounds.min_x;
let mut max_x = bounds.max_x;
let mut min_y = bounds.min_y;
let mut max_y = bounds.max_y;
if min_x == max_x {
min_x -= 1.0;
max_x += 1.0;
}
if min_y == max_y {
min_y -= 1.0;
max_y += 1.0;
}
Some(([min_x, min_y], [max_x, max_y]))
}
fn recompute_time_series_y_bounds(&mut self) {
let mut min_y = f64::INFINITY;
let mut max_y = f64::NEG_INFINITY;
for series in &self.series {
for [_, y] in series.points() {
if y.is_finite() {
min_y = min_y.min(y);
max_y = max_y.max(y);
}
}
}
self.time_series_y_bounds = if min_y.is_finite() && max_y.is_finite() {
Some((min_y, max_y))
} else {
None
};
self.time_series_y_dirty = false;
}
fn recompute_xy_bounds(&mut self) {
let mut bounds: Option<BoundsRect> = None;
for series in &self.series {
for point in series.points() {
match &mut bounds {
Some(existing) => existing.extend_with_point(point),
None => bounds = BoundsRect::from_point(point),
}
}
}
self.xy_bounds = bounds;
self.xy_bounds_dirty = false;
}
}
fn decode_ascii(hex: &str) -> String {
hex::decode(hex.replace(' ', ""))
.map(|bytes| {
bytes
.into_iter()
.map(|byte| {
if byte.is_ascii_graphic() || byte == b' ' {
byte as char
} else {
'.'
}
})
.collect()
})
.unwrap_or_else(|_| String::from("[invalid hex]"))
}

65
crates/pipeview-tui/src/main.rs
View File

@@ -1,65 +0,0 @@
mod ansi;
mod app;
mod app_state;
mod buffers;
mod ui;
use std::io;
use crossterm::{
event::{DisableMouseCapture, EnableMouseCapture},
execute,
terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{Terminal, backend::CrosstermBackend};
use tracing_appender::non_blocking::WorkerGuard;
use tracing_subscriber::{EnvFilter, fmt};
use crate::app::App;
#[tokio::main]
async fn main() -> io::Result<()> {
let _log_guard = init_tracing();
enable_raw_mode()?;
let mut stdout = io::stdout();
execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
let backend = CrosstermBackend::new(stdout);
let mut terminal = Terminal::new(backend)?;
let result = async {
let mut app = App::new();
app.run(&mut terminal).await?;
app.shutdown().await;
io::Result::Ok(())
}
.await;
disable_raw_mode()?;
execute!(
terminal.backend_mut(),
LeaveAlternateScreen,
DisableMouseCapture
)?;
terminal.show_cursor()?;
result
}
fn init_tracing() -> Option<WorkerGuard> {
let filter = EnvFilter::try_from_default_env()
.unwrap_or_else(|_| EnvFilter::new("pipeview_tui=info,pipeview_client=info"));
let log_dir = app_state::config_dir();
let _ = std::fs::create_dir_all(&log_dir);
let file_appender = tracing_appender::rolling::never(log_dir, "tui.log");
let (writer, guard) = tracing_appender::non_blocking(file_appender);
fmt()
.with_env_filter(filter)
.with_target(false)
.with_ansi(false)
.with_writer(writer)
.try_init()
.ok()
.map(|_| guard)
}

989
crates/pipeview-tui/src/ui.rs
View File

@@ -1,989 +0,0 @@
use std::time::Duration;
use ratatui::{
Frame,
layout::{Alignment, Constraint, Direction, Layout, Rect},
style::{Color, Modifier, Style},
symbols::Marker,
text::{Line, Span},
widgets::{
Axis, Block, Borders, Chart, Clear, Dataset, GraphType, List, ListItem, Paragraph, Wrap,
},
};
use crate::ansi::ansi_to_spans;
use crate::app::{
App, AppMode, ConfigField, ConnectionStatus, DisplayOptions, FocusPane, HotAction, LineEnding,
SendMode, View,
};
use crate::buffers::{ConsoleLine, HexLine, LineDirection, PlotSeriesKind};
const BG: Color = Color::Rgb(8, 12, 18);
const PANEL: Color = Color::Rgb(12, 20, 28);
const PANEL_ALT: Color = Color::Rgb(17, 27, 38);
const CYAN: Color = Color::Rgb(55, 214, 230);
const GREEN: Color = Color::Rgb(72, 211, 137);
const AMBER: Color = Color::Rgb(244, 184, 74);
const MAGENTA: Color = Color::Rgb(219, 111, 220);
const RED: Color = Color::Rgb(238, 92, 107);
const BLUE: Color = Color::Rgb(96, 165, 250);
const MUTED: Color = Color::Rgb(120, 134, 153);
const TEXT: Color = Color::Rgb(224, 234, 244);
pub fn render(frame: &mut Frame, app: &mut App) {
app.reset_hot_zones();
let area = frame.area();
frame.render_widget(Block::default().style(Style::default().bg(BG)), area);
let root = Layout::default()
.direction(Direction::Vertical)
.constraints([
Constraint::Length(4),
Constraint::Min(10),
Constraint::Length(6),
Constraint::Length(2),
])
.split(area);
render_header(frame, app, root[0]);
let body = Layout::default()
.direction(Direction::Horizontal)
.constraints([Constraint::Length(34), Constraint::Min(30)])
.split(root[1]);
render_controls(frame, app, body[0]);
render_main(frame, app, body[1]);
render_composer(frame, app, root[2]);
render_footer(frame, app, root[3]);
match app.mode {
AppMode::Search => render_search_modal(frame, app),
AppMode::Config => render_config_modal(frame, app),
AppMode::Help => render_help_modal(frame, app),
AppMode::Normal | AppMode::EditingSend => {}
}
}
fn render_header(frame: &mut Frame, app: &App, area: Rect) {
let status = &app.session.status;
let status_color = status_color(status);
let error = match status {
ConnectionStatus::Error(message) => format!(" {message}"),
_ => String::new(),
};
let header = vec![
Line::from(vec![
Span::styled(
" PIPEVIEW ",
Style::default()
.fg(Color::Black)
.bg(CYAN)
.add_modifier(Modifier::BOLD),
),
Span::raw(" "),
Span::styled(
"single session telemetry console",
Style::default().fg(TEXT).add_modifier(Modifier::BOLD),
),
Span::raw(" "),
Span::styled(
status.label(),
Style::default()
.fg(Color::Black)
.bg(status_color)
.add_modifier(Modifier::BOLD),
),
Span::styled(error, Style::default().fg(RED)),
]),
Line::from(vec![
Span::styled(app.transport_summary(), Style::default().fg(AMBER)),
Span::raw(" | pipelines: "),
Span::styled(app.pipeline_summary(), Style::default().fg(MAGENTA)),
Span::raw(" | view: "),
Span::styled(
app.session.view.label(),
Style::default().fg(view_color(app.session.view)),
),
Span::raw(" | rx/tx: "),
Span::styled(
format!(
"{}/{}",
app.session.received_messages, app.session.sent_messages
),
Style::default().fg(GREEN),
),
]),
];
frame.render_widget(
Paragraph::new(header)
.block(panel_block("Status", false, CYAN))
.wrap(Wrap { trim: false }),
area,
);
}
fn render_controls(frame: &mut Frame, app: &mut App, area: Rect) {
app.add_hot_zone(area, HotAction::Focus(FocusPane::Controls));
let focused = app.focus == FocusPane::Controls;
let block = panel_block("Control Deck", focused, AMBER);
let inner = block.inner(area);
frame.render_widget(block, area);
let connect_label = if app.session.status.is_connectedish() {
"[ Disconnect ]"
} else {
"[ Connect ]"
};
let ending = next_line_ending(app.session.line_ending);
let rows: Vec<(Line<'static>, Option<HotAction>)> = vec![
section_line("SESSION"),
button_line(
connect_label,
status_color(&app.session.status),
Some(HotAction::ToggleConnection),
),
button_line("[ Reconnect ]", BLUE, Some(HotAction::Reconnect)),
button_line("[ Clear Buffers ]", RED, Some(HotAction::Clear)),
button_line("[ Configure ]", MAGENTA, Some(HotAction::OpenConfig)),
spacer_line(),
section_line("LINES"),
toggle_line(
"Auto reconnect",
app.session.auto_reconnect,
Some(HotAction::ToggleAutoReconnect),
),
toggle_line("DTR", app.session.dtr, Some(HotAction::ToggleDtr)),
toggle_line("RTS", app.session.rts, Some(HotAction::ToggleRts)),
spacer_line(),
section_line("DISPLAY"),
toggle_line(
"Timestamp",
app.display.show_timestamp,
Some(HotAction::ToggleTimestamp),
),
toggle_line(
"Direction",
app.display.show_direction,
Some(HotAction::ToggleDirection),
),
toggle_line(
"Pipeline",
app.display.show_pipeline,
Some(HotAction::TogglePipeline),
),
spacer_line(),
section_line("SEND"),
value_line(
"Mode",
app.session.send_mode.label(),
Some(HotAction::SendMode(match app.session.send_mode {
SendMode::Text => SendMode::Hex,
SendMode::Hex => SendMode::Text,
})),
),
value_line(
"Ending",
app.session.line_ending.label(),
Some(HotAction::LineEnding(ending)),
),
button_line("[ Search ]", CYAN, Some(HotAction::OpenSearch)),
button_line("[ Help ]", MUTED, Some(HotAction::OpenHelp)),
];
for (index, (_, action)) in rows.iter().enumerate() {
if let Some(action) = action {
let y = inner.y.saturating_add(index as u16);
if y < inner.y.saturating_add(inner.height) {
app.add_hot_zone(
Rect {
x: inner.x,
y,
width: inner.width,
height: 1,
},
*action,
);
}
}
}
frame.render_widget(
Paragraph::new(rows.into_iter().map(|(line, _)| line).collect::<Vec<_>>())
.style(Style::default().fg(TEXT).bg(PANEL)),
inner,
);
}
fn render_main(frame: &mut Frame, app: &mut App, area: Rect) {
app.add_hot_zone(area, HotAction::Focus(FocusPane::Main));
let layout = Layout::default()
.direction(Direction::Vertical)
.constraints([Constraint::Length(3), Constraint::Min(5)])
.split(area);
render_tabs(frame, app, layout[0]);
match app.session.view {
View::Text => render_text_view(frame, app, layout[1]),
View::Hex => render_hex_view(frame, app, layout[1]),
View::Plot => render_plot_view(frame, app, layout[1]),
}
}
fn render_tabs(frame: &mut Frame, app: &mut App, area: Rect) {
let chunks = Layout::default()
.direction(Direction::Horizontal)
.constraints([
Constraint::Percentage(34),
Constraint::Percentage(33),
Constraint::Percentage(33),
])
.split(area);
for (idx, view) in View::ALL.into_iter().enumerate() {
let selected = app.session.view == view;
app.add_hot_zone(chunks[idx], HotAction::View(view));
let color = view_color(view);
let block = panel_block(view.label(), selected, color);
frame.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(
view.label(),
Style::default()
.fg(if selected { Color::Black } else { color })
.bg(if selected { color } else { PANEL })
.add_modifier(Modifier::BOLD),
),
Span::styled(
match view {
View::Text => format!(" {} lines", app.session.console.len()),
View::Hex => format!(" {} lines", app.session.hex.len()),
View::Plot => format!(
" {} series / {} pts",
app.session.plot.series_len(),
app.session.plot.total_points()
),
},
Style::default().fg(MUTED),
),
]))
.block(block)
.alignment(Alignment::Center),
chunks[idx],
);
}
}
fn render_text_view(frame: &mut Frame, app: &mut App, area: Rect) {
let focused = app.focus == FocusPane::Main;
let block = panel_block("Text Stream", focused, CYAN);
let inner = block.inner(area);
let height = inner.height as usize;
let total = app.session.console.len();
let start = app.visible_start(total, height);
let end = start.saturating_add(height).min(total);
let lines = if total == 0 {
vec![Line::styled("no text data", Style::default().fg(MUTED))]
} else {
(start..end)
.filter_map(|index| {
app.session
.console
.get(index)
.map(|line| format_console_line(index, line, app.display, app))
})
.collect()
};
frame.render_widget(
Paragraph::new(lines)
.block(block)
.style(Style::default().bg(PANEL_ALT))
.wrap(Wrap { trim: false }),
area,
);
}
fn render_hex_view(frame: &mut Frame, app: &mut App, area: Rect) {
let focused = app.focus == FocusPane::Main;
let block = panel_block("Hex Stream", focused, AMBER);
let inner = block.inner(area);
let height = inner.height as usize;
let total = app.session.hex.len();
let start = app.visible_start(total, height);
let end = start.saturating_add(height).min(total);
let lines = if total == 0 {
vec![Line::styled("no hex data", Style::default().fg(MUTED))]
} else {
(start..end)
.filter_map(|index| {
app.session
.hex
.get(index)
.map(|line| format_hex_line(index, line, app.display, app))
})
.collect()
};
frame.render_widget(
Paragraph::new(lines)
.block(block)
.style(Style::default().bg(PANEL_ALT))
.wrap(Wrap { trim: false }),
area,
);
}
fn render_plot_view(frame: &mut Frame, app: &mut App, area: Rect) {
let focused = app.focus == FocusPane::Main;
let block = panel_block("Plot View", focused, GREEN);
let inner = block.inner(area);
app.add_hot_zone(inner, HotAction::Focus(FocusPane::Main));
if app.session.plot.is_empty() {
frame.render_widget(
Paragraph::new(vec![
Line::styled("no plot data", Style::default().fg(MUTED)),
Line::from(vec![
Span::raw("pipeline: "),
Span::styled(app.pipeline_summary(), Style::default().fg(MAGENTA)),
]),
])
.block(block)
.style(Style::default().bg(PANEL_ALT))
.alignment(Alignment::Center),
area,
);
return;
}
let Some((min, max)) = app.plot_bounds() else {
frame.render_widget(
Paragraph::new("plot bounds unavailable")
.block(block)
.style(Style::default().fg(MUTED).bg(PANEL_ALT)),
area,
);
return;
};
let max_points = (inner.width as usize).saturating_mul(2).max(32);
let kind = app.session.plot.kind();
let series_points: Vec<(String, Vec<(f64, f64)>)> = app
.session
.plot
.iter()
.map(|series| {
let points = match kind {
PlotSeriesKind::TimeSeries => {
series.render_points_time_series(min[0], max[0], max_points)
}
PlotSeriesKind::XY => series.render_points_xy(max_points),
};
(
series.name.clone(),
points.into_iter().map(|[x, y]| (x, y)).collect(),
)
})
.collect();
let palette = [GREEN, CYAN, AMBER, MAGENTA, BLUE, RED];
let datasets = series_points
.iter()
.enumerate()
.map(|(index, (name, points))| {
Dataset::default()
.name(name.as_str())
.marker(Marker::Braille)
.graph_type(GraphType::Line)
.style(Style::default().fg(palette[index % palette.len()]))
.data(points)
})
.collect::<Vec<_>>();
let chart = Chart::new(datasets)
.block(block)
.style(Style::default().bg(PANEL_ALT))
.x_axis(axis("X", min[0], max[0], CYAN))
.y_axis(axis("Y", min[1], max[1], GREEN));
frame.render_widget(chart, area);
let overlay = Rect {
x: inner.x.saturating_add(1),
y: inner.y,
width: inner.width.saturating_sub(2).min(72),
height: 1,
};
let controls = Layout::default()
.direction(Direction::Horizontal)
.constraints([
Constraint::Length(16),
Constraint::Length(10),
Constraint::Length(10),
Constraint::Min(1),
])
.split(overlay);
app.add_hot_zone(controls[0], HotAction::PlotFollow);
app.add_hot_zone(controls[1], HotAction::PlotZoomIn);
app.add_hot_zone(controls[2], HotAction::PlotZoomOut);
let mode = match kind {
PlotSeriesKind::TimeSeries => "time",
PlotSeriesKind::XY => "xy",
};
frame.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(
format!(
"[follow {}] ",
if app.plot.follow_latest { "on" } else { "off" }
),
Style::default()
.fg(Color::Black)
.bg(if app.plot.follow_latest { GREEN } else { MUTED })
.add_modifier(Modifier::BOLD),
),
Span::styled("[zoom +] ", Style::default().fg(Color::Black).bg(CYAN)),
Span::styled("[zoom -] ", Style::default().fg(Color::Black).bg(AMBER)),
Span::styled(format!("{mode} "), Style::default().fg(MUTED)),
Span::styled(
format!(
"{} series / {} pts",
app.session.plot.series_len(),
app.session.plot.total_points()
),
Style::default().fg(TEXT),
),
]))
.style(Style::default().bg(PANEL_ALT)),
overlay,
);
}
fn render_composer(frame: &mut Frame, app: &mut App, area: Rect) {
app.add_hot_zone(area, HotAction::Focus(FocusPane::Composer));
let focused = app.focus == FocusPane::Composer || matches!(app.mode, AppMode::EditingSend);
let block = panel_block("Composer", focused, MAGENTA);
let inner = block.inner(area);
frame.render_widget(block, area);
let chunks = Layout::default()
.direction(Direction::Horizontal)
.constraints([Constraint::Min(20), Constraint::Length(28)])
.split(inner);
let input_block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(if focused { MAGENTA } else { MUTED }))
.style(Style::default().bg(PANEL_ALT));
frame.render_widget(
Paragraph::new(input_line(app))
.block(input_block)
.wrap(Wrap { trim: false }),
chunks[0],
);
let side_rows = vec![
value_line(
"Mode",
app.session.send_mode.label(),
Some(HotAction::SendMode(match app.session.send_mode {
SendMode::Text => SendMode::Hex,
SendMode::Hex => SendMode::Text,
})),
),
value_line(
"Ending",
app.session.line_ending.label(),
Some(HotAction::LineEnding(next_line_ending(
app.session.line_ending,
))),
),
button_line("[ Send ]", GREEN, Some(HotAction::Send)),
(
Line::from(vec![
Span::styled("Status ", Style::default().fg(MUTED)),
Span::styled(app.session.send_status.clone(), Style::default().fg(TEXT)),
]),
None,
),
];
for (index, (_, action)) in side_rows.iter().enumerate() {
if let Some(action) = action {
app.add_hot_zone(
Rect {
x: chunks[1].x,
y: chunks[1].y.saturating_add(index as u16),
width: chunks[1].width,
height: 1,
},
*action,
);
}
}
frame.render_widget(
Paragraph::new(
side_rows
.into_iter()
.map(|(line, _)| line)
.collect::<Vec<_>>(),
)
.style(Style::default().bg(PANEL)),
chunks[1],
);
}
fn render_footer(frame: &mut Frame, app: &App, area: Rect) {
let search = if app.search.active && !app.search.query.is_empty() {
format!(
" search {}/{} '{}'",
app.search.display_index(),
app.search.count(),
app.search.query
)
} else {
String::new()
};
let shortcuts = "1/2/3 view c connect r reconnect e config / search Ctrl-S send q quit";
frame.render_widget(
Paragraph::new(Line::from(vec![
Span::styled(
format!(" {} ", app.notice),
Style::default().fg(TEXT).bg(PANEL_ALT),
),
Span::styled(search, Style::default().fg(AMBER).bg(PANEL_ALT)),
Span::styled(" ", Style::default().bg(PANEL_ALT)),
Span::styled(shortcuts, Style::default().fg(MUTED).bg(PANEL_ALT)),
])),
area,
);
}
fn render_search_modal(frame: &mut Frame, app: &mut App) {
let area = centered_rect(70, 7, frame.area());
app.add_hot_zone(area, HotAction::CloseModal);
frame.render_widget(Clear, area);
let block = panel_block("Search", true, CYAN);
let inner = block.inner(area);
frame.render_widget(block, area);
let body = vec![
Line::from(vec![
Span::styled("Query: ", Style::default().fg(MUTED)),
Span::styled(app.search.query.clone(), Style::default().fg(TEXT)),
Span::styled(
"_",
Style::default().fg(CYAN).add_modifier(Modifier::SLOW_BLINK),
),
]),
Line::from(vec![
Span::styled("Matches: ", Style::default().fg(MUTED)),
Span::styled(
format!("{}/{}", app.search.display_index(), app.search.count()),
Style::default().fg(AMBER),
),
Span::raw(" "),
Span::styled(
if app.search.case_sensitive {
"case sensitive"
} else {
"case insensitive"
},
Style::default().fg(MAGENTA),
),
]),
Line::styled(
"Enter close Up/Down navigate Ctrl-C case",
Style::default().fg(MUTED),
),
];
frame.render_widget(
Paragraph::new(body)
.style(Style::default().bg(PANEL))
.wrap(Wrap { trim: false }),
inner,
);
}
fn render_config_modal(frame: &mut Frame, app: &mut App) {
let rows = app.config_form.rows();
let height = (rows.len() as u16 + 6).min(frame.area().height.saturating_sub(2));
let area = centered_rect(88, height, frame.area());
frame.render_widget(Clear, area);
let block = panel_block("Session Config", true, MAGENTA);
let inner = block.inner(area);
frame.render_widget(block, area);
let footer_height = 3;
let layout = Layout::default()
.direction(Direction::Vertical)
.constraints([Constraint::Min(3), Constraint::Length(footer_height)])
.split(inner);
let items = rows
.iter()
.enumerate()
.map(|(index, row)| {
let focused = index == app.config_form.focused;
let value_style = if row.editable {
Style::default().fg(CYAN)
} else {
Style::default().fg(AMBER)
};
ListItem::new(Line::from(vec![
Span::styled(
format!("{:<18}", row.label),
Style::default().fg(if focused { Color::Black } else { MUTED }),
),
Span::styled(
row.value.clone(),
if focused {
value_style.bg(MAGENTA).fg(Color::Black)
} else {
value_style
},
),
]))
.style(if focused {
Style::default().bg(MAGENTA)
} else {
Style::default().bg(PANEL)
})
})
.collect::<Vec<_>>();
for (index, row) in rows.iter().enumerate() {
let y = layout[0].y.saturating_add(index as u16);
if y >= layout[0].y.saturating_add(layout[0].height) {
break;
}
app.add_hot_zone(
Rect {
x: layout[0].x,
y,
width: layout[0].width,
height: 1,
},
if row.field == ConfigField::Apply {
HotAction::ConfigSubmit
} else {
HotAction::ConfigFocus(row.field)
},
);
}
frame.render_widget(
List::new(items).style(Style::default().bg(PANEL)),
layout[0],
);
app.add_hot_zone(layout[1], HotAction::ConfigCancel);
frame.render_widget(
Paragraph::new(vec![
Line::styled(
"Tab move Left/Right change options Enter apply Esc cancel",
Style::default().fg(MUTED),
),
Line::styled(serial_ports_hint(app), Style::default().fg(BLUE)),
])
.style(Style::default().bg(PANEL)),
layout[1],
);
}
fn render_help_modal(frame: &mut Frame, app: &mut App) {
let area = centered_rect(74, 12, frame.area());
app.add_hot_zone(area, HotAction::CloseModal);
frame.render_widget(Clear, area);
let block = panel_block("Help", true, BLUE);
let inner = block.inner(area);
frame.render_widget(block, area);
frame.render_widget(
Paragraph::new(vec![
Line::styled(
"Keyboard",
Style::default().fg(CYAN).add_modifier(Modifier::BOLD),
),
Line::raw("1/2/3 switch views, Tab shift focus, q quit"),
Line::raw("c connect, r reconnect, e config, / search, x clear"),
Line::raw("Ctrl-S send, Enter edit/send composer, Esc close modal"),
Line::styled(
"Mouse",
Style::default().fg(AMBER).add_modifier(Modifier::BOLD),
),
Line::raw("Click tabs, buttons, toggles, config rows, and composer."),
Line::raw("Wheel scrolls Text/Hex and zooms Plot."),
])
.style(Style::default().fg(TEXT).bg(PANEL))
.wrap(Wrap { trim: false }),
inner,
);
}
fn format_console_line(
index: usize,
line: &ConsoleLine,
display: DisplayOptions,
app: &App,
) -> Line<'static> {
let mut spans = prefix_spans(line.elapsed, line.direction, &line.pipeline, display);
let base_style = Style::default().fg(TEXT);
spans.extend(ansi_to_spans(&line.text, base_style));
apply_search_style(index, Line::from(spans), app)
}
fn format_hex_line(
index: usize,
line: &HexLine,
display: DisplayOptions,
app: &App,
) -> Line<'static> {
let mut spans = prefix_spans(line.elapsed, line.direction, &line.pipeline, display);
spans.push(Span::styled(line.hex.clone(), Style::default().fg(AMBER)));
spans.push(Span::styled(" |", Style::default().fg(MUTED)));
spans.push(Span::styled(line.ascii.clone(), Style::default().fg(TEXT)));
spans.push(Span::styled("|", Style::default().fg(MUTED)));
apply_search_style(index, Line::from(spans), app)
}
fn prefix_spans(
elapsed: Duration,
direction: LineDirection,
pipeline: &str,
display: DisplayOptions,
) -> Vec<Span<'static>> {
let mut spans = Vec::new();
if display.show_timestamp {
spans.push(Span::styled(
format!("[{}] ", format_elapsed(elapsed)),
Style::default().fg(MUTED),
));
}
if display.show_direction {
let (label, color) = match direction {
LineDirection::In => ("IN", CYAN),
LineDirection::Out => ("OUT", AMBER),
};
spans.push(Span::styled(
format!("[{label}] "),
Style::default().fg(color).add_modifier(Modifier::BOLD),
));
}
if display.show_pipeline {
spans.push(Span::styled(
format!("[{pipeline}] "),
Style::default().fg(MAGENTA),
));
}
spans
}
fn apply_search_style(index: usize, line: Line<'static>, app: &App) -> Line<'static> {
if !app.search.active || app.search.query.is_empty() {
return line;
}
if app.search.current_line() == Some(index) {
line.style(Style::default().bg(AMBER))
} else if app.search.matches.contains(&index) {
line.style(Style::default().bg(Color::Rgb(47, 61, 91)))
} else {
line
}
}
fn input_line(app: &App) -> Line<'static> {
if app.session.send_input.is_empty() {
return Line::styled(
match app.session.send_mode {
SendMode::Text => "type text payload",
SendMode::Hex => "hex bytes, e.g. 48 65 6c 6c 6f",
},
Style::default().fg(MUTED),
);
}
if !matches!(app.mode, AppMode::EditingSend) {
return Line::styled(app.session.send_input.clone(), Style::default().fg(TEXT));
}
let mut spans = Vec::new();
let cursor = app.session.input_cursor;
for (index, ch) in app.session.send_input.chars().enumerate() {
if index == cursor {
spans.push(Span::styled(
ch.to_string(),
Style::default().fg(Color::Black).bg(MAGENTA),
));
} else {
spans.push(Span::styled(ch.to_string(), Style::default().fg(TEXT)));
}
}
if cursor >= app.session.send_input.chars().count() {
spans.push(Span::styled(" ", Style::default().bg(MAGENTA)));
}
Line::from(spans)
}
fn section_line(label: &'static str) -> (Line<'static>, Option<HotAction>) {
(
Line::styled(
format!("-- {label} "),
Style::default().fg(MUTED).add_modifier(Modifier::BOLD),
),
None,
)
}
fn spacer_line() -> (Line<'static>, Option<HotAction>) {
(Line::raw(""), None)
}
fn button_line(
label: &'static str,
color: Color,
action: Option<HotAction>,
) -> (Line<'static>, Option<HotAction>) {
(
Line::from(vec![Span::styled(
label,
Style::default()
.fg(Color::Black)
.bg(color)
.add_modifier(Modifier::BOLD),
)]),
action,
)
}
fn toggle_line(
label: &'static str,
enabled: bool,
action: Option<HotAction>,
) -> (Line<'static>, Option<HotAction>) {
(
Line::from(vec![
Span::styled(
if enabled { "[x] " } else { "[ ] " },
Style::default().fg(if enabled { GREEN } else { MUTED }),
),
Span::styled(label, Style::default().fg(TEXT)),
]),
action,
)
}
fn value_line(
label: &'static str,
value: &'static str,
action: Option<HotAction>,
) -> (Line<'static>, Option<HotAction>) {
(
Line::from(vec![
Span::styled(format!("{label:<8}"), Style::default().fg(MUTED)),
Span::styled(value.to_string(), Style::default().fg(CYAN)),
]),
action,
)
}
fn panel_block(title: &str, focused: bool, color: Color) -> Block<'_> {
Block::default()
.borders(Borders::ALL)
.title(Span::styled(
format!(" {title} "),
Style::default()
.fg(if focused { Color::Black } else { color })
.bg(if focused { color } else { PANEL })
.add_modifier(Modifier::BOLD),
))
.border_style(Style::default().fg(if focused {
color
} else {
Color::Rgb(45, 58, 74)
}))
.style(Style::default().bg(PANEL))
}
fn axis(title: &'static str, min: f64, max: f64, color: Color) -> Axis<'static> {
Axis::default()
.title(title)
.style(Style::default().fg(color))
.bounds([min, max])
.labels(vec![
Span::styled(format!("{min:.2}"), Style::default().fg(MUTED)),
Span::styled(format!("{max:.2}"), Style::default().fg(MUTED)),
])
}
fn centered_rect(width: u16, height: u16, area: Rect) -> Rect {
let vertical = Layout::default()
.direction(Direction::Vertical)
.constraints([
Constraint::Fill(1),
Constraint::Length(height.min(area.height)),
Constraint::Fill(1),
])
.split(area);
Layout::default()
.direction(Direction::Horizontal)
.constraints([
Constraint::Fill(1),
Constraint::Length(width.min(area.width)),
Constraint::Fill(1),
])
.split(vertical[1])[1]
}
fn status_color(status: &ConnectionStatus) -> Color {
match status {
ConnectionStatus::Connected => GREEN,
ConnectionStatus::Disconnected => MUTED,
ConnectionStatus::Connecting => AMBER,
ConnectionStatus::Error(_) => RED,
}
}
fn view_color(view: View) -> Color {
match view {
View::Text => CYAN,
View::Hex => AMBER,
View::Plot => GREEN,
}
}
fn format_elapsed(elapsed: Duration) -> String {
let secs = elapsed.as_secs_f64();
if secs < 60.0 {
format!("{secs:05.2}")
} else {
format!("{:02}:{:02}", (secs / 60.0) as u64, (secs % 60.0) as u64)
}
}
fn next_line_ending(current: LineEnding) -> LineEnding {
let endings = LineEnding::ALL;
let index = endings
.iter()
.position(|ending| *ending == current)
.unwrap_or(0);
endings[(index + 1) % endings.len()]
}
fn serial_ports_hint(app: &App) -> String {
if app.config_form.available_serial_ports.is_empty() {
String::from("Serial ports: none detected")
} else {
format!(
"Serial ports: {}",
app.config_form.available_serial_ports.join(", ")
)
}
}