Struct Node 

pub struct Node<BackendT>
where
    BackendT: TreeBackend,
{
    pub depth: usize,
    pub kind: NodeKind,
    pub id: BackendT::ID,
    pub representation: Representation,
    pub representation_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.

representation: Representation

Representation.

representation_size: Vec2

Representation size.

Cached so we only have to calculate it once.

Note that nodes 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( depth: usize, kind: NodeKind, id: BackendT::ID, representation: Representation, ) -> Self

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( &mut self, kind: NodeKind, id: BackendT::ID, representation: Representation, )

Add a child node.

Will do nothing if not a Branch.

Examples found in repository

examples/simple.rs (line 22)

fn main() {
    let mut cursive = Cursive::default();

    let mut tree = SimpleTreeBackend::tree_view(());

    // A few roots

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

    // Add 10 children to "World"

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

    // 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()).unwrap();
        child.kind = NodeKind::Branch;
        for _ in 0..10 {
            child.add_child(NodeKind::Leaf, (), format!("Grandchild #{}", gc + 1).into());
            gc += 1;
        }
    }

    // Expand all nodes

    tree.model.expand(None).unwrap();

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

    cursive.run();
}

pub fn insert_child( &mut self, index: usize, kind: NodeKind, id: BackendT::ID, representation: Representation, )

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 68)

    fn handle_selection_changed(cursive: &mut Cursive) {
        let content = match cursive.call_on_name("tree", |tree: &mut TreeView<Self>| {
            // Although we're not using the context in data() but we still need to provide 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, 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.