Struct EventKind 

pub struct EventKind(pub u64);

Bitflags describing the categories an event belongs to.

A single PlotEvent may have several bits set. For example a “click that set a measurement point” would have both CLICK and MEASUREMENT_POINT set.

Tuple Fields

0: u64

Implementations

impl EventKind

pub const CLICK: Self

A single (primary) click anywhere on a scope plot.

pub const DOUBLE_CLICK: Self

A double-click on a scope plot (the second click is also a CLICK).

pub const CLICK_ON_TRACE: Self

A click that landed on (or snapped to) a specific curve/trace.

pub const PAUSE: Self

The scope was paused (either by click or programmatically).

pub const RESUME: Self

The scope was resumed.

pub const MEASUREMENT_POINT: Self

A measurement marker point was set (P1 or P2).

pub const MEASUREMENT_COMPLETE: Self

A full measurement (both P1 and P2) is now available.

pub const MEASUREMENT_CLEARED: Self

A measurement was cleared.

pub const TRACE_SHOWN: Self

A trace was shown.

pub const TRACE_HIDDEN: Self

A trace was hidden.

pub const TRACE_COLOR_CHANGED: Self

A trace colour was changed.

pub const MATH_TRACE_ADDED: Self

A math trace was added.

pub const MATH_TRACE_REMOVED: Self

A math trace was removed.

pub const ZOOM: Self

The view was zoomed (scroll-wheel, box-zoom, or programmatic).

pub const FIT_TO_VIEW: Self

The view was fit-to-data (auto-fit or button).

pub const PAN: Self

The view was panned.

pub const RESIZE: Self

The plot widget was resized.

pub const DATA_UPDATED: Self

New data points were received for one or more traces.

pub const DATA_CLEARED: Self

All trace data was cleared.

pub const THRESHOLD_EXCEEDED: Self

A threshold event was detected (threshold exceeded condition met).

pub const THRESHOLD_ADDED: Self

A threshold definition was added.

pub const THRESHOLD_REMOVED: Self

A threshold definition was removed.

pub const KEY_PRESSED: Self

A keyboard key was pressed inside the plot area.

pub const EXPORT: Self

An export (CSV/Parquet) was initiated.

pub const SCREENSHOT: Self

A screenshot was taken.

pub const SCOPE_ADDED: Self

A scope was added.

pub const SCOPE_REMOVED: Self

A scope was removed.

pub const TRIGGER_FIRED: Self

A trigger fired.

pub const TRACE_OFFSET_CHANGED: Self

A trace Y-offset was changed.

pub const Y_LOG_CHANGED: Self

Y-axis log mode was toggled.

pub const Y_UNIT_CHANGED: Self

Y-axis unit was changed.

pub const ALL: Self

Wildcard: matches every event kind.

pub const fn union(self, other: Self) -> Self

Combine two event kinds (bitwise OR).

pub const fn contains(self, other: Self) -> bool

Check whether self contains all bits in other.

Examples found in repository

examples/events_advanced.rs (line 34)

fn main() -> eframe::Result<()> {
    // Subscribe to ALL events.
    let event_ctrl = EventController::new();
    let rx = event_ctrl.subscribe(EventFilter::all());

    // Background thread: pretty-print every event.
    std::thread::spawn(move || {
        while let Ok(evt) = rx.recv() {
            let k = evt.kinds;

            // ── Click / Double-click ──────────────────────────────────────
            if k.contains(EventKind::CLICK) || k.contains(EventKind::DOUBLE_CLICK) {
                let label = if k.contains(EventKind::DOUBLE_CLICK) {
                    "DOUBLE_CLICK"
                } else {
                    "CLICK"
                };
                if let Some(c) = &evt.click {
                    // coordinates are optional but should exist for click events
                    let (px, py) = if let Some(p) = c.plot_pos {
                        (p.x, p.y)
                    } else {
                        (f64::NAN, f64::NAN)
                    };
                    let (sx, sy) = if let Some(s) = c.screen_pos {
                        (s.x, s.y)
                    } else {
                        (f32::NAN, f32::NAN)
                    };
                    println!(
                        "[{label}] plot=({:.4},{:.4})  screen=({:.1},{:.1})  scope={}",
                        px,
                        py,
                        sx,
                        sy,
                        c.scope_id.map_or("?".into(), |id| id.to_string()),
                    );
                } else {
                    println!("[{label}]");
                }
            }

            // ── Pause / Resume ────────────────────────────────────────────
            if k.contains(EventKind::PAUSE) || k.contains(EventKind::RESUME) {
                let label = if k.contains(EventKind::RESUME) {
                    "RESUME"
                } else {
                    "PAUSE"
                };
                if let Some(p) = &evt.pause {
                    println!("[{label}] scope={}", p.scope_id.unwrap_or(0));
                } else {
                    println!("[{label}]");
                }
            }

            // ── Zoom / Pan / Fit-to-View ──────────────────────────────────
            if k.contains(EventKind::ZOOM)
                || k.contains(EventKind::PAN)
                || k.contains(EventKind::FIT_TO_VIEW)
            {
                let label = if k.contains(EventKind::FIT_TO_VIEW) {
                    "FIT_TO_VIEW"
                } else if k.contains(EventKind::ZOOM) {
                    "ZOOM"
                } else {
                    "PAN"
                };
                if let Some(v) = &evt.view_change {
                    println!(
                        "[{label}] x={:?}  y={:?}  scope={}",
                        v.x_range,
                        v.y_range,
                        v.scope_id.map_or("?".into(), |id| id.to_string()),
                    );
                } else {
                    println!("[{label}]");
                }
            }

            // ── Measurement ───────────────────────────────────────────────
            if k.contains(EventKind::MEASUREMENT_POINT) {
                let complete = k.contains(EventKind::MEASUREMENT_COMPLETE);
                if let Some(m) = &evt.measurement {
                    println!(
                        "[MEASUREMENT{}] name={:?} point=({:.4},{:.4}) p1={:?} p2={:?} slope={:?} dist={:?}",
                        if complete { " COMPLETE" } else { "" },
                        m.measurement_name,
                        m.point[0], m.point[1],
                        m.p1, m.p2, m.slope, m.distance,
                    );
                }
            }
            if k.contains(EventKind::MEASUREMENT_CLEARED) {
                println!("[MEASUREMENT_CLEARED]");
            }

            // ── Resize ────────────────────────────────────────────────────
            if k.contains(EventKind::RESIZE) {
                if let Some(r) = &evt.resize {
                    println!("[RESIZE] {}×{}", r.width as u32, r.height as u32);
                }
            }

            // ── Key press ─────────────────────────────────────────────────
            if k.contains(EventKind::KEY_PRESSED) {
                if let Some(kp) = &evt.key_press {
                    println!(
                        "[KEY] {:?}  ctrl={} alt={} shift={} cmd={}",
                        kp.key,
                        kp.modifiers.ctrl,
                        kp.modifiers.alt,
                        kp.modifiers.shift,
                        kp.modifiers.command,
                    );
                }
            }

            // ── Data update ───────────────────────────────────────────────
            if k.contains(EventKind::DATA_UPDATED) {
                if let Some(d) = &evt.data_update {
                    println!("[DATA_UPDATED] traces={:?}", d.traces);
                }
            }

            // ── Trace visibility / colour / offset ────────────────────────
            if k.contains(EventKind::TRACE_SHOWN) || k.contains(EventKind::TRACE_HIDDEN) {
                if let Some(t) = &evt.trace {
                    println!(
                        "[TRACE_{}] {:?} visible={:?}",
                        if k.contains(EventKind::TRACE_SHOWN) {
                            "SHOWN"
                        } else {
                            "HIDDEN"
                        },
                        t.trace.0,
                        t.visible,
                    );
                }
            }
            if k.contains(EventKind::TRACE_COLOR_CHANGED) {
                if let Some(t) = &evt.trace {
                    println!("[TRACE_COLOR] {:?} rgb={:?}", t.trace.0, t.color_rgb);
                }
            }
            if k.contains(EventKind::TRACE_OFFSET_CHANGED) {
                if let Some(t) = &evt.trace {
                    println!("[TRACE_OFFSET] {:?} offset={:?}", t.trace.0, t.offset);
                }
            }

            // ── Math trace ────────────────────────────────────────────────
            if k.contains(EventKind::MATH_TRACE_ADDED) {
                if let Some(m) = &evt.math_trace {
                    println!("[MATH_TRACE_ADDED] {:?} formula={:?}", m.name, m.formula);
                }
            }
            if k.contains(EventKind::MATH_TRACE_REMOVED) {
                if let Some(m) = &evt.math_trace {
                    println!("[MATH_TRACE_REMOVED] {:?}", m.name);
                }
            }

            // ── Threshold ─────────────────────────────────────────────────
            if k.contains(EventKind::THRESHOLD_EXCEEDED) {
                if let Some(t) = &evt.threshold {
                    println!(
                        "[THRESHOLD_EXCEEDED] {:?} trace={:?} area={:?}",
                        t.threshold_name, t.trace, t.area,
                    );
                }
            }
            if k.contains(EventKind::THRESHOLD_REMOVED) {
                if let Some(t) = &evt.threshold {
                    println!("[THRESHOLD_REMOVED] {:?}", t.threshold_name);
                }
            }

            // ── Export / Screenshot ───────────────────────────────────────
            if k.contains(EventKind::EXPORT) || k.contains(EventKind::SCREENSHOT) {
                let label = if k.contains(EventKind::SCREENSHOT) {
                    "SCREENSHOT"
                } else {
                    "EXPORT"
                };
                if let Some(e) = &evt.export {
                    println!("[{label}] format={:?} path={:?}", e.format, e.path);
                }
            }

            // ── Scope management ──────────────────────────────────────────
            if k.contains(EventKind::SCOPE_ADDED) {
                if let Some(s) = &evt.scope_manage {
                    println!("[SCOPE_ADDED] id={}", s.scope_id);
                }
            }
            if k.contains(EventKind::SCOPE_REMOVED) {
                if let Some(s) = &evt.scope_manage {
                    println!("[SCOPE_REMOVED] id={}", s.scope_id);
                }
            }
        }
        println!("[event] channel closed");
    });

    // Set up a sine + cosine trace so there is data to interact with.
    let (sink, data_rx) = channel_plot();
    let t_sin = sink.create_trace("sin", Some("Sine"));
    let t_cos = sink.create_trace("cos", Some("Cosine"));

    std::thread::spawn(move || {
        let dt = Duration::from_millis(1);
        loop {
            let t_s = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .map(|d| d.as_secs_f64())
                .unwrap_or(0.0);
            let _ = sink.send_point(
                &t_sin,
                PlotPoint {
                    x: t_s,
                    y: (2.0 * std::f64::consts::PI * 2.0 * t_s).sin(),
                },
            );
            let _ = sink.send_point(
                &t_cos,
                PlotPoint {
                    x: t_s,
                    y: (2.0 * std::f64::consts::PI * 2.0 * t_s).cos(),
                },
            );
            std::thread::sleep(dt);
        }
    });

    let mut cfg = LivePlotConfig::default();
    cfg.controllers.event = Some(event_ctrl);

    run_liveplot(data_rx, cfg)
}

pub const fn intersects(self, other: Self) -> bool

Check whether self intersects with other (at least one bit in common).

pub const fn is_empty(self) -> bool

Returns true if no bits are set.

Trait Implementations

impl BitAnd for EventKind

type Output = EventKind

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self

Performs the & operation.

impl BitOr for EventKind

type Output = EventKind

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl BitOrAssign for EventKind

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for EventKind

fn clone(&self) -> EventKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for EventKind

impl Debug for EventKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for EventKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for EventKind

impl Hash for EventKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Not for EventKind

type Output = EventKind

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl PartialEq for EventKind

fn eq(&self, other: &EventKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for EventKind