Struct Node 

pub struct Node<BackendT, ContextT, ErrorT, IdT, DataT> {
    pub depth: usize,
    pub kind: NodeKind,
    pub id: IdT,
    pub representation: Representation,
    pub representation_size: XY<usize>,
    pub branch_state: BranchState,
    pub children: Option<NodeList<BackendT, ContextT, ErrorT, IdT, DataT>>,
    pub data: Option<DataT>,
    /* private fields */
}

Tree node.

Fields

depth: usize

Depth.

kind: NodeKind

Kind.

id: IdT

ID.

representation: Representation

Representation.

representation_size: XY<usize>

Representation size.

Cached so we only have to calculate it once.

branch_state: BranchState

State for Branch node.

children: Option<NodeList<BackendT, ContextT, ErrorT, IdT, DataT>>

Children for Branch node.

data: Option<DataT>

Data.

Implementations

impl<BackendT, ContextT, ErrorT, IdT, DataT> Node<BackendT, ContextT, ErrorT, IdT, DataT>

where BackendT: TreeBackend<ContextT, ErrorT, IdT, DataT>,

pub fn new( depth: usize, kind: NodeKind, id: IdT, representation: Representation, ) -> Self

Constructor.

pub fn symbol(&self, context: ContextT) -> 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: ContextT, ) -> Result<(), ErrorT>

where ContextT: Clone,

Fetch nodes from backend.

If depth is None will populate all depths.

If depth is 0 will do nothing.

pub fn add_child( &mut self, kind: NodeKind, id: IdT, representation: Representation, )

Add a child node.

Examples found in repository

examples/simple.rs (line 23)

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"
    // and expand it

    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());
    }
    world.expand_branch(()).unwrap();

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

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

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

    cursive.run();
}

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

Inserts a child node.

pub fn expand_branch(&mut self, context: ContextT) -> Result<bool, ErrorT>

where ContextT: Clone,

Expand the branch.

Will return false if not a Branch or already expanded.

Examples found in repository

examples/simple.rs (line 25)

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"
    // and expand it

    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());
    }
    world.expand_branch(()).unwrap();

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

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

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

    cursive.run();
}

pub fn collapse_branch(&mut self) -> bool

Collapse the branch.

Will return false if not a Branch or already collapsed.

pub fn toggle_branch_state(&mut self, context: ContextT) -> Result<(), ErrorT>

where ContextT: Clone,

Toggle the branch state.

Expand if collapsed, collapse if expanded.

Will do nothing if not a Branch.

pub fn data( &mut self, context: ContextT, ) -> Result<Option<Cow<'_, DataT>>, ErrorT>

where DataT: Clone,

Data.

If not already cached will fetch it from the backend.

Examples found in repository

examples/file_browser.rs (line 73)

    fn handle_selection_changed(cursive: &mut Cursive) {
        let content = match cursive.call_on_name(
            "tree",
            |tree: &mut TreeView<Self, Arc<PathBuf>, io::Error, PathBuf, Metadata>| {
                // 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, ContextT, ErrorT, IdT, DataT> FromIterator<Node<BackendT, ContextT, ErrorT, IdT, DataT>> for NodeList<BackendT, ContextT, ErrorT, IdT, DataT>

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

where IteratorT: IntoIterator<Item = Node<BackendT, ContextT, ErrorT, IdT, DataT>>,

Creates a value from an iterator.