bernardo-tui 0.2.7

A keyboard-only, distraction-free TUI widget 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

use log::{debug, error};

use crate::experiments::screenspace::Screenspace;
use crate::experiments::subwidget_pointer::SubwidgetPointer;
use crate::layout::layout::{Layout, LayoutResult};
use crate::layout::widget_with_rect::WidgetWithRect;
use crate::primitives::rect::Rect;
use crate::primitives::xy::XY;
use crate::widget::fill_policy::{DeterminedBy, SizePolicy};
use crate::widget::widget::Widget;

pub struct LeafLayout<W: Widget> {
    widget: SubwidgetPointer<W>,
}

impl<W: Widget> LeafLayout<W> {
    pub fn new(widget: SubwidgetPointer<W>) -> Self {
        LeafLayout { widget }
    }
}

impl<W: Widget> Layout<W> for LeafLayout<W> {
    fn prelayout(&self, root: &mut W) {
        let widget = self.widget.get_mut(root);
        widget.prelayout();
    }

    fn exact_size(&self, root: &W, output_size: XY) -> XY {
        let widget = self.widget.get(root);

        let size_policy = widget.size_policy();
        if size_policy == SizePolicy::MATCH_LAYOUT {
            return output_size;
        }

        let widget_full_size = widget.full_size();
        let widget_output_size = XY::new(
            if size_policy.x == DeterminedBy::Widget {
                widget_full_size.x
            } else {
                output_size.x
            },
            if size_policy.y == DeterminedBy::Widget {
                widget_full_size.y
            } else {
                output_size.y
            },
        );
        widget_output_size
    }

    fn layout(&self, root: &mut W, screenspace: Screenspace) -> LayoutResult<W> {
        let root_id = root.id();
        let _root_desc = format!("{:?}", root as &dyn Widget);

        let _widget_desc = {
            let widget = self.widget.get(root);
            format!("{:?}", widget)
        };

        let widget_output_size = self.exact_size(root, screenspace.output_size());

        if !(widget_output_size <= screenspace.output_size()) {
            error!("not enough space to draw widget {}", _widget_desc);
            return LayoutResult::new(vec![], XY::ZERO);
        }

        debug_assert!(widget_output_size <= screenspace.output_size());

        let widget = self.widget.get_mut(root);
        let skip = root_id == widget.id();

        if skip {
            return LayoutResult::new(vec![], XY::ZERO);
        }

        let widget_desc = format!("W{}{}", widget.typename(), widget.id());
        // let widget_full_size = widget.full_size();
        //
        // if !(widget_full_size <= output_size) {
        //     error!("can't fit widget {}, required {} scaled to {} and got max {}", &widget_desc, widget_full_size, widget_output_size, output_size);
        //     return LayoutResult::new(vec![], widget_output_size);
        // }

        if let Some(widget_visible_rect) = screenspace.visible_rect().capped_at(widget_output_size) {
            widget.layout(Screenspace::new(widget_output_size, widget_visible_rect));
            let is_focusable = widget.is_focusable();

            debug!("leaf layout for {}, returning {}", &widget_desc, widget_output_size);

            LayoutResult::new(
                vec![WidgetWithRect::new(
                    self.widget.clone(),
                    Rect::new(XY::ZERO, widget_output_size),
                    is_focusable,
                )],
                widget_output_size,
            )
        } else {
            debug!("leaf layout for {} CULLED, returning {}", &widget_desc, widget_output_size);

            LayoutResult::new(vec![], widget_output_size)
        }
    }
}