Struct TreeView 

pub struct TreeView<'a, T> { /* private fields */ }

Available on crate feature tree-view only.

Tree view widget.

A widget for rendering hierarchical tree data with expand/collapse functionality, custom rendering, and selection highlighting.

Type Parameters

• T - The type of data stored in tree nodes.

Example

use ratatui_toolkit::tree_view::{TreeNode, TreeView};

let nodes = vec![TreeNode::new("Root")];
let tree = TreeView::new(nodes)
    .render_fn(|data, state| {
        ratatui::text::Line::from(*data)
    });

Implementations

impl<'a, T> TreeView<'a, T>

pub fn new(nodes: Vec<TreeNode<T>>) -> TreeView<'a, T>

Creates a new tree view with nodes.

Arguments

• nodes - The root nodes of the tree.

Returns

A new TreeView with default settings.

Example

use ratatui_toolkit::tree_view::{TreeNode, TreeView};

let nodes = vec![TreeNode::new("Item")];
let tree = TreeView::new(nodes);

impl<'a, T> TreeView<'a, T>

pub fn block(self, block: Block<'a>) -> TreeView<'a, T>

Sets the block to wrap the tree.

Arguments

• block - The block to wrap the tree view.

Returns

Self for method chaining.

Example

use ratatui::widgets::{Block, Borders};
use ratatui_toolkit::tree_view::{TreeNode, TreeView};

let nodes = vec![TreeNode::new("Item")];
let tree = TreeView::new(nodes)
    .block(Block::default().borders(Borders::ALL).title("Tree"));

impl<'a, T> TreeView<'a, T>

pub fn handle_key_event( &mut self, key: KeyEvent, navigator: &TreeNavigator, state: &mut TreeViewState, ) -> WidgetEvent

Handle a keyboard event and return a WidgetEvent.

This method processes keyboard input for the tree view, including:

• Navigation keys (up/down/left/right)
• Expansion/collapse keys (h/l)
• Filter mode keys (/ to enter, Esc to exit, Enter to confirm)

When filter mode is active, all keystrokes are routed to the filter input and the tree is automatically filtered.

Arguments

• key - The keyboard event to handle
• navigator - The tree navigator for navigation operations
• state - The tree view state to modify

Returns

A WidgetEvent indicating what action was taken.

Example

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

let nodes = vec![TreeNode::new("Root")];
let mut tree = TreeView::new(nodes)
    .render_fn(|data, state| {
        ratatui::text::Line::from(*data)
    });
let mut state = TreeViewState::new();
let navigator = TreeNavigator::new();

match tree.handle_key_event(crossterm::event::KeyEvent::new(KeyCode::Down), &navigator, &mut state) {
    WidgetEvent::Selected { path } => println!("Selected: {:?}", path),
    WidgetEvent::Scrolled { offset, direction } => println!("Scrolled"),
    _ => {}
}

pub fn handle_mouse_event( &mut self, event: MouseEvent, state: &mut TreeViewState, area: Rect, ) -> WidgetEvent

Handle a mouse event and return a WidgetEvent.

This method processes mouse input for the tree view, including:

• Click to select items
• Scroll wheel to scroll

Arguments

• event - The mouse event to handle
• state - The tree view state to modify
• area - The area occupied by the tree view (including borders)

Returns

A WidgetEvent indicating what action was taken.

impl<'a, T> TreeView<'a, T>

pub fn highlight_style(self, style: Style) -> TreeView<'a, T>

Sets the highlight style for selected rows (full-width background).

Arguments

• style - The style to apply to selected rows.

Returns

Self for method chaining.

Example

use ratatui::style::{Color, Style};
use ratatui_toolkit::tree_view::{TreeNode, TreeView};

let nodes = vec![TreeNode::new("Item")];
let tree = TreeView::new(nodes)
    .highlight_style(Style::default().bg(Color::Blue));

impl<'a, T> TreeView<'a, T>

pub fn icons(self, expand: &'a str, collapse: &'a str) -> TreeView<'a, T>

Sets custom expand/collapse icons.

Arguments

• expand - The icon to show for collapsed nodes.
• collapse - The icon to show for expanded nodes.

Returns

Self for method chaining.

Example

use ratatui_toolkit::tree_view::{TreeNode, TreeView};

let nodes = vec![TreeNode::new("Item")];
let tree = TreeView::new(nodes)
    .icons("+", "-");

impl<'a, T> TreeView<'a, T>

pub fn node_at_row( &self, state: &TreeViewState, row: usize, ) -> Option<Vec<usize>>

Gets the node at a specific row (considering scroll offset).

Arguments

• state - The tree view state.
• row - The row index (0-based, relative to visible area).

Returns

The path to the node at the given row, or None if out of bounds.

Example

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

let nodes = vec![TreeNode::new("Item")];
let tree = TreeView::new(nodes);
let state = TreeViewState::new();
let path = tree.node_at_row(&state, 0);

impl<'a, T> TreeView<'a, T>

pub fn render_fn<F>(self, f: F) -> TreeView<'a, T>

where F: Fn(&T, &NodeState) -> Line<'a> + 'a,

Sets the render function for nodes.

Arguments

• f - A function that takes node data and state, returns a Line.

Returns

Self for method chaining.

Example

use ratatui::text::Line;
use ratatui_toolkit::tree_view::{TreeNode, TreeView};

let nodes = vec![TreeNode::new("Item")];
let tree = TreeView::new(nodes)
    .render_fn(|data, state| {
        if state.is_selected {
            Line::from(format!("> {}", data))
        } else {
            Line::from(*data)
        }
    });

impl<'a, T> TreeView<'a, T>

pub fn visible_item_count(&self, state: &TreeViewState) -> usize

Gets total visible item count.

Arguments

• state - The tree view state.

Returns

The number of visible items in the tree.

Example

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

let nodes = vec![TreeNode::new("Item")];
let tree = TreeView::new(nodes);
let state = TreeViewState::new();
assert_eq!(tree.visible_item_count(&state), 1);

impl<'a, T> TreeView<'a, T>

pub fn with_filter_ui(self, show: bool) -> TreeView<'a, T>

Enable or disable the built-in filter UI.

When enabled, the tree view will automatically render a filter input line at the bottom of the widget when filter mode is active or a filter is set.

This eliminates the need for manual buffer manipulation when rendering the filter cursor.

Example

use ratatui_toolkit::tree_view::{TreeNode, TreeView};

let nodes = vec![TreeNode::new("Root")];
let tree = TreeView::new(nodes)
    .render_fn(|data, state| {
        ratatui::text::Line::from(*data)
    })
    .with_filter_ui(true);

Trait Implementations

impl<'a, T> StatefulWidget for TreeView<'a, T>

type State = TreeViewState

State associated with the stateful widget.

fn render( self, area: Rect, buf: &mut Buffer, state: &mut <TreeView<'a, T> as StatefulWidget>::State, )

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom stateful widget.

impl<'a, T> Widget for &TreeView<'a, T>

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.