Struct LivePlotApp 

pub struct LivePlotApp {
    pub main_panel: LivePlotPanel,
    pub window_ctrl: Option<WindowController>,
    pub ui_ctrl: Option<UiActionController>,
    pub traces_ctrl: Option<TracesController>,
    pub scopes_ctrl: Option<ScopesController>,
    pub liveplot_ctrl: Option<LiveplotController>,
    pub fft_ctrl: Option<FFTController>,
    pub threshold_ctrl: Option<ThresholdController>,
    pub headline: Option<String>,
    pub subheadline: Option<String>,
    pub color_scheme: Option<ColorScheme>,
    /* private fields */
}

Standalone LivePlot application that implements eframe::App.

LivePlotApp is the top-level container used when LivePlot runs in its own native window (via run_liveplot). It:

1. Owns a LivePlotPanel that does the actual rendering.
2. Holds optional controller handles for programmatic interaction.
3. Processes controller requests each frame in apply_controllers.
4. Applies initial configuration from LivePlotConfig.

Fields

main_panel: LivePlotPanel

The inner panel widget that owns all data and UI state.

window_ctrl: Option<WindowController>

Controls the host window (size, position).

ui_ctrl: Option<UiActionController>

Programmatic UI actions (pause, screenshot, export).

traces_ctrl: Option<TracesController>

Programmatic trace manipulation (colour, visibility, offset, etc.).

scopes_ctrl: Option<ScopesController>

Programmatic scope management (add/remove/configure scopes).

liveplot_ctrl: Option<LiveplotController>

High-level liveplot control (pause all, clear all, save/load state).

fft_ctrl: Option<FFTController>

FFT panel control (show/hide, resize).

threshold_ctrl: Option<ThresholdController>

Threshold management (add/remove thresholds, listen for threshold events).

headline: Option<String>

Optional heading text shown at the top of the window.

subheadline: Option<String>

Optional sub-heading text shown below the headline.

color_scheme: Option<ColorScheme>

Color scheme to apply to the egui context. Applied once on the first frame.

Implementations

impl LivePlotApp

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

Create a new LivePlotApp without any controllers.

Examples found in repository

examples/embedded_window.rs (line 41)

    fn new() -> Self {
        let (sink, rx) = channel_plot();
        let trace_sine = sink.create_trace("sine", None);
        let trace_cos = sink.create_trace("cosine", None);
        let mut plot = LivePlotApp::new(rx);
        // Configure the embedded main panel's data
        for scope in plot.main_panel.liveplot_panel.get_data_mut() {
            scope.time_window = 10.0;
        }
        plot.main_panel.traces_data.max_points = 10_000;
        Self {
            kind: WaveKind::Sine,
            sink,
            trace_sine,
            trace_cos,
            plot,
            show_plot_window: false,
        }
    }

examples/color_scheme.rs (line 112)

fn main() -> eframe::Result<()> {
    let scheme = std::env::args()
        .nth(1)
        .map(|a| parse_scheme(&a))
        .unwrap_or(ColorScheme::Dark);

    let (sink, rx) = channel_plot();
    let tr_sine = sink.create_trace("sine", None);
    let tr_cos = sink.create_trace("cosine", None);

    // Producer: 1 kHz, 3 Hz sine + cosine
    std::thread::spawn(move || {
        const FS_HZ: f64 = 1000.0;
        const F_HZ: f64 = 3.0;
        let dt = Duration::from_millis(1);
        let mut n: u64 = 0;
        loop {
            let t = n as f64 / FS_HZ;
            let s_val = (2.0 * std::f64::consts::PI * F_HZ * t).sin();
            let c_val = (2.0 * std::f64::consts::PI * F_HZ * t).cos();
            let t_s = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .map(|d| d.as_secs_f64())
                .unwrap_or(0.0);
            let _ = sink.send_point(&tr_sine, PlotPoint { x: t_s, y: s_val });
            let _ = sink.send_point(&tr_cos, PlotPoint { x: t_s, y: c_val });
            n = n.wrapping_add(1);
            std::thread::sleep(dt);
        }
    });

    let plot = LivePlotApp::new(rx);
    let app = ColorSchemePickerApp { scheme, plot };

    eframe::run_native(
        "Color Scheme Demo",
        eframe::NativeOptions::default(),
        Box::new(|_cc| Ok(Box::new(app))),
    )
}

examples/features.rs (line 67)

    fn new() -> Self {
        // create shared sink/receiver pair and register traces
        let (sink, rx) = channel_plot();
        let tr_sine = sink.create_trace("sine", None);
        let tr_cos = sink.create_trace("cosine", None);

        // spawn the producer thread (1 kHz sample rate as in sine_cosine.rs)
        let sink_clone = sink.clone();
        let sine_clone = tr_sine.clone();
        let cos_clone = tr_cos.clone();
        std::thread::spawn(move || {
            const FS_HZ: f64 = 1000.0;
            const F_HZ: f64 = 3.0;
            let dt = Duration::from_millis(1);
            let mut n: u64 = 0;
            loop {
                let t = n as f64 / FS_HZ;
                let s_val = (2.0 * std::f64::consts::PI * F_HZ * t).sin();
                let c_val = (2.0 * std::f64::consts::PI * F_HZ * t).cos();
                let t_s = SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .map(|d| d.as_secs_f64())
                    .unwrap_or(0.0);
                let _ = sink_clone.send_point(&sine_clone, PlotPoint { x: t_s, y: s_val });
                let _ = sink_clone.send_point(&cos_clone, PlotPoint { x: t_s, y: c_val });
                n = n.wrapping_add(1);
                std::thread::sleep(dt);
            }
        });

        let plot = LivePlotApp::new(rx);
        let features = FeatureFlags::default();

        Self {
            plot,
            features,
            _sink: sink,
            _tr_sine: tr_sine,
            _tr_cos: tr_cos,
        }
    }

pub fn with_controllers( rx: Receiver<PlotCommand>, 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>, ) -> Self

Create a new LivePlotApp with the given controller handles already wired.

Trait Implementations

impl App for LivePlotApp

fn update(&mut self, ctx: &Context, frame: &mut Frame)

Called each time the UI needs repainting, which may be many times per second.

fn save(&mut self, _storage: &mut dyn Storage)

Called on shutdown, and perhaps at regular intervals. Allows you to save state.

fn on_exit(&mut self, _gl: Option<&Context>)

Called once on shutdown, after Self::save.

fn auto_save_interval(&self) -> Duration

Time between automatic calls to Self::save

fn clear_color(&self, _visuals: &Visuals) -> [f32; 4]

Background color values for the app, e.g. what is sent to gl.clearColor.

fn persist_egui_memory(&self) -> bool

Controls whether or not the egui memory (window positions etc) will be persisted (only if the “persistence” feature is enabled).

fn raw_input_hook(&mut self, _ctx: &Context, _raw_input: &mut RawInput)

A hook for manipulating or filtering raw input before it is processed by Self::update.