Struct LivePlotPanel 

pub struct LivePlotPanel {

    pub traces_data: TracesCollection,
    pub overlays: Option<Box<dyn for<'a> FnMut(&mut PlotUi<'_>, &ScopeData, &TracesCollection) + 'static>>,
    pub hotkeys: Rc<RefCell<Hotkeys>>,
    pub liveplot_panel: LiveplotPanel,
    pub right_side_panels: Vec<Box<dyn Panel>>,
    pub left_side_panels: Vec<Box<dyn Panel>>,
    pub bottom_panels: Vec<Box<dyn Panel>>,
    pub detached_panels: Vec<Box<dyn Panel>>,
    pub empty_panels: Vec<Box<dyn Panel>>,
    pub pending_requests: LivePlotRequests,
    pub top_bar_buttons: Option<Vec<ScopeButton>>,
    pub sidebar_buttons: Option<Vec<ScopeButton>>,
    pub min_height_for_top_bar: f32,
    pub min_width_for_sidebar: f32,
    pub min_height_for_sidebar: f32,
    pub compact: bool,
    /* private fields */
}

The central widget that owns trace data, panels, and the live-plot scope(s).

LivePlotPanel is the building block of the LivePlot UI. It can be used:

• Standalone – wrapped inside LivePlotApp and driven by the eframe event loop.
• Embedded – placed inside a parent egui application via LivePlotPanel::update or LivePlotPanel::update_embedded.

Fields

The struct holds:

• All trace and scope data (traces_data, liveplot_panel).
• A set of configurable sub-panels (traces list, math, thresholds, …).
• Optional controllers that allow programmatic interaction from external code (e.g. pause, export, change colours).
• Responsive-layout parameters that control when the top-bar or sidebar collapse.

Fields

traces_data: TracesCollection

Collection of all traces (time-series data) received through the command channel.

overlays: Option<Box<dyn for<'a> FnMut(&mut PlotUi<'_>, &ScopeData, &TracesCollection) + 'static>>

Optional plot overlay callback, supplied via configuration.

hotkeys: Rc<RefCell<Hotkeys>>

Shared hotkey bindings used by all panels and menu buttons.

liveplot_panel: LiveplotPanel

The primary live-plot panel that renders scope(s) with traces.

right_side_panels: Vec<Box<dyn Panel>>

Panels docked to the right side of the plot area.

left_side_panels: Vec<Box<dyn Panel>>

Panels docked to the left side of the plot area.

bottom_panels: Vec<Box<dyn Panel>>

Panels docked to the bottom of the plot area (e.g. FFT).

detached_panels: Vec<Box<dyn Panel>>

Panels shown in detached (floating) windows.

empty_panels: Vec<Box<dyn Panel>>

Panels that exist but are not rendered in any dock position (e.g. export dialog).

pending_requests: LivePlotRequests

Pending requests (save/load state, add/remove scope) accumulated during one frame.

top_bar_buttons: Option<Vec<ScopeButton>>

Buttons placed in the top menu bar. None = the full default set.

sidebar_buttons: Option<Vec<ScopeButton>>

Buttons placed in the right sidebar icon strip. None = empty (standard behaviour).

min_height_for_top_bar: f32

Minimum plot-area height (px) before the top bar is hidden and its buttons move to sidebar.

min_width_for_sidebar: f32

Minimum plot-area width (px) before the sidebar is hidden and its buttons move to top bar.

min_height_for_sidebar: f32

Minimum plot-area height (px) before the sidebar is hidden and its buttons move to top bar.

compact: bool

When true, the inner CentralPanel is rendered with no frame/margin so the plot fills every pixel of the allocated space. Useful for dense embedded grid layouts.

Implementations

impl LivePlotPanel

pub fn apply_controllers_embedded(&mut self, ctx: &Context)

Apply controller requests and publish state, for embedded usage (no stand-alone window frame).

This method handles all optional controllers:

• WindowController – publishes viewport size/position, applies resize requests.
• UiActionController – pause/resume, screenshot, raw data export.
• TracesController – colour, visibility, offset, width, style changes; publishes the current trace snapshot.
• ScopesController – add/remove/configure scopes.
• LiveplotController – pause all, clear all, save/load state, window commands.
• FFTController – publishes FFT panel info.
• ThresholdController – threshold add/remove and event publishing (via [apply_threshold_controller_requests] and [publish_threshold_events]).

impl LivePlotPanel

pub fn hide_hotkeys_panel(&mut self)

Hide the Hotkeys panel (useful when focus switches away via hotkeys).

impl LivePlotPanel

pub fn update(&mut self, ui: &mut Ui)

Main per-frame update: ingest data, render menu / side panels, then draw the plot.

Call this from an egui Ui context each frame. In standalone mode it is called by LivePlotApp::update; in embedded mode the host application calls it directly (or via update_embedded).

pub fn update_embedded(&mut self, ui: &mut Ui)

Update and render the panel when embedded in a parent app, then apply controllers.

This is the convenience entry point for embedded use: it calls update followed by apply_controllers_embedded.

Examples found in repository

examples/embedded_tiles.rs (line 152)

    fn render_dashboard(&mut self, ui: &mut egui::Ui) {
        let cols = 2;
        let rows = (self.panels.len() + cols - 1) / cols;
        let avail = ui.available_size();
        let cell_w = avail.x / cols as f32;
        let cell_h = avail.y / rows as f32;

        egui::Grid::new("embedded_dashboard_grid")
            .num_columns(cols)
            .spacing([0.0, 0.0])
            .show(ui, |ui| {
                for (idx, (_panel, plot)) in self.panels.iter_mut().enumerate() {
                    let (_, rect) = ui.allocate_space(egui::vec2(cell_w, cell_h));
                    let mut child_ui = ui.new_child(egui::UiBuilder::new().max_rect(rect));
                    plot.update_embedded(&mut child_ui);

                    if idx % cols == cols - 1 {
                        ui.end_row();
                    }
                }
            });
    }

examples/color_scheme.rs (line 74)

    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // Apply color scheme
        self.scheme.apply(ctx);

        egui::TopBottomPanel::top("color_scheme_picker_top").show(ctx, |ui| {
            ui.horizontal(|ui| {
                ui.label("Color scheme:");
                ComboBox::from_id_salt("color_scheme_picker")
                    .selected_text(self.scheme.label())
                    .show_ui(ui, |ui| {
                        for scheme in ColorScheme::all() {
                            let label = scheme.label();
                            if ui.selectable_label(self.scheme == *scheme, label).clicked() {
                                self.scheme = scheme.clone();
                            }
                        }
                    });
            });
        });

        egui::CentralPanel::default().show(ctx, |ui| {
            self.plot.main_panel.update_embedded(ui);
        });

        ctx.request_repaint_after(std::time::Duration::from_millis(16));
    }

examples/lots_of_tiny_plots.rs (line 162)

    fn render_grid(&mut self, ui: &mut egui::Ui) {
        // Claim the entire remaining area so the grid fills and resizes with the window.
        let avail = ui.available_size();
        let (grid_rect, _) = ui.allocate_exact_size(avail, egui::Sense::hover());

        // Floor to whole pixels; use the grid_rect origin for pixel-aligned placement.
        let cell_w = (grid_rect.width() / COLS as f32).floor().max(1.0);
        let cell_h = (grid_rect.height() / ROWS as f32).floor().max(1.0);

        for row in 0..ROWS {
            for col in 0..COLS {
                let idx = row * COLS + col;
                let x = (grid_rect.left() + col as f32 * cell_w).round();
                let y = (grid_rect.top() + row as f32 * cell_h).round();
                let cell_rect =
                    egui::Rect::from_min_size(egui::pos2(x, y), egui::vec2(cell_w, cell_h));
                let (_p, panel) = &mut self.plots[idx];
                let mut child_ui =
                    ui.new_child(egui::UiBuilder::new().id_salt(idx).max_rect(cell_rect));
                panel.update_embedded(&mut child_ui);
            }
        }
    }

examples/features.rs (line 311)

    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // data is produced on a background thread; nothing to do here

        // draw checkboxes at the top
        egui::TopBottomPanel::top("features_top").show(ctx, |ui| {
            ui.label("Toggle features:");
            ui.horizontal_wrapped(|ui| {
                ui.checkbox(&mut self.features.top_bar, "top_bar");
                ui.checkbox(&mut self.features.sidebar, "sidebar");
                ui.checkbox(&mut self.features.markers, "markers");
                ui.checkbox(&mut self.features.thresholds, "thresholds");
                ui.checkbox(&mut self.features.triggers, "triggers");
                ui.checkbox(&mut self.features.measurement, "measurement");
                ui.checkbox(&mut self.features.export, "export");
                ui.checkbox(&mut self.features.math, "math");
                ui.checkbox(&mut self.features.hotkeys, "hotkeys");
                ui.checkbox(&mut self.features.fft, "fft");
                ui.checkbox(&mut self.features.x_tick_labels, "x_tick_labels");
                ui.checkbox(&mut self.features.y_tick_labels, "y_tick_labels");
                ui.checkbox(&mut self.features.grid, "grid");
                ui.checkbox(&mut self.features.legend, "legend");
                ui.checkbox(&mut self.features.scopes, "scopes");
                ui.checkbox(&mut self.features.pause_resume, "pause_resume");
                ui.checkbox(&mut self.features.clear_all, "clear_all");
            });
        });

        // Apply flags every frame (cost negligible)
        self.apply_features();

        // render the plot panel
        egui::CentralPanel::default().show(ctx, |ui| {
            self.plot.main_panel.update_embedded(ui);
        });

        // keep redrawing at roughly 60Hz
        ctx.request_repaint_after(Duration::from_millis(16));
    }

examples/embedded_window.rs (line 89)

    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| {
            ui.heading("Embedding LivePlot in egui::Window");
            ui.horizontal(|ui| {
                ui.label("Select wave:");
                egui::ComboBox::from_id_salt("wave_select")
                    .selected_text(match self.kind {
                        WaveKind::Sine => "Sine",
                        WaveKind::Cosine => "Cosine",
                    })
                    .show_ui(ui, |ui| {
                        ui.selectable_value(&mut self.kind, WaveKind::Sine, "Sine");
                        ui.selectable_value(&mut self.kind, WaveKind::Cosine, "Cosine");
                    });
                if ui.button("Open Plot Window").clicked() {
                    self.show_plot_window = true;
                }
            });
            ui.separator();
            ui.label("Pick a wave and click the button to open the embedded LivePlot window.");
        });

        // Show the embedded plot in its own egui::Window when requested
        if self.show_plot_window {
            let mut open = true;
            egui::Window::new("LivePlot Window")
                .open(&mut open)
                .show(ctx, |ui| {
                    // Optional minimal size for nicer layout
                    ui.set_min_size(egui::vec2(600.0, 300.0));
                    self.plot.main_panel.update_embedded(ui);
                });
            if !open {
                self.show_plot_window = false;
            }
        }

        // Feed the chosen wave
        let now_us = chrono::Utc::now().timestamp_micros();
        let t = (now_us as f64) * 1e-6;
        let phase = t * 2.0 * std::f64::consts::PI;
        let val = match self.kind {
            WaveKind::Sine => phase.sin(),
            WaveKind::Cosine => phase.cos(),
        };
        let tr = match self.kind {
            WaveKind::Sine => &self.trace_sine,
            WaveKind::Cosine => &self.trace_cos,
        };
        let _ = self.sink.send_point(tr, PlotPoint { x: t, y: val });

        ctx.request_repaint_after(Duration::from_millis(16));
    }

pub fn fit_all_bounds(&mut self)

Programmatically trigger “Fit to View” (both X and Y axes) on every scope.

Call this e.g. after a window resize to ensure all plots fill their bounds.

Examples found in repository

examples/lots_of_tiny_plots.rs (line 189)

    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // use wall-clock time as sample x
        let now_us = chrono::Utc::now().timestamp_micros();
        let t = (now_us as f64) * 1e-6;
        // generate samples at configured rate; each sample uses the sine frequency
        let sample_interval = 1.0 / self.samples_per_second;
        let mut next_time = self.last_sample_time + sample_interval;
        while next_time <= t {
            for (p, _) in &self.plots {
                p.feed(next_time, self.sine_hz);
            }
            // advance last_sample_time by one interval per sample generated
            self.last_sample_time = next_time;
            next_time += sample_interval;
        }

        // Detect window resizes and auto-fit all plots when the size changes.
        let current_size = ctx.input(|i| i.viewport_rect().size());
        if self.last_window_size != egui::Vec2::ZERO && self.last_window_size != current_size {
            for (_p, panel) in &mut self.plots {
                panel.fit_all_bounds();
            }
        }
        self.last_window_size = current_size;

        egui::CentralPanel::default().show(ctx, |ui| {
            ui.heading("Lots of tiny sine plots — 20 × 15");
            ui.label(format!(
                "Each plot shows the same sine wave shifted by phase; every trace has its own color. — samples: {:.1} Hz, sine: {:.3} Hz",
                self.samples_per_second,
                self.sine_hz
            ));
            ui.add_space(6.0);
            self.render_grid(ui);
        });

        ctx.request_repaint_after(Duration::from_millis(UPDATE_MS));
    }

impl LivePlotPanel

pub fn new(rx: Receiver<PlotCommand>) -> Self

Create a new LivePlotPanel that will receive PlotCommands from the given channel.

The panel is pre-populated with the default set of sub-panels:

• Right: Traces, Math, Hotkeys, Thresholds, Triggers, Measurement
• Bottom: FFT (when the fft feature is enabled)
• Hidden: Export

Examples found in repository

examples/embedded_tiles.rs (line 44)

    fn new(
        label: &'static str,
        wave: PanelWave,
        freq_hz: f64,
        phase_cycles: f64,
        color_rgb: Option<[u8; 3]>,
    ) -> (Self, LivePlotPanel) {
        let (sink, rx) = channel_plot();
        let trace = sink.create_trace(label, None);
        let mut plot = LivePlotPanel::new(rx);
        for scope in plot.liveplot_panel.get_data_mut() {
            scope.time_window = 8.0;
        }
        plot.traces_data.max_points = 5_000;
        plot.liveplot_panel.update_data(&plot.traces_data);
        // Attach a per-plot traces controller so we can request a custom color
        let ctrl = TracesController::new();
        plot.set_controllers(None, None, Some(ctrl.clone()), None, None, None, None);

        // If a color hint is supplied, request it via the traces controller (applied during tick)
        if let Some(rgb) = color_rgb {
            ctrl.request_set_color(label, rgb);
        }

        let panel = Self {
            wave,
            freq_hz,
            phase_cycles,
            sink,
            trace,
        };
        (panel, plot)
    }

examples/lots_of_tiny_plots.rs (line 68)

    fn new(label: &str, phase_cycles: f64, color_hint: [u8; 3]) -> (Self, LivePlotPanel) {
        let (sink, rx) = channel_plot();
        let trace = sink.create_trace(label, None);

        let mut panel = LivePlotPanel::new(rx);
        // keep buffers small for many plots
        panel.traces_data.max_points = 2_000;
        // strip all borders/margins so each cell is pure plot
        panel.compact = true;
        // suppress top-bar buttons so nothing competes for the tiny space
        panel.top_bar_buttons = Some(vec![]);
        panel.sidebar_buttons = Some(vec![]);
        panel.min_height_for_top_bar = 0.0;
        panel.min_width_for_sidebar = 0.0;
        panel.min_height_for_sidebar = 0.0;
        for s in panel.liveplot_panel.get_data_mut() {
            s.time_window = 4.0;
            // Force-hide the legend overlay to avoid wasting space in tiny cells
            s.force_hide_legend = true;
        }

        // Attach a traces controller so we can request a color for this trace
        let ctrl = TracesController::new();
        panel.set_controllers(None, None, Some(ctrl.clone()), None, None, None, None);
        ctrl.request_set_color(label, color_hint);

        (
            Self {
                sink,
                trace,
                phase_cycles,
            },
            panel,
        )
    }

pub fn set_controllers( &mut self, window_ctrl: Option<WindowController>, ui_ctrl: Option<UiActionController>, traces_ctrl: Option<TracesController>, scopes_ctrl: Option<ScopesController>, liveplot_ctrl: Option<LiveplotController>, fft_ctrl: Option<FFTController>, threshold_ctrl: Option<ThresholdController>, )

Attach controllers for embedded usage.

These mirror the controllers used by LivePlotApp; call this once after construction to enable programmatic interaction from external code.

Examples found in repository

examples/embedded_tiles.rs (line 52)

    fn new(
        label: &'static str,
        wave: PanelWave,
        freq_hz: f64,
        phase_cycles: f64,
        color_rgb: Option<[u8; 3]>,
    ) -> (Self, LivePlotPanel) {
        let (sink, rx) = channel_plot();
        let trace = sink.create_trace(label, None);
        let mut plot = LivePlotPanel::new(rx);
        for scope in plot.liveplot_panel.get_data_mut() {
            scope.time_window = 8.0;
        }
        plot.traces_data.max_points = 5_000;
        plot.liveplot_panel.update_data(&plot.traces_data);
        // Attach a per-plot traces controller so we can request a custom color
        let ctrl = TracesController::new();
        plot.set_controllers(None, None, Some(ctrl.clone()), None, None, None, None);

        // If a color hint is supplied, request it via the traces controller (applied during tick)
        if let Some(rgb) = color_rgb {
            ctrl.request_set_color(label, rgb);
        }

        let panel = Self {
            wave,
            freq_hz,
            phase_cycles,
            sink,
            trace,
        };
        (panel, plot)
    }

examples/lots_of_tiny_plots.rs (line 87)

    fn new(label: &str, phase_cycles: f64, color_hint: [u8; 3]) -> (Self, LivePlotPanel) {
        let (sink, rx) = channel_plot();
        let trace = sink.create_trace(label, None);

        let mut panel = LivePlotPanel::new(rx);
        // keep buffers small for many plots
        panel.traces_data.max_points = 2_000;
        // strip all borders/margins so each cell is pure plot
        panel.compact = true;
        // suppress top-bar buttons so nothing competes for the tiny space
        panel.top_bar_buttons = Some(vec![]);
        panel.sidebar_buttons = Some(vec![]);
        panel.min_height_for_top_bar = 0.0;
        panel.min_width_for_sidebar = 0.0;
        panel.min_height_for_sidebar = 0.0;
        for s in panel.liveplot_panel.get_data_mut() {
            s.time_window = 4.0;
            // Force-hide the legend overlay to avoid wasting space in tiny cells
            s.force_hide_legend = true;
        }

        // Attach a traces controller so we can request a color for this trace
        let ctrl = TracesController::new();
        panel.set_controllers(None, None, Some(ctrl.clone()), None, None, None, None);
        ctrl.request_set_color(label, color_hint);

        (
            Self {
                sink,
                trace,
                phase_cycles,
            },
            panel,
        )
    }

pub fn set_event_controller(&mut self, event_ctrl: Option<EventController>)

Attach an event controller for event dispatch.