Struct TreeModel 

pub struct TreeModel<BackendT>
where
    BackendT: TreeBackend,
{
    pub roots: NodeList<BackendT>,
    pub context: BackendT::Context,
}

Tree model.

Fields

roots: NodeList<BackendT>

Roots.

context: BackendT::Context

Context.

Implementations

impl<BackendT> TreeModel<BackendT>

where BackendT: TreeBackend,

pub fn new(context: BackendT::Context) -> Self

Constructor.

pub fn is_empty(&self) -> bool

Whether we have no nodes.

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

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

Get node at path.

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

Get node at path.

Examples found in repository

examples/simple.rs (line 20)

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

Get node at row.

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

Find path to node.

pub fn extents(&self) -> Vec2

Full extents for drawing.

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

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

Add a root node.

Examples found in repository

examples/simple.rs (line 15)

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

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

Insert a root node.

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

where BackendT::Context: Clone,

Expand branch nodes.

If depth is None will expand the entire tree.

If depth is 0 will do nothing.

Note that this will populate expanded nodes from the backend.

Examples found in repository

examples/simple.rs (line 40)

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 collapse(&mut self, depth: Option<usize>)

Collapse branch nodes.

If depth is None will collapse the entire tree.

If depth is 0 will do nothing.

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

where BackendT::Context: Clone,

Fetch roots and possibly their children from backend.

If depth is None will populate the entire tree.

If depth is 1 will only populate the roots.

If depth is 0 will do nothing.

Note that populating a branch node will not automatically expand it.

Examples found in repository

examples/file_browser.rs (line 23)

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

    // Our base directory (the backend context) will be the current directory
    let mut tree = FileBackend::tree_view(current_dir()?.into());

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

    cursive.add_fullscreen_layer(
        LinearLayout::horizontal()
            .child(Panel::new(tree.with_name("tree").scrollable()))
            .child(Panel::new(TextView::new("").with_name("details").scrollable())),
    );

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

    cursive.run();

    Ok(())
}

pub fn clear(&mut self)

Remove all nodes.

Trait Implementations

impl<BackendT> From<TreeModel<BackendT>> for TreeView<BackendT>

where BackendT: TreeBackend,

fn from(model: TreeModel<BackendT>) -> Self

Converts to this type from the input type.