Struct TreeModel 

pub struct TreeModel<BackendT, ContextT, ErrorT, IdT, DataT> {
    pub roots: NodeList<BackendT, ContextT, ErrorT, IdT, DataT>,
    pub context: ContextT,
    /* private fields */
}

Tree model.

Fields

roots: NodeList<BackendT, ContextT, ErrorT, IdT, DataT>

Roots.

context: ContextT

Context.

Implementations

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

pub fn new(context: ContextT) -> Self

Constructor.

pub fn is_empty(&self) -> bool

Whether we have no nodes.

pub fn iter( &self, only_expanded: bool, ) -> NodeIterator<'_, BackendT, ContextT, ErrorT, IdT, DataT>

Iterate nodes in visual order from top to bottom.

When only_expanded is true will skip the children of collapsed branches.

pub fn at_path( &self, path: NodePath, ) -> Option<&Node<BackendT, ContextT, ErrorT, IdT, DataT>>

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

Get node at path.

pub fn at_path_mut( &mut self, path: NodePath, ) -> Option<&mut Node<BackendT, ContextT, ErrorT, IdT, DataT>>

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

Get node at path.

Examples found in repository

examples/simple.rs (line 21)

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 at_row( &self, row: usize, ) -> Option<&Node<BackendT, ContextT, ErrorT, IdT, DataT>>

where DataT: 'static,

Get node at row.

pub fn path( &self, node: &Node<BackendT, ContextT, ErrorT, IdT, DataT>, ) -> Option<NodePath>

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

Find path to node.

pub fn size(&self) -> XY<usize>

where DataT: 'static,

Size.

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

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

Add a root node.

Examples found in repository

examples/simple.rs (line 15)

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_root( &mut self, index: usize, kind: NodeKind, id: IdT, representation: Representation, )

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

Insert a root node.

pub fn populate(&mut self, depth: Option<usize>) -> Result<(), ErrorT>

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

Fetch nodes from backend.

If depth is None will populate the entire tree.

If depth is 0 will do nothing.

Examples found in repository

examples/file_browser.rs (line 20)

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

    let current_dir = current_dir().unwrap();
    let mut tree = FileBackend::tree_view(current_dir.into());

    // Populate the first level (just the roots)
    tree.model.populate(Some(1)).unwrap();

    let mut browser = LinearLayout::horizontal();
    browser.add_child(tree.with_name("tree").scrollable().full_screen());
    browser.add_child(TextView::new("").with_name("details").scrollable().full_screen());

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

    cursive.run();
}

pub fn clear(&mut self)

Remove all nodes.

Trait Implementations

impl<BackendT, ContextT, ErrorT, IdT, DataT> From<TreeModel<BackendT, ContextT, ErrorT, IdT, DataT>> for TreeView<BackendT, ContextT, ErrorT, IdT, DataT>

fn from(model: TreeModel<BackendT, ContextT, ErrorT, IdT, DataT>) -> Self

Converts to this type from the input type.