Struct TreeView 

pub struct TreeView<BackendT>
where
    BackendT: TreeBackend,
{
    pub model: TreeModel<BackendT>,
    pub selected_row: Option<usize>,
    pub page: usize,
    pub debug: bool,
}

Tree view.

Nodes can be leaves (no children) or branches (potentially have children) and can have custom data (DataT) attached to them. Their representation can be stylized with multiple colors and effects.

Supported events:

• Up/Down keys: move selection
• PgUp/PgDown keys: move selection by 10 (configurable)
• Left/Right keys: collapse/expand selected branch node
• Enter key: toggle selected branch node collapse/expand
• “-”/“+” keys: collapse/expand selected branch and all children recursively
• Mouse click on node: select
• Mouse click to the left of the node: toggle branch collapse/expand

The view’s data and behavior are backed by a TreeBackend. The nodes are stored and managed by a TreeModel. The model can be populated in advance and can also fetch data from the backend on demand, e.g. when a branch node is expanded.

Fields

model: TreeModel<BackendT>

Tree model.

selected_row: Option<usize>

Selected row.

page: usize

Page size for PgUp/PgDown.

debug: bool

Whether we want to display debug information.

Implementations

impl<BackendT> TreeView<BackendT>

where BackendT: TreeBackend,

pub fn selected_node(&self) -> Option<&Node<BackendT>>

The selected node.

pub fn selected_path(&self) -> Option<NodePath>

The selected path.

pub fn selected_node_mut(&mut self) -> Option<&mut Node<BackendT>>

The selected node.

Examples found in repository

examples/file_browser.rs (line 67)

    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);
        });
    }

pub fn is_selected(&self, row: usize) -> bool

Whether the row is selected.

pub fn select_top(&mut self)

Select top row.

pub fn select_bottom(&mut self)

Select bottom row.

pub fn move_selection(&mut self, delta: isize)

Move selection by delta rows.

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.

impl<BackendT> View for TreeView<BackendT>

where BackendT: 'static + TreeBackend + Send + Sync, BackendT::Context: Clone + Send + Sync, BackendT::Error: Send + Sync, BackendT::ID: Send + Sync, BackendT::Data: Send + Sync,

fn type_name(&self) -> &'static str

Returns the type of this view.

fn take_focus(&mut self, _source: Direction) -> Result<EventResult, CannotFocus>

Attempt to give this view the focus.

fn required_size(&mut self, _constraint: Vec2) -> Vec2

Returns the minimum size the view requires with the given restrictions.

fn important_area(&self, view_size: Vec2) -> Rect

What part of the view is important and should be visible?

fn on_event(&mut self, event: Event) -> EventResult

Called when an event is received (key press, mouse event, …).

fn draw(&self, printer: &Printer<'_, '_>)

Draws the view with the given printer (includes bounds) and focus.

fn layout(&mut self, _: XY<usize>)

Called once the size for this view has been decided.

fn needs_relayout(&self) -> bool

Should return true if the view content changed since the last call to layout().

fn call_on_any( &mut self, _: &Selector<'_>, _: &mut dyn FnMut(&mut (dyn View + 'static)), )

Runs a closure on the view identified by the given selector.

fn focus_view(&mut self, _: &Selector<'_>) -> Result<EventResult, ViewNotFound>

Moves the focus to the view identified by the given selector.