cursive-split-panel 0.0.6

Split panel 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

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

//
// Pane
//

// Pane for split panel.
pub(crate) struct Pane {
    pub(crate) view: Box<dyn View>,
    pub(crate) start: usize,
    pub(crate) extent: usize,
}

impl Pane {
    // Layout view.
    pub(crate) fn layout(&mut self, size: Vec2, orientation: Orientation) {
        self.view.layout(size.with_axis(orientation, self.extent));
    }

    // Required size.
    pub(crate) fn required_size(&mut self, constraint: Vec2, orientation: Orientation) -> Vec2 {
        self.view.required_size(constraint.with_axis(orientation, self.extent))
    }

    // Draw view.
    pub(crate) fn draw(&self, printer: &Printer, orientation: Orientation, is_focused: bool) {
        if self.extent > 0 {
            self.view.draw(
                &printer
                    .offset(orientation.make_vec(self.start, 0))
                    .cropped(printer.size.with_axis(orientation, self.extent))
                    .focused(is_focused),
            );
        }
    }

    // Translate important area from local to split panel coordinates.
    pub(crate) fn important_area(&self, size: Vec2, orientation: Orientation, border: bool) -> Rect {
        let mut offset = orientation.make_vec(self.start, 0);
        if border {
            offset = offset + (1, 1);
        }

        self.view.important_area(size) + offset
    }

    // Translate mouse event from split panel to local coordinates.
    pub(crate) fn mouse_event(
        &self,
        mut offset: Vec2,
        position: Vec2,
        orientation: Orientation,
        border: bool,
        size: Option<Vec2>,
    ) -> Option<(Vec2, Vec2)> {
        if self.extent == 0 {
            return None;
        }

        let Some(mut local) = position.checked_sub(offset) else { return None };

        if border {
            if local.x == 0 || local.y == 0 {
                // On the left or top border
                return None;
            }

            if let Some(size) = size
                && ((size.x == 0) || (size.y == 0) || (local.x >= size.x - 1) || (local.y >= size.y - 1))
            {
                // On or beyond the right or bottom border
                return None;
            }

            offset = offset + (1, 1);
            local = local - (1, 1);
        }

        let local_ = *local.get(orientation);
        if local_ < self.start || local_ > self.start + self.extent - 1 {
            return None;
        }

        *offset.get_mut(orientation) += self.start;

        Some((offset, position))
    }
}

impl<ViewT> From<ViewT> for Pane
where
    ViewT: IntoBoxedView,
{
    fn from(view: ViewT) -> Self {
        Self { view: view.into_boxed_view(), start: 0, extent: 0 }
    }
}