Struct TreeNavigator 

pub struct TreeNavigator {
    pub keybindings: TreeKeyBindings,
}

Tree navigator with configurable keybindings.

Provides navigation methods for tree views with customizable key mappings.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let nodes = vec![TreeNode::new("Item")];
let mut state = TreeViewState::new();
navigator.select_next(&nodes, &mut state);

Fields

keybindings: TreeKeyBindings

The keybindings for navigation.

Implementations

impl TreeNavigator

pub fn new() -> Self

Creates a new tree navigator with default keybindings.

Returns

A new TreeNavigator with default keybindings.

Example

use ratatui_toolkit::tree_view::TreeNavigator;

let navigator = TreeNavigator::new();

impl TreeNavigator

pub fn with_keybindings(keybindings: TreeKeyBindings) -> Self

Creates a tree navigator with custom keybindings.

Arguments

• keybindings - The custom keybindings to use.

Returns

A new TreeNavigator with the specified keybindings.

Example

use ratatui_toolkit::tree_view::{TreeKeyBindings, TreeNavigator};

let keybindings = TreeKeyBindings::default();
let navigator = TreeNavigator::with_keybindings(keybindings);

impl TreeNavigator

pub fn handle_filter_key(&self, key: KeyCode, state: &mut TreeViewState) -> bool

Handles a key code in filter mode.

Arguments

• key - The key code to handle.
• state - The tree view state to update.

Returns

true if the key was handled, false otherwise.

Example

use crossterm::event::KeyCode;
use ratatui_toolkit::tree_view::{TreeNavigator, TreeViewState};

let navigator = TreeNavigator::new();
let mut state = TreeViewState::new();
state.enter_filter_mode();
navigator.handle_filter_key(KeyCode::Char('t'), &mut state);
assert_eq!(state.filter, Some("t".to_string()));

impl TreeNavigator

pub fn handle_key<T>( &self, key: KeyEvent, nodes: &[TreeNode<T>], state: &mut TreeViewState, ) -> bool

Handles a key event and updates tree state.

Arguments

• key - The key event to handle.
• nodes - The tree nodes.
• state - The tree view state to update.

Returns

true if the key was handled, false otherwise.

impl TreeNavigator

pub fn handle_key_event<T>( &self, key: KeyEvent, nodes: &[TreeNode<T>], state: &mut TreeViewState, ) -> bool

Handles a key event and updates tree state.

Arguments

• key - The key event to handle.
• nodes - The tree nodes.
• state - The tree view state to update.

Returns

true if the key was handled, false otherwise.

Example

use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let nodes = vec![TreeNode::new("Item")];
let mut state = TreeViewState::new();
let key = KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE);
let handled = navigator.handle_key_event(key, &nodes, &mut state);

impl TreeNavigator

pub fn handle_key_event_filtered<T, F>( &self, key: KeyEvent, nodes: &[TreeNode<T>], state: &mut TreeViewState, matcher: F, ) -> bool

where F: Fn(&T, &Option<String>) -> bool,

Handles a key event with filtering support.

Type Parameters

• T - The node data type.
• F - The filter matcher function type.

Arguments

• key - The key event to handle.
• nodes - The tree nodes.
• state - The tree view state to update.
• matcher - A function that takes node data and filter, returns true if matches.

Returns

true if the key was handled, false otherwise.

impl TreeNavigator

pub fn handle_key_filtered<T, F>( &self, key: KeyEvent, nodes: &[TreeNode<T>], state: &mut TreeViewState, matcher: F, ) -> bool

where F: Fn(&T, &Option<String>) -> bool,

Handles a key event with filtering support.

Type Parameters

• T - The node data type.
• F - The filter matcher function type.

Arguments

• key - The key event to handle.
• nodes - The tree nodes.
• state - The tree view state to update.
• matcher - A function that takes node data and filter, returns true if matches.

Returns

true if the key was handled, false otherwise.

impl TreeNavigator

pub fn get_hotkey_items(&self) -> Vec<(String, &'static str)>

Gets hotkey items for display in HotkeyFooter.

Returns

A vector of (key_display, description) pairs.

Example

use ratatui_toolkit::tree_view::TreeNavigator;

let navigator = TreeNavigator::new();
let items = navigator.get_hotkey_items();
assert!(!items.is_empty());

impl TreeNavigator

pub fn collapse_selected<T>( &self, _nodes: &[TreeNode<T>], state: &mut TreeViewState, )

Collapses the selected node or moves to parent.

If the node is expanded, it collapses it. If the node is already collapsed, it moves to the parent.

Arguments

• _nodes - The tree nodes (unused but kept for API consistency).
• state - The tree view state to update.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let child = TreeNode::new("Child");
let nodes = vec![TreeNode::with_children("Parent", vec![child])];
let mut state = TreeViewState::new();
state.select(vec![0]);
state.expand(vec![0]);
navigator.collapse_selected(&nodes, &mut state);
assert!(!state.is_expanded(&[0]));

impl TreeNavigator

pub fn expand_selected<T>( &self, nodes: &[TreeNode<T>], state: &mut TreeViewState, )

Expands the selected node.

Only expands if the node has children.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let child = TreeNode::new("Child");
let nodes = vec![TreeNode::with_children("Parent", vec![child])];
let mut state = TreeViewState::new();
state.select(vec![0]);
navigator.expand_selected(&nodes, &mut state);
assert!(state.is_expanded(&[0]));

impl TreeNavigator

pub fn goto_bottom<T>(&self, nodes: &[TreeNode<T>], state: &mut TreeViewState)

Goes to the last visible item.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let nodes = vec![TreeNode::new("Item1"), TreeNode::new("Item2")];
let mut state = TreeViewState::new();
navigator.goto_bottom(&nodes, &mut state);
assert_eq!(state.selected_path, Some(vec![1]));

impl TreeNavigator

pub fn goto_bottom_filtered<T, F>( &self, nodes: &[TreeNode<T>], state: &mut TreeViewState, matcher: F, )

where F: Fn(&T, &Option<String>) -> bool,

Goes to the last visible item with filtering support.

Type Parameters

• T - The node data type.
• F - The filter matcher function type.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.
• matcher - A function that takes node data and filter, returns true if matches.

impl TreeNavigator

pub fn goto_top<T>(&self, nodes: &[TreeNode<T>], state: &mut TreeViewState)

Goes to the first visible item.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let nodes = vec![TreeNode::new("Item1"), TreeNode::new("Item2")];
let mut state = TreeViewState::new();
state.select(vec![1]);
navigator.goto_top(&nodes, &mut state);
assert_eq!(state.selected_path, Some(vec![0]));

impl TreeNavigator

pub fn goto_top_filtered<T, F>( &self, nodes: &[TreeNode<T>], state: &mut TreeViewState, matcher: F, )

where F: Fn(&T, &Option<String>) -> bool,

Goes to the first visible item with filtering support.

Type Parameters

• T - The node data type.
• F - The filter matcher function type.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.
• matcher - A function that takes node data and filter, returns true if matches.

impl TreeNavigator

pub fn select_next<T>(&self, nodes: &[TreeNode<T>], state: &mut TreeViewState)

Selects the next visible item.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let nodes = vec![TreeNode::new("Item1"), TreeNode::new("Item2")];
let mut state = TreeViewState::new();
navigator.select_next(&nodes, &mut state);
assert_eq!(state.selected_path, Some(vec![0]));

impl TreeNavigator

pub fn select_next_filtered<T, F>( &self, nodes: &[TreeNode<T>], state: &mut TreeViewState, matcher: F, )

where F: Fn(&T, &Option<String>) -> bool,

Selects the next visible item with filtering support.

Type Parameters

• T - The node data type.
• F - The filter matcher function type.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.
• matcher - A function that takes node data and filter, returns true if matches.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};
use ratatui_toolkit::tree_view::helpers::matches_filter;

let navigator = TreeNavigator::new();
let nodes = vec![TreeNode::new("Item1"), TreeNode::new("Item2")];
let mut state = TreeViewState::new();
navigator.select_next_filtered(&nodes, &mut state, |data, filter| {
    matches_filter(data, filter)
});

impl TreeNavigator

pub fn select_previous<T>( &self, nodes: &[TreeNode<T>], state: &mut TreeViewState, )

Selects the previous visible item.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let nodes = vec![TreeNode::new("Item1"), TreeNode::new("Item2")];
let mut state = TreeViewState::new();
state.select(vec![1]);
navigator.select_previous(&nodes, &mut state);
assert_eq!(state.selected_path, Some(vec![0]));

impl TreeNavigator

pub fn select_previous_filtered<T, F>( &self, nodes: &[TreeNode<T>], state: &mut TreeViewState, matcher: F, )

where F: Fn(&T, &Option<String>) -> bool,

Selects the previous visible item with filtering support.

Type Parameters

• T - The node data type.
• F - The filter matcher function type.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.
• matcher - A function that takes node data and filter, returns true if matches.

impl TreeNavigator

pub fn toggle_selected<T>( &self, nodes: &[TreeNode<T>], state: &mut TreeViewState, )

Toggles expansion of the selected node.

Expands if collapsed, collapses if expanded. Only works on nodes with children.

Arguments

• nodes - The tree nodes.
• state - The tree view state to update.

Example

use ratatui_toolkit::tree_view::{TreeNavigator, TreeNode, TreeViewState};

let navigator = TreeNavigator::new();
let child = TreeNode::new("Child");
let nodes = vec![TreeNode::with_children("Parent", vec![child])];
let mut state = TreeViewState::new();
state.select(vec![0]);
navigator.toggle_selected(&nodes, &mut state);
assert!(state.is_expanded(&[0]));
navigator.toggle_selected(&nodes, &mut state);
assert!(!state.is_expanded(&[0]));

Trait Implementations

impl Clone for TreeNavigator

fn clone(&self) -> TreeNavigator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for TreeNavigator

fn default() -> Self

Returns the “default value” for a type.