Struct TreeView 

pub struct TreeView<BackendT>
where
    BackendT: TreeBackend,
{
    pub model: TreeModel<BackendT>,
    /* private fields */
}

Tree view.

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

Event handling (configurable):

• 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
• “<”/“>” keys: collapse/expand all nodes
• 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.

Implementations

impl<BackendT> TreeView<BackendT>

where BackendT: TreeBackend,

pub fn selected_row(&self) -> Option<usize>

The selected row.

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

    fn handle_selection_changed(cursive: &mut Cursive, base_directory: Self::Context) {
        let content = match cursive.call_on_name("tree", |tree: &mut TreeView<Self>| {
            // Note that although we're not using the context in data() we still need to provide it
            // (some implementations might need 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, base_directory, 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(&mut self, row: usize, cursive: &mut Cursive)

where BackendT::Context: Clone,

Set selected row.

If the row is invalid will set the selection to None.

If the selection is changed will call handle_selection_changed.

pub fn select_top(&mut self, cursive: &mut Cursive)

where BackendT::Context: Clone,

Select top row.

If the tree is empty will set the selection to None.

If the selection is changed will call handle_selection_changed.

pub fn select_bottom(&mut self, cursive: &mut Cursive)

where BackendT::Context: Clone,

Select bottom row.

If the tree is empty will set the selection to None.

If the selection is changed will call handle_selection_changed.

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

where BackendT::Context: Clone,

Move selection by delta rows if possible.

If the selection is None will select the top row.

If the selection is changed will call handle_selection_changed.

impl<BackendT> TreeView<BackendT>

where BackendT: TreeBackend,

pub fn page(&self) -> usize

Page size for SelectUpPage/SelectDownPage.

pub fn set_page(&mut self, page: usize)

Set page size for SelectUpPage/SelectDownPage.

pub fn with_page(self, page: usize) -> Self

Set page size for SelectUpPage/SelectDownPage.

Chainable.

pub fn debug(&self) -> bool

Debug mode.

pub fn set_debug(&mut self, debug: bool)

Set debug mode.

pub fn with_debug(self, debug: bool) -> Self

Set debug mode.

Chainable.

pub fn actions(&self) -> &Actions

Action map.

pub fn actions_mut(&mut self) -> &mut Actions

Action map.

pub fn set_actions(&mut self, actions: Actions)

Set action map.

pub fn with_actions(self, actions: Actions) -> Self

Set action map.

Chainable.

pub fn set_action(&mut self, action: Action, event: Event)

Set action.

pub fn with_action(self, action: Action, event: Event) -> Self

Set action.

Chainable.

pub fn remove_action(&mut self, action: Action) -> bool

Remove action.

Return true if removed.

pub fn without_action(self, action: Action) -> Self

Remove action.

Chainable.

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.