Struct Node 

pub struct Node<BackendT>
where
    BackendT: TreeBackend,
{
    pub depth: usize,
    pub kind: NodeKind,
    pub id: BackendT::ID,
    pub label: SpannedString<Style>,
    pub label_size: Vec2,
    pub branch_state: BranchState,
    pub children: Option<NodeList<BackendT>>,
    pub data: Option<BackendT::Data>,
    /* private fields */
}

Tree node.

Fields

depth: usize

Depth.

kind: NodeKind

Kind.

id: BackendT::ID

ID.

label: SpannedString<Style>

Label.

label_size: Vec2

Label size.

Cached so we only have to calculate it once.

Note that labels can ostensibly have heights >1, i.e. they can be multiline, however this is not currently supported by TreeView.

branch_state: BranchState

State for Branch node.

children: Option<NodeList<BackendT>>

Children for Branch node.

data: Option<BackendT::Data>

Data.

Implementations

impl<BackendT> Node<BackendT>

where BackendT: TreeBackend,

pub fn new<IdT, LabelT>( depth: usize, kind: NodeKind, id: IdT, label: LabelT, ) -> Self

where IdT: Into<BackendT::ID>, LabelT: Into<SpannedString<Style>>,

Constructor.

pub fn symbol(&self, context: BackendT::Context) -> Symbol<'_>

Symbol.

Its char count is always 1.

pub fn at_path(&self, path: NodePath) -> Option<&Self>

Get node at path.

pub fn at_path_mut(&mut self, path: NodePath) -> Option<&mut Self>

Get node at path.

pub fn fill_path(&self, path: &mut NodePath, node: &Self) -> bool

Fill path to node.

Returns true if found.

pub fn populate( &mut self, depth: Option<usize>, context: BackendT::Context, ) -> Result<(), BackendT::Error>

where BackendT::Context: Clone,

Fetch the branch’s children from backend.

If depth is None will populate all depths.

If depth is 0 or not a Branch will do nothing.

Note that populating a node will not automatically expand it.

pub fn add_child<IdT, LabelT>(&mut self, kind: NodeKind, id: IdT, label: LabelT)

where IdT: Into<BackendT::ID>, LabelT: Into<SpannedString<Style>>,

Add a child node.

Will do nothing if not a Branch.

Examples found in repository

examples/simple.rs (line 22)

fn main() -> Result<(), ()> {
    let mut cursive = default();

    let mut tree = SimpleTreeBackend::tree_view();

    // A few roots

    tree.model.add_root(NodeKind::Leaf, (), "Hello");
    tree.model.add_root(NodeKind::Branch, (), "World");

    // Add 10 children to "World"

    let world = tree.model.at_path_mut([1].into()).expect("at_path_mut");
    for i in 0..10 {
        world.add_child(NodeKind::Leaf, (), format!("Child #{}", i + 1));
    }

    // Add 10 grandchildren each to "Child #5" -> "Child #10"
    // Note that we change them to branch in order to support having children

    let mut gc = 0;
    for c in 4..10 {
        let child = tree.model.at_path_mut([1, c].into()).expect("at_path_mut");
        child.kind = NodeKind::Branch;
        for _ in 0..10 {
            child.add_child(NodeKind::Leaf, (), format!("Grandchild #{}", gc + 1));
            gc += 1;
        }
    }

    // Expand all nodes

    tree.model.expand(None)?;

    cursive.add_fullscreen_layer(Panel::new(tree.scrollable()));
    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();

    Ok(())
}

pub fn insert_child<IdT, LabelT>( &mut self, index: usize, kind: NodeKind, id: IdT, label: LabelT, )

where IdT: Into<BackendT::ID>, LabelT: Into<SpannedString<Style>>,

Inserts a child node.

Will do nothing if not a Branch.

pub fn expand( &mut self, depth: Option<usize>, context: BackendT::Context, ) -> Result<(), BackendT::Error>

where BackendT::Context: Clone,

Expand the branch.

If depth is None will expand all depths.

If depth is 0 or not a Branch will do nothing.

Note that this will populate expanded nodes from the backend.

pub fn collapse(&mut self, depth: Option<usize>)

Collapse the branch.

If depth is None will collapse all depths.

If depth is 0 or not a Branch will do nothing.

pub fn toggle_branch_state( &mut self, context: BackendT::Context, ) -> Result<(), BackendT::Error>

where BackendT::Context: Clone,

Toggle the branch state.

Expand if collapsed, collapse if expanded.

Will do nothing if not a Branch.

pub fn data( &mut self, context: BackendT::Context, ) -> Result<Option<Cow<'_, BackendT::Data>>, BackendT::Error>

where BackendT::Data: Clone,

Data.

If not already cached will fetch it from the backend.

Examples found in repository

examples/file_browser.rs (line 75)

    fn handle_selection_changed(cursive: &mut Cursive, base_directory: Self::Context) {
        let content = match cursive.call_on_name("tree", |tree: &mut TreeView<Self>| {
            // Note that although we're not using the context in data() we still need to provide it
            // (some implementations might need it)
            let base_directory = tree.model.context.clone();
            Ok(match tree.selected_node_mut() {
                Some(node) => match node.data(base_directory)? {
                    Some(metadata) => Some(format_metadata(&metadata)?),
                    None => None,
                },
                None => None,
            })
        }) {
            Some(Ok(Some(text))) => text,
            Some(Err(error)) => return Self::handle_error(cursive, base_directory, error),
            _ => "".into(),
        };

        cursive.call_on_name("details", |details: &mut TextView| details.set_content(content));
    }

Trait Implementations

impl<BackendT> FromIterator<Node<BackendT>> for NodeList<BackendT>

where BackendT: TreeBackend,

fn from_iter<IteratorT>(iterator: IteratorT) -> Self

where IteratorT: IntoIterator<Item = Node<BackendT>>,

Creates a value from an iterator.