cursive-tree 0.0.9

Tree view for the Cursive TUI library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

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

use {cursive::*, std::cmp::*};

impl<BackendT> TreeView<BackendT>
where
    BackendT: TreeBackend,
{
    /// The selected row.
    pub fn selected_row(&self) -> Option<usize> {
        self.selected_row
    }

    /// The selected node.
    pub fn selected_node(&self) -> Option<&Node<BackendT>> {
        self.selected_row.and_then(|selected_row| self.model.at_row(selected_row))
    }

    /// The selected node.
    pub fn selected_node_mut(&mut self) -> Option<&mut Node<BackendT>> {
        self.selected_path().and_then(|path| self.model.at_path_mut(path))
    }

    /// The selected path.
    pub fn selected_path(&self) -> Option<NodePath> {
        self.selected_node().and_then(|node| self.model.path(node))
    }

    /// Whether the row is selected.
    pub fn is_selected(&self, row: usize) -> bool {
        self.selected_row.map(|selected_row| selected_row == row).unwrap_or_default()
    }

    /// Set selected row.
    ///
    /// If the row is invalid will set the selection to [None].
    ///
    /// If the selection is changed will call
    /// [handle_selection_changed](TreeBackend::handle_selection_changed).
    pub fn select(&mut self, row: usize, cursive: &mut Cursive)
    where
        BackendT::Context: Clone,
    {
        let last_selected_row = self.selected_row;
        self.selected_row = if self.model.is_empty() || row >= self.model.extents().y { None } else { Some(row) };
        if self.selected_row != last_selected_row {
            BackendT::handle_selection_changed(cursive, self.model.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](TreeBackend::handle_selection_changed).
    pub fn select_top(&mut self, cursive: &mut Cursive)
    where
        BackendT::Context: Clone,
    {
        let last_selected_row = self.selected_row;
        self.select_top_();
        if self.selected_row != last_selected_row {
            BackendT::handle_selection_changed(cursive, self.model.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](TreeBackend::handle_selection_changed).
    pub fn select_bottom(&mut self, cursive: &mut Cursive)
    where
        BackendT::Context: Clone,
    {
        let last_selected_row = self.selected_row;
        self.select_bottom_();
        if self.selected_row != last_selected_row {
            BackendT::handle_selection_changed(cursive, self.model.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](TreeBackend::handle_selection_changed).
    pub fn move_selection(&mut self, delta: isize, cursive: &mut Cursive)
    where
        BackendT::Context: Clone,
    {
        let last_selected_row = self.selected_row;
        self.move_selection_(delta);
        if self.selected_row != last_selected_row {
            BackendT::handle_selection_changed(cursive, self.model.context.clone());
        }
    }

    // Select top row.
    pub(crate) fn select_top_(&mut self) {
        self.selected_row = if self.model.is_empty() || self.model.extents().y == 0 { None } else { Some(0) }
    }

    // Select bottom row.
    pub(crate) fn select_bottom_(&mut self) {
        self.selected_row = if self.model.is_empty() {
            None
        } else {
            let height = self.model.extents().y;
            if height == 0 { None } else { Some(height - 1) }
        };
    }

    // Move selection by delta rows.
    pub(crate) fn move_selection_(&mut self, delta: isize) {
        if delta == 0 {
            return;
        }

        self.selected_row = if self.model.is_empty() {
            None
        } else {
            let height = self.model.extents().y;
            if height == 0 {
                None
            } else {
                Some(
                    self.selected_row
                        .map(|selected_row| min(selected_row.checked_add_signed(delta).unwrap_or_default(), height - 1))
                        .unwrap_or_default(),
                )
            }
        };
    }
}