cursive_tree/view/

tree.rs

use super::super::{backend::*, model::*};

use cursive::{direction::*, event::*, theme::*, view::*, *};

const TYPE_NAME: &str = "TreeView";

//
// TreeView
//

/// 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 branch node
/// * Enter key: toggle branch collapse/expand
/// * 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.
pub struct TreeView<BackendT>
where
    BackendT: TreeBackend,
{
    /// Tree model.
    pub model: TreeModel<BackendT>,

    /// Selected row.
    pub selected_row: Option<usize>,

    /// Page size for PgUp/PgDown.
    pub page: usize,

    /// Whether we want to display debug information.
    pub debug: bool,
}

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 {
        TYPE_NAME
    }

    fn take_focus(&mut self, _source: Direction) -> Result<EventResult, CannotFocus> {
        if self.model.is_empty() { Err(CannotFocus) } else { Ok(EventResult::consumed()) }
    }

    fn required_size(&mut self, _constraint: Vec2) -> Vec2 {
        self.model.size()
    }

    fn important_area(&self, view_size: Vec2) -> Rect {
        if let Some(selected_row) = self.selected_row {
            Rect::from_size((0, selected_row), (view_size.x, selected_row))
        } else {
            Rect::from_size((0, 0), view_size)
        }
    }

    fn on_event(&mut self, event: Event) -> EventResult {
        let selected_row = self.selected_row;

        match event {
            Event::Key(Key::Up) => self.move_selection(-1),
            Event::Key(Key::Down) => self.move_selection(1),
            Event::Key(Key::PageUp) => self.move_selection(-(self.page as isize)),
            Event::Key(Key::PageDown) => self.move_selection(self.page as isize),
            Event::Key(Key::Home) => self.select_top(),
            Event::Key(Key::End) => self.select_bottom(),

            Event::Key(Key::Left) => {
                if let Some(node) = self.selected_node_mut()
                    && node.kind.is_branch()
                {
                    node.collapse_branch();
                }
            }

            Event::Key(Key::Right) => {
                let context = self.model.context.clone();
                if let Some(node) = self.selected_node_mut()
                    && node.kind.is_branch()
                {
                    return Self::expand_branch(node, context);
                }
            }

            Event::Key(Key::Enter) => {
                let context = self.model.context.clone();
                if let Some(node) = self.selected_node_mut()
                    && node.kind.is_branch()
                {
                    return Self::toggle_branch_state(node, context);
                }
            }

            Event::Mouse { offset, position, event: MouseEvent::Press(_) } => {
                self.selected_row = if let Some(position) = position.checked_sub(offset)
                    && let Some(node) = self.model.at_row(position.y)
                {
                    if node.kind.is_branch() && (position.x < node.depth * 2 + 2) {
                        // If we click to the left of the representation then toggle state
                        let context = self.model.context.clone();
                        if let Some(path) = self.model.path(node)
                            && let Some(node) = self.model.at_path_mut(path)
                        {
                            return Self::toggle_branch_state(node, context);
                        } else {
                            None
                        }
                    } else {
                        // Otherwise just select
                        Some(position.y)
                    }
                } else {
                    None
                };
            }

            _ => return EventResult::Ignored,
        }

        EventResult::Consumed(if self.selected_row != selected_row {
            // Selection has changed
            Some(Callback::from_fn_once(|cursive| {
                BackendT::handle_selection_changed(cursive);
            }))
        } else {
            None
        })
    }

    fn draw(&self, printer: &Printer) {
        let mut start = XY::<usize>::default();
        for node in self.model.iter(true) {
            // Symbol

            start.x = node.depth * 2;
            match node.symbol(self.model.context.clone()) {
                Symbol::Representation(symbol) => printer.print_styled(start, &symbol),
                Symbol::String(symbol) => printer.print(start, symbol),
            };
            start.x += 2;

            // Representation

            let mut representation = &node.representation;

            let debug_representation = if self.debug
                && let Some(path) = self.model.path(node)
            {
                let path: Vec<_> = path.into_iter().map(|i| i.to_string()).collect();
                let mut representation = representation.clone();
                representation.append(format!(" {}", path.join(".")));
                Some(representation)
            } else {
                None
            };

            if let Some(debug_representation) = &debug_representation {
                representation = debug_representation;
            }

            let highlight = if self.is_selected(start.y) {
                Some(if printer.focused { PaletteStyle::Highlight } else { PaletteStyle::HighlightInactive })
            } else {
                None
            };

            let print = |printer: &Printer| printer.print_styled(start, representation);

            match highlight {
                Some(highlight) => printer.with_style(highlight, print),
                None => print(printer),
            }

            start.y += node.representation_size.y;
        }
    }
}

impl<BackendT> From<TreeModel<BackendT>> for TreeView<BackendT>
where
    BackendT: TreeBackend,
{
    fn from(model: TreeModel<BackendT>) -> Self {
        Self { model, selected_row: None, page: 10, debug: false }
    }
}