Struct SpanTreeState 

pub struct SpanTreeState { /* private fields */ }

State for a SpanTree component.

Contains the root spans, selection state, expanded set, and layout configuration.

Example

use envision::component::{SpanTreeState, SpanNode};

let root = SpanNode::new("r", "root", 0.0, 1000.0)
    .with_child(SpanNode::new("c", "child", 100.0, 500.0));
let state = SpanTreeState::new(vec![root]);

assert_eq!(state.roots().len(), 1);
assert_eq!(state.global_start(), 0.0);
assert_eq!(state.global_end(), 1000.0);
assert_eq!(state.selected_index(), Some(0));

Implementations

impl SpanTreeState

pub fn new(roots: Vec<SpanNode>) -> Self

Creates a new span tree state with the given root spans.

All nodes with children start expanded. The first node is selected if the tree is non-empty.

Example

use envision::component::{SpanTreeState, SpanNode};

let root = SpanNode::new("r", "root", 0.0, 100.0)
    .with_child(SpanNode::new("c", "child", 10.0, 50.0));
let state = SpanTreeState::new(vec![root]);

assert_eq!(state.roots().len(), 1);
assert_eq!(state.selected_index(), Some(0));
assert_eq!(state.global_start(), 0.0);
assert_eq!(state.global_end(), 100.0);

pub fn with_title(self, title: impl Into<String>) -> Self

Sets the title (builder pattern).

Example

use envision::component::{SpanTreeState, SpanNode};

let state = SpanTreeState::new(vec![SpanNode::new("r", "root", 0.0, 10.0)])
    .with_title("Trace");
assert_eq!(state.title(), Some("Trace"));

pub fn with_label_width(self, width: u16) -> Self

Sets the label column width (builder pattern).

Example

use envision::component::{SpanTreeState, SpanNode};

let state = SpanTreeState::new(vec![SpanNode::new("r", "root", 0.0, 10.0)])
    .with_label_width(40);
assert_eq!(state.label_width(), 40);

pub fn roots(&self) -> &[SpanNode]

Returns the root spans.

Example

use envision::component::{SpanTreeState, SpanNode};

let state = SpanTreeState::new(vec![
    SpanNode::new("a", "svc-a", 0.0, 10.0),
    SpanNode::new("b", "svc-b", 5.0, 15.0),
]);
assert_eq!(state.roots().len(), 2);

pub fn roots_mut(&mut self) -> &mut Vec<SpanNode>

Returns a mutable reference to the root spans.

This is safe because span nodes are simple data containers. The expanded set tracks nodes by string id, so mutating node data does not corrupt expand/collapse state.

Example

use envision::component::{SpanTreeState, SpanNode};
use ratatui::style::Color;

let root = SpanNode::new("r", "root", 0.0, 100.0);
let mut state = SpanTreeState::new(vec![root]);
state.roots_mut()[0].set_color(Color::Red);
assert_eq!(state.roots()[0].color(), Color::Red);

Note: After modifying the collection, the scrollbar may be inaccurate until the next render. Prefer dedicated methods (e.g., push_event()) when available.

pub fn set_roots(&mut self, roots: Vec<SpanNode>)

Replaces all root spans and recomputes global times.

Example

use envision::component::{SpanTreeState, SpanNode};

let mut state = SpanTreeState::new(vec![SpanNode::new("old", "old", 0.0, 10.0)]);
state.set_roots(vec![SpanNode::new("new", "new", 5.0, 50.0)]);
assert_eq!(state.roots().len(), 1);
assert_eq!(state.global_start(), 5.0);
assert_eq!(state.global_end(), 50.0);

pub fn selected_index(&self) -> Option<usize>

Returns the currently selected flat index.

Example

use envision::component::{SpanTreeState, SpanNode};

let state = SpanTreeState::new(vec![SpanNode::new("r", "root", 0.0, 10.0)]);
assert_eq!(state.selected_index(), Some(0));

let empty = SpanTreeState::default();
assert_eq!(empty.selected_index(), None);

pub fn selected_span(&self) -> Option<FlatSpan>

Returns the currently selected span in flattened view.

Example

use envision::component::{SpanTreeState, SpanNode};

let root = SpanNode::new("r", "root", 0.0, 100.0);
let state = SpanTreeState::new(vec![root]);
let selected = state.selected_span().unwrap();
assert_eq!(selected.id(), "r");
assert_eq!(selected.label(), "root");

pub fn global_start(&self) -> f64

Returns the earliest start time across all spans.

pub fn global_end(&self) -> f64

Returns the latest end time across all spans.

pub fn label_width(&self) -> u16

Returns the label column width.

pub fn title(&self) -> Option<&str>

Returns the title, if set.

pub fn set_title(&mut self, title: impl Into<String>)

Sets the title.

Example

use envision::component::SpanTreeState;

let mut state = SpanTreeState::default();
state.set_title("Trace View");
assert_eq!(state.title(), Some("Trace View"));

pub fn is_empty(&self) -> bool

Returns true if the tree is empty.

Example

use envision::component::SpanTreeState;

assert!(SpanTreeState::default().is_empty());

pub fn expanded_ids(&self) -> &HashSet<String>

Returns the set of expanded node IDs.

pub fn expand(&mut self, id: &str)

Expands a node by its ID.

Example

use envision::component::{SpanTreeState, SpanNode};

let root = SpanNode::new("r", "root", 0.0, 100.0)
    .with_child(SpanNode::new("c", "child", 10.0, 50.0));
let mut state = SpanTreeState::new(vec![root]);
state.collapse("r");
assert!(!state.expanded_ids().contains("r"));
state.expand("r");
assert!(state.expanded_ids().contains("r"));

pub fn collapse(&mut self, id: &str)

Collapses a node by its ID.

Example

use envision::component::{SpanTreeState, SpanNode};

let root = SpanNode::new("r", "root", 0.0, 100.0)
    .with_child(SpanNode::new("c", "child", 10.0, 50.0));
let mut state = SpanTreeState::new(vec![root]);
state.collapse("r");
assert!(!state.expanded_ids().contains("r"));

pub fn expand_all(&mut self)

Expands all nodes.

Example

use envision::component::{SpanTreeState, SpanNode};

let root = SpanNode::new("r", "root", 0.0, 100.0)
    .with_child(SpanNode::new("c", "child", 10.0, 50.0));
let mut state = SpanTreeState::new(vec![root]);
state.collapse_all();
state.expand_all();
assert!(state.expanded_ids().contains("r"));

pub fn collapse_all(&mut self)

Collapses all nodes.

Example

use envision::component::{SpanTreeState, SpanNode};

let root = SpanNode::new("r", "root", 0.0, 100.0)
    .with_child(SpanNode::new("c", "child", 10.0, 50.0));
let mut state = SpanTreeState::new(vec![root]);
state.collapse_all();
assert!(state.expanded_ids().is_empty());

pub fn flatten(&self) -> Vec<FlatSpan>

Flattens the visible hierarchy into a list of FlatSpan items.

Only expanded nodes have their children included. The order is depth-first, matching the visual tree order.

Example

use envision::component::{SpanTreeState, SpanNode};

let root = SpanNode::new("r", "root", 0.0, 100.0)
    .with_child(SpanNode::new("c1", "child-1", 10.0, 50.0))
    .with_child(SpanNode::new("c2", "child-2", 50.0, 90.0));
let state = SpanTreeState::new(vec![root]);
let flat = state.flatten();
assert_eq!(flat.len(), 3);
assert_eq!(flat[0].id(), "r");
assert_eq!(flat[0].depth(), 0);
assert_eq!(flat[1].id(), "c1");
assert_eq!(flat[1].depth(), 1);

pub fn update(&mut self, msg: SpanTreeMessage) -> Option<SpanTreeOutput>

Updates the state with a message, returning any output.

Trait Implementations

impl Clone for SpanTreeState

fn clone(&self) -> SpanTreeState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpanTreeState

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

Formats the value using the given formatter.

impl Default for SpanTreeState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SpanTreeState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SpanTreeState

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SpanTreeState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SpanTreeState