Add results panel UI components: Implement controls for console visibility and UI scaling, display running metrics, progress tracking, and results tables. This enhances user interaction by providing comprehensive feedback during speed tests and improving overall layout and usability.

Author: sh1ftd

src/ui/results_panel/controls.rs

@@ -0,0 +1,51 @@
+use crate::ui::types::ResultsPanelParams;
+use eframe::egui;
+use egui_phosphor::regular::*;
+
+pub fn render_console_and_scale_controls(
+    ui: &mut egui::Ui,
+    params: &mut ResultsPanelParams<'_>,
+    on_toggle_console: &mut bool,
+) {
+    ui.horizontal(|ui| {
+        let console_text = if params.console.is_visible() {
+            format!("{EYE_SLASH} Hide Console")
+        } else {
+            format!("{EYE} Show Console")
+        };
+        if ui
+            .add_sized([140.0, 35.0], egui::Button::new(console_text))
+            .clicked()
+        {
+            *on_toggle_console = true;
+        }
+
+        ui.separator();
+
+        ui.label(format!("{MAGNIFYING_GLASS} UI Scale"));
+        let btn_size = egui::vec2(22.0, ui.spacing().interact_size.y);
+
+        if ui.add_sized(btn_size, egui::Button::new("-")).clicked() {
+            *params.ui_scale = (*params.ui_scale - 0.1).max(0.3);
+        }
+
+        if params.ui_scale_text.parse::<f32>().unwrap_or(1.0) != *params.ui_scale {
+            *params.ui_scale_text = format!("{:.1}", params.ui_scale);
+        }
+        let width = 70.0;
+        if ui
+            .add_sized(
+                [width, ui.spacing().interact_size.y],
+                egui::TextEdit::singleline(params.ui_scale_text),
+            )
+            .changed()
+            && let Ok(new_scale) = params.ui_scale_text.parse::<f32>()
+        {
+            *params.ui_scale = new_scale.clamp(0.3, 3.0);
+        }
+
+        if ui.add_sized(btn_size, egui::Button::new("+")).clicked() {
+            *params.ui_scale = (*params.ui_scale + 0.1).min(3.0);
+        }
+    });
+}

src/ui/results_panel/metrics.rs

@@ -0,0 +1,44 @@
+use crate::ui::helpers::get_size_label;
+use crate::ui::types::ResultsPanelParams;
+use eframe::egui;
+use egui_phosphor::regular::*;
+
+pub fn render_running_metrics(ui: &mut egui::Ui, params: &ResultsPanelParams<'_>) {
+    ui.horizontal(|ui| {
+        ui.label(
+            egui::RichText::new(format!(
+                "{} {:.1} MB/s",
+                LIGHTNING, params.test_state.current_throughput
+            ))
+            .size(16.0)
+            .color(egui::Color32::from_rgb(52, 152, 219)),
+        );
+        ui.label("•");
+        ui.label(
+            egui::RichText::new(format!(
+                "{} {} reads/s",
+                CHART_BAR, params.test_state.current_reads
+            ))
+            .size(14.0)
+            .color(egui::Color32::from_rgb(155, 89, 182)),
+        );
+        ui.label("•");
+        ui.label(
+            egui::RichText::new(format!(
+                "{} {:.1} μs",
+                CLOCK, params.test_state.current_latency
+            ))
+            .size(14.0)
+            .color(egui::Color32::from_rgb(231, 76, 60)),
+        );
+
+        if let Some(current_size) = params.test_state.current_test_size {
+            ui.label("•");
+            ui.label(
+                egui::RichText::new(format!("{} {}", TARGET, get_size_label(current_size)))
+                    .size(14.0)
+                    .color(egui::Color32::from_rgb(155, 89, 182)),
+            );
+        }
+    });
+}

src/ui/results_panel/mod.rs

@@ -0,0 +1,8 @@
+pub mod controls;
+pub mod metrics;
+pub mod panel;
+pub mod plot;
+pub mod progress;
+pub mod table;
+
+pub use panel::render_results_panel;

src/ui/results_panel/panel.rs

@@ -0,0 +1,128 @@
+use super::{
+    controls::render_console_and_scale_controls, metrics::render_running_metrics,
+    plot::render_plot_column, progress::render_chunk_progress, table::render_results_table,
+};
+use crate::ui::plot_controls::render_plot_size_controls;
+use crate::ui::types::{PlotMetric, ResultsPanelParams};
+use eframe::egui;
+use egui_phosphor::regular::*;
+
+pub fn render_results_panel(
+    ui: &mut egui::Ui,
+    params: &mut ResultsPanelParams<'_>,
+    on_stop_test: impl FnOnce(),
+    on_test_again: impl FnOnce(),
+    on_toggle_console: &mut bool,
+) {
+    ui.vertical_centered(|ui| {
+        ui.add_space(5.0);
+        ui.heading(format!("{CHART_LINE_UP} DMA Speed Test Results"));
+        ui.add_space(10.0);
+    });
+
+    egui::Frame::new()
+        .fill(ui.visuals().extreme_bg_color)
+        .corner_radius(6.0)
+        .inner_margin(10.0)
+        .show(ui, |ui| {
+            ui.horizontal(|ui| {
+                ui.vertical(|ui| {
+                    render_plot_size_controls(
+                        ui,
+                        params.plot_controls.custom_plot_width,
+                        params.plot_controls.custom_plot_height,
+                        params.plot_controls.plot_resize_start_time,
+                        params.plot_controls.plot_resize_direction,
+                        params.plot_controls.plot_resize_last_repeat,
+                    );
+
+                    ui.add_space(8.0);
+                    render_console_and_scale_controls(ui, params, on_toggle_console);
+
+                    if params.test_state.is_running {
+                        ui.separator();
+                        render_running_metrics(ui, params);
+                        render_chunk_progress(ui, params);
+                    }
+                });
+
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+                    if params.test_state.is_running {
+                        let stop_button = egui::Button::new(
+                            egui::RichText::new(format!("{X_CIRCLE} STOP TEST"))
+                                .color(egui::Color32::BLACK),
+                        )
+                        .fill(egui::Color32::from_rgb(231, 76, 60))
+                        .stroke(egui::Stroke::new(2.0, egui::Color32::from_rgb(192, 57, 43)));
+                        if ui.add_sized([150.0, 40.0], stop_button).clicked() {
+                            on_stop_test();
+                        }
+                    } else if params.test_state.test_end_time.is_some() {
+                        let again_button = egui::Button::new(
+                            egui::RichText::new(format!("{LIGHTNING} TEST AGAIN"))
+                                .color(egui::Color32::BLACK),
+                        )
+                        .fill(egui::Color32::from_rgb(46, 204, 113))
+                        .stroke(egui::Stroke::new(2.0, egui::Color32::from_rgb(39, 174, 96)));
+                        if ui.add_sized([170.0, 40.0], again_button).clicked() {
+                            on_test_again();
+                            *params.show_config = false;
+                        }
+
+                        ui.add_space(8.0);
+
+                        let back_button = egui::Button::new(
+                            egui::RichText::new("RETURN TO CONFIG").color(egui::Color32::BLACK),
+                        )
+                        .fill(egui::Color32::from_rgb(241, 196, 15))
+                        .stroke(egui::Stroke::new(
+                            2.0,
+                            egui::Color32::from_rgb(243, 156, 18),
+                        ));
+                        if ui.add_sized([190.0, 40.0], back_button).clicked() {
+                            *params.show_config = true;
+                        }
+                    }
+                });
+            });
+        });
+
+    ui.add_space(10.0);
+
+    ui.columns(3, |columns| {
+        let width = *params.plot_controls.custom_plot_width;
+        let height = *params.plot_controls.custom_plot_height;
+
+        let specs = [
+            (
+                "Throughput (MB/s)",
+                "throughput_plot",
+                PlotMetric::Throughput,
+                "throughput_results",
+                "Results (MB/s)",
+            ),
+            (
+                "Reads per Second",
+                "reads_plot",
+                PlotMetric::Reads,
+                "reads_results",
+                "Results (reads/s)",
+            ),
+            (
+                "Latency (μs)",
+                "latency_plot",
+                PlotMetric::Latency,
+                "latency_results",
+                "Results (μs)",
+            ),
+        ];
+
+        for (column, (heading, plot_id, metric, table_id, title)) in columns.iter_mut().zip(specs) {
+            column.vertical(|ui| {
+                render_plot_column(ui, heading, plot_id, metric, params, width, height);
+                ui.add_space(10.0);
+                render_results_table(ui, table_id, params.results, metric, title);
+            });
+        }
+    });
+}

src/ui/results_panel/plot.rs

@@ -0,0 +1,106 @@
+use crate::ui::constants::*;
+use crate::ui::helpers::{color_for_size, get_size_label};
+use crate::ui::types::{PlotMetric, ResultsPanelParams, TestResults};
+use eframe::egui;
+use egui_plot::{Corner, Legend, Line, Plot, PlotPoints};
+
+pub fn render_plot_column(
+    ui: &mut egui::Ui,
+    heading: &str,
+    plot_id: &'static str,
+    metric: PlotMetric,
+    params: &ResultsPanelParams<'_>,
+    width: f32,
+    height: f32,
+) {
+    ui.heading(heading);
+    ui.add_space(6.0);
+    render_plot(
+        ui,
+        plot_id,
+        params.results,
+        metric,
+        params.duration,
+        width,
+        height,
+    );
+}
+
+fn base_plot(id: &'static str, duration: u64, width: f32, height: f32) -> Plot<'static> {
+    Plot::new(id)
+        .height(height)
+        .width(width)
+        .include_x(0.0)
+        .include_x(duration as f64)
+        .show_grid(PLOT_SHOW_GRID)
+        .allow_drag(PLOT_ALLOW_DRAG)
+        .allow_zoom(PLOT_ALLOW_ZOOM)
+        .allow_scroll(PLOT_ALLOW_SCROLL)
+        .allow_boxed_zoom(PLOT_ALLOW_BOXED_ZOOM)
+        .allow_double_click_reset(PLOT_ALLOW_DOUBLE_CLICK_RESET)
+}
+
+fn y_range_for(results: &TestResults, metric: PlotMetric) -> (f64, f64) {
+    let mut min_v: Option<f64> = None;
+    let mut max_v: Option<f64> = None;
+    if let Ok(results) = results.lock() {
+        for (_, (throughput_points, reads_points, latency_points)) in results.iter() {
+            let pts: &Vec<(f64, f64)> = match metric {
+                PlotMetric::Throughput => throughput_points,
+                PlotMetric::Reads => reads_points,
+                PlotMetric::Latency => latency_points,
+            };
+            for &(_, y) in pts.iter() {
+                min_v = Some(min_v.map_or(y, |m| m.min(y)));
+                max_v = Some(max_v.map_or(y, |m| m.max(y)));
+            }
+        }
+    }
+    match (min_v, max_v) {
+        (Some(miny), Some(maxy)) if maxy > miny => {
+            let range = maxy - miny;
+            (miny - 0.1 * range, maxy + 0.1 * range)
+        }
+        _ => (0.0, 1.0),
+    }
+}
+
+fn render_plot(
+    ui: &mut egui::Ui,
+    plot_id: &'static str,
+    results: &TestResults,
+    metric: PlotMetric,
+    duration: u64,
+    width: f32,
+    height: f32,
+) {
+    let (y_min, y_max) = y_range_for(results, metric);
+    base_plot(plot_id, duration, width, height)
+        .include_y(y_min)
+        .include_y(y_max)
+        .legend(Legend::default().position(Corner::RightTop))
+        .show(ui, |plot_ui| {
+            if let Ok(results) = results.lock() {
+                let mut sorted_results: Vec<_> = results.iter().collect();
+                sorted_results.sort_by(|a, b| b.0.cmp(&a.0));
+                for (read_size, (throughput_points, reads_points, latency_points)) in sorted_results
+                {
+                    let points = match metric {
+                        PlotMetric::Throughput => throughput_points,
+                        PlotMetric::Reads => reads_points,
+                        PlotMetric::Latency => latency_points,
+                    };
+                    if !points.is_empty() {
+                        let color = color_for_size(*read_size);
+                        let plot_points: PlotPoints<'_> =
+                            points.iter().map(|&(x, y)| [x, y]).collect();
+                        plot_ui.line(
+                            Line::new(get_size_label(*read_size), plot_points)
+                                .color(color)
+                                .width(2.0),
+                        );
+                    }
+                }
+            }
+        });
+}