tuika 0.7.0

The application framework for Rust terminal UIs — flexbox layout, overlays, focus, keymap, components, and safe ratatui interoperability.
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

//! Intrinsic min/max sizing for responsive flex children.

use ratatui_core::layout::Rect;

use crate::{Element, RenderCtx, Size, Surface, View};

/// Clamp a child's measured size without changing its rendering contract.
pub struct Constrained<V: View = Element> {
    child: V,
    min: Size,
    max: Size,
}

impl<V: View> Constrained<V> {
    /// Wrap `child` with unconstrained defaults.
    pub fn new(child: V) -> Self {
        Self {
            child,
            min: Size::ZERO,
            max: Size::new(u16::MAX, u16::MAX),
        }
    }

    /// Set the minimum intrinsic width and height.
    pub fn min_size(mut self, width: u16, height: u16) -> Self {
        self.min = Size::new(width, height);
        self
    }

    /// Set the maximum intrinsic width and height.
    pub fn max_size(mut self, width: u16, height: u16) -> Self {
        self.max = Size::new(width, height);
        self
    }
}

impl<V: View> View for Constrained<V> {
    fn measure(&self, available: Size, ctx: &RenderCtx) -> Size {
        let measured = self.child.measure(available, ctx);
        Size::new(
            measured
                .width
                .max(self.min.width)
                .min(self.max.width)
                .min(available.width),
            measured
                .height
                .max(self.min.height)
                .min(self.max.height)
                .min(available.height),
        )
    }

    fn render(&self, area: Rect, surface: &mut Surface, ctx: &RenderCtx) {
        self.child.render(area, surface, ctx);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::Size;
    use crate::components::Text;
    use crate::view::{View, element};

    #[test]
    fn constrained_clamps_intrinsic_measurement() {
        let theme = crate::Theme::default();
        let ctx = RenderCtx::new(&theme);
        let constrained = Constrained::new(element(Text::raw("long content")))
            .min_size(4, 1)
            .max_size(6, 2);
        assert_eq!(
            constrained.measure(Size::new(20, 10), &ctx),
            Size::new(6, 1)
        );
        assert_eq!(constrained.measure(Size::new(3, 1), &ctx), Size::new(3, 1));
    }
}