fret-ui 0.1.0

Mechanism-layer UI engine for Fret with tree, layout, focus, routing, and interaction contracts.
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

use crate::layout_constraints::{AvailableSpace, LayoutConstraints, LayoutSize};
use fret_core::Size;

/// Layout-time overflow budget hints inherited down the layout subtree.
///
/// This is intentionally minimal: it only affects how wrapper widgets construct probe/measurement
/// constraints for their children. It does **not** change paint-time clipping behavior.
///
/// The initial use case is scroll extents (DOM/GPUI parity): scroll roots can install a context
/// indicating the scroll axis should be treated as `MaxContent` for child probes so wrapper-heavy
/// trees can still observe overflow in post-layout geometry.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct LayoutOverflowContext {
    /// Override the available-space budget used when building probe constraints for children.
    ///
    /// When `None`, probe constraints default to `AvailableSpace::Definite(size.{width,height})`.
    pub probe_available_override: LayoutSize<Option<AvailableSpace>>,
    /// Allow `Length::Auto` sizes to exceed the viewport-sized available budget.
    ///
    /// When `true` for an axis, clamp helpers must not treat `available` as a hard maximum for
    /// `Auto` on that axis. This is required for DOM/GPUI-like overflow: children can be taller
    /// than their viewport budget and still have that overflow observable in post-layout geometry.
    ///
    /// This is scoped via `LayoutCx` and must not affect paint-time clipping.
    pub allow_overflow_on_auto: LayoutSize<bool>,
}

impl LayoutOverflowContext {
    pub const fn new(probe_available_override: LayoutSize<Option<AvailableSpace>>) -> Self {
        Self {
            probe_available_override,
            allow_overflow_on_auto: LayoutSize::new(false, false),
        }
    }

    pub const fn default_for_layout() -> Self {
        Self {
            probe_available_override: LayoutSize::new(None, None),
            allow_overflow_on_auto: LayoutSize::new(false, false),
        }
    }

    pub fn probe_constraints_for_size(self, size: Size) -> LayoutConstraints {
        let mut available = LayoutSize::new(
            AvailableSpace::Definite(size.width),
            AvailableSpace::Definite(size.height),
        );

        if let Some(w) = self.probe_available_override.width {
            available.width = w;
        }
        if let Some(h) = self.probe_available_override.height {
            available.height = h;
        }

        LayoutConstraints::new(LayoutSize::new(None, None), available)
    }
}

impl Default for LayoutOverflowContext {
    fn default() -> Self {
        Self::default_for_layout()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use fret_core::Px;

    #[test]
    fn probe_constraints_default_to_definite() {
        let ctx = LayoutOverflowContext::default();
        let c = ctx.probe_constraints_for_size(Size::new(Px(10.0), Px(20.0)));
        assert_eq!(c.available.width, AvailableSpace::Definite(Px(10.0)));
        assert_eq!(c.available.height, AvailableSpace::Definite(Px(20.0)));
    }

    #[test]
    fn probe_constraints_apply_overrides_per_axis() {
        let ctx = LayoutOverflowContext {
            probe_available_override: LayoutSize::new(Some(AvailableSpace::MaxContent), None),
            allow_overflow_on_auto: LayoutSize::new(false, false),
        };
        let c = ctx.probe_constraints_for_size(Size::new(Px(10.0), Px(20.0)));
        assert_eq!(c.available.width, AvailableSpace::MaxContent);
        assert_eq!(c.available.height, AvailableSpace::Definite(Px(20.0)));
    }
}