Struct TreeState 

pub struct TreeState<T> { /* private fields */ }

State for a Tree component.

Implementations

impl<T: Clone> TreeState<T>

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

Creates a new tree state with the given root nodes.

If roots are non-empty, the first node is selected.

Example

use envision::component::{TreeState, TreeNode};

let roots = vec![
    TreeNode::new("Root 1", 1),
    TreeNode::new("Root 2", 2),
];
let state = TreeState::new(roots);
assert_eq!(state.roots().len(), 2);

pub fn with_selected(self, index: usize) -> Self

Sets the initially selected index in the flattened view (builder method).

The index is clamped to the valid range of visible nodes. Has no effect on empty trees.

Example

use envision::component::{TreeState, TreeNode};

let mut root = TreeNode::new_expanded("Root", ());
root.add_child(TreeNode::new("Child 1", ()));
root.add_child(TreeNode::new("Child 2", ()));

let state = TreeState::new(vec![root]).with_selected(2);
assert_eq!(state.selected_index(), Some(2));

pub fn roots(&self) -> &[TreeNode<T>]

Returns the root nodes.

Examples

use envision::prelude::*;

let state = TreeState::new(vec![
    TreeNode::new("Root 1", 1),
    TreeNode::new("Root 2", 2),
]);
assert_eq!(state.roots().len(), 2);
assert_eq!(state.roots()[0].label(), "Root 1");

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

Returns a mutable reference to the root nodes.

Example

use envision::component::{TreeState, TreeNode};

let mut state = TreeState::new(vec![TreeNode::new("Root", ())]);
state.roots_mut().push(TreeNode::new("Another Root", ()));
assert_eq!(state.roots().len(), 2);

pub fn update_root(&mut self, index: usize, f: impl FnOnce(&mut TreeNode<T>))

Updates a root node at the given index via a closure.

No-ops if the index is out of bounds. This is safe because it does not change the number of root nodes or their positions, so selection and filter state remain valid.

Example

use envision::component::{TreeState, TreeNode};

let mut state = TreeState::new(vec![
    TreeNode::new("Root 1", 1),
    TreeNode::new("Root 2", 2),
]);
state.update_root(0, |root| root.set_label("Updated Root"));
assert_eq!(state.roots()[0].label(), "Updated Root");

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

Sets the root nodes.

Resets selection to the first node, or None if the new roots are empty. Clears any active filter.

Examples

use envision::prelude::*;

let mut state = TreeState::new(vec![TreeNode::new("Old", 0)]);
state.set_roots(vec![TreeNode::new("New 1", 1), TreeNode::new("New 2", 2)]);
assert_eq!(state.roots().len(), 2);
assert_eq!(state.selected_index(), Some(0));

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

Returns the currently selected index in the flattened view.

Returns None if the tree is empty.

Examples

use envision::prelude::*;

let state = TreeState::new(vec![TreeNode::new("Root", ())]);
assert_eq!(state.selected_index(), Some(0));

let empty: TreeState<()> = TreeState::new(vec![]);
assert_eq!(empty.selected_index(), None);

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

Alias for selected_index().

Example

use envision::component::{TreeState, TreeNode};

let state = TreeState::new(vec![TreeNode::new("Root", ())]);
assert_eq!(state.selected(), Some(0));

pub fn set_selected(&mut self, index: Option<usize>)

Sets the selected index in the flattened view.

The index is clamped to the valid range of visible nodes. Has no effect on empty trees.

Example

use envision::component::{TreeState, TreeNode};

let mut root = TreeNode::new_expanded("Root", ());
root.add_child(TreeNode::new("Child 1", ()));
root.add_child(TreeNode::new("Child 2", ()));

let mut state = TreeState::new(vec![root]);
state.set_selected(Some(2));
assert_eq!(state.selected_index(), Some(2));

pub fn is_empty(&self) -> bool

Returns true if the tree is empty.

Example

use envision::component::TreeState;

let empty: TreeState<()> = TreeState::new(vec![]);
assert!(empty.is_empty());

pub fn selected_path(&self) -> Option<Vec<usize>>

Returns the path of the currently selected node.

Example

use envision::component::{TreeState, TreeNode};

let state = TreeState::new(vec![TreeNode::new("Root", ())]);
assert_eq!(state.selected_path(), Some(vec![0]));

pub fn selected_node(&self) -> Option<&TreeNode<T>>

Returns a reference to the currently selected node.

Examples

use envision::prelude::*;

let state = TreeState::new(vec![TreeNode::new("Root", 42)]);
let node = state.selected_node().unwrap();
assert_eq!(node.label(), "Root");
assert_eq!(node.data(), &42);

pub fn selected_item(&self) -> Option<&TreeNode<T>>

Returns a reference to the currently selected node.

This is an alias for selected_node() that provides a consistent accessor name across all selection-based components.

Examples

use envision::prelude::*;

let state = TreeState::new(vec![TreeNode::new("Root", 1)]);
assert_eq!(state.selected_item(), state.selected_node());

pub fn expand_all(&mut self)

Expands all nodes in the tree.

Examples

use envision::prelude::*;

let mut root = TreeNode::new("Root", ());
root.add_child(TreeNode::new("Child", ()));
let mut state = TreeState::new(vec![root]);
state.expand_all();
assert!(state.roots()[0].is_expanded());

pub fn collapse_all(&mut self)

Collapses all nodes in the tree.

Examples

use envision::prelude::*;

let mut root = TreeNode::new_expanded("Root", ());
root.add_child(TreeNode::new("Child", ()));
let mut state = TreeState::new(vec![root]);
state.collapse_all();
assert!(!state.roots()[0].is_expanded());

pub fn visible_count(&self) -> usize

Returns the number of visible nodes.

Examples

use envision::prelude::*;

let mut root = TreeNode::new_expanded("Root", ());
root.add_child(TreeNode::new("Child 1", ()));
root.add_child(TreeNode::new("Child 2", ()));
let state = TreeState::new(vec![root]);
// Root + 2 children visible (root is expanded)
assert_eq!(state.visible_count(), 3);

pub fn filter_text(&self) -> &str

Returns the current filter text.

Example

use envision::component::TreeState;

let state: TreeState<()> = TreeState::new(vec![]);
assert_eq!(state.filter_text(), "");

pub fn set_filter_text(&mut self, text: &str)

Sets the filter text for case-insensitive substring matching on node labels.

When a filter is active, only nodes whose label matches or whose descendants match are shown. Ancestor nodes are auto-expanded to reveal matching descendants without modifying their actual expanded state.

Selection is preserved if the selected node remains visible, otherwise it moves to the first visible node.

Example

use envision::component::{TreeState, TreeNode};

let mut state = TreeState::new(vec![
    TreeNode::new("Alpha", ()),
    TreeNode::new("Beta", ()),
]);
state.set_filter_text("alpha");
assert_eq!(state.filter_text(), "alpha");
assert_eq!(state.visible_count(), 1);

pub fn clear_filter(&mut self)

Clears the filter, showing all nodes with their original expanded state.

Example

use envision::component::{TreeState, TreeNode};

let mut state = TreeState::new(vec![
    TreeNode::new("Alpha", ()),
    TreeNode::new("Beta", ()),
]);
state.set_filter_text("alpha");
assert_eq!(state.visible_count(), 1);
state.clear_filter();
assert_eq!(state.filter_text(), "");
assert_eq!(state.visible_count(), 2);

impl<T: Clone + 'static> TreeState<T>

pub fn update(&mut self, msg: TreeMessage) -> Option<TreeOutput>

Updates the tree state with a message, returning any output.

Example

use envision::component::{TreeMessage, TreeNode, TreeState};

let mut root = TreeNode::new("Root", ());
root.add_child(TreeNode::new("Child", ()));
let mut state = TreeState::new(vec![root]);
state.update(TreeMessage::Expand);
assert!(state.roots()[0].is_expanded());

Trait Implementations

impl<T: Clone> Clone for TreeState<T>

fn clone(&self) -> TreeState<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TreeState<T>

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

Formats the value using the given formatter.

impl<T: Clone> Default for TreeState<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for TreeState<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Clone + PartialEq> PartialEq for TreeState<T>

fn eq(&self, other: &Self) -> 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<T> Serialize for TreeState<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.