orinium_browser/engine/ui/components/

custom_node_bridge.rs

//! Unified layout bridge for custom nodes.
//!
//! Implements the unified [`CustomLayouter`] trait for both block and inline
//! formatting contexts. The resolved [`Display`] is taken from the owned
//! [`Style`] (`layout_style`) at layout time and drives the shape of the
//! returned [`LayoutBox`].

use ui_layout::{
    AutoSizeBehavior, BoxModel, CustomLayouter, Display, InlineBox, LayoutBox, LayoutContext,
    OuterDisplay, Rect, SizeStyle, Style,
};

use crate::engine::ui::custom_node::{ContentSize, CustomNode};

use super::inline_cache::resolve_border_box_size;

/// A [`CustomLayouter`] implementation for custom nodes.
///
/// Holds the resolved [`Style`] so the layout engine can account for borders
/// and padding when sizing the element. The actual content rendering is
/// delegated to a separate [`CustomNode`](crate::engine::ui::CustomNode).
///
/// The element participates in the formatting context reported by the owned
/// style's [`OuterDisplay`]:
///
/// - [`OuterDisplay::Inline`] → `layout` returns an atomic
///   [`LayoutBox::InlineBox`]. The flow engine creates its line span so the
///   element's full border-box height contributes to the line box.
/// - [`OuterDisplay::Block`] → `layout` returns a [`LayoutBox::BlockBox`]
///   positioned at the origin; the engine translates it to its final position.
/// - [`Display::None`] / [`Display::Contents`] → the element produces nothing.
///
/// [`measure`](Self::measure) is implemented for every context so flex sizing
/// and auto-height work regardless of the display value.
#[derive(Debug)]
pub struct CustomNodeBridge {
    node: std::sync::Arc<dyn CustomNode>,
    layout_style: Style,
}

impl CustomNodeBridge {
    pub fn new(node: std::sync::Arc<dyn CustomNode>, layout_style: Style) -> Self {
        Self { node, layout_style }
    }

    /// Builds the intrinsic-content child of a styled custom element.
    ///
    /// The containing `LayoutNode` owns the element's CSS sizing and spacing;
    /// applying them again to this bridge would duplicate padding and borders.
    pub fn new_content(node: std::sync::Arc<dyn CustomNode>, element_style: &Style) -> Self {
        let mut content_style = element_style.clone();
        content_style.size = SizeStyle {
            auto_behavior: AutoSizeBehavior::ShrinkToFit,
            ..Default::default()
        };
        content_style.box_sizing = Default::default();
        content_style.spacing = Default::default();
        Self::new(node, content_style)
    }

    /// Returns the resolved [`Style`] that drives this element's layout.
    ///
    /// The layout engine reads [`Display`](ui_layout::Display) from it, exactly
    /// as for a childless `LayoutNode`.
    pub fn style(&self) -> &Style {
        &self.layout_style
    }

    fn resolve_size(
        &self,
        containing_width: Option<f32>,
        containing_height: Option<f32>,
        viewport_width: f32,
        viewport_height: f32,
    ) -> ContentSize {
        resolve_border_box_size(
            self.node.as_ref(),
            &self.layout_style,
            containing_width,
            containing_height,
            viewport_width,
            viewport_height,
        )
    }
}

fn resolve_len(len: &ui_layout::Length, container: Option<f32>, viewport: f32) -> f32 {
    len.resolve_with(container, viewport, 0.0).unwrap_or(0.0)
}

fn spacing_px(
    style: &Style,
    cw: Option<f32>,
    ch: Option<f32>,
    vw: f32,
    vh: f32,
) -> (f32, f32, f32, f32, f32, f32, f32, f32) {
    let cbw = cw.unwrap_or(vw);
    let cbh = ch.unwrap_or(vh);
    (
        resolve_len(&style.spacing.border_left, Some(cbw), vw),
        resolve_len(&style.spacing.border_top, Some(cbh), vh),
        resolve_len(&style.spacing.border_right, Some(cbw), vw),
        resolve_len(&style.spacing.border_bottom, Some(cbh), vh),
        resolve_len(&style.spacing.padding_left, Some(cbw), vw),
        resolve_len(&style.spacing.padding_top, Some(cbh), vh),
        resolve_len(&style.spacing.padding_right, Some(cbw), vw),
        resolve_len(&style.spacing.padding_bottom, Some(cbh), vh),
    )
}

/// Geometry parameters for building a box model.
struct BoxGeometry {
    x: f32,
    y: f32,
    border_w: f32,
    border_h: f32,
    cw: Option<f32>,
    ch: Option<f32>,
    vw: f32,
    vh: f32,
}

fn make_box_model(geometry: &BoxGeometry, style: &Style) -> BoxModel {
    let (bl, bt, br, bb, pl, pt, pr, pb) =
        spacing_px(style, geometry.cw, geometry.ch, geometry.vw, geometry.vh);
    let border_box = Rect {
        x: geometry.x,
        y: geometry.y,
        width: geometry.border_w.max(0.0),
        height: geometry.border_h.max(0.0),
    };
    let padding_box = Rect {
        x: geometry.x + bl,
        y: geometry.y + bt,
        width: (geometry.border_w - bl - br).max(0.0),
        height: (geometry.border_h - bt - bb).max(0.0),
    };
    let content_box = Rect {
        x: geometry.x + bl + pl,
        y: geometry.y + bt + pt,
        width: (geometry.border_w - bl - br - pl - pr).max(0.0),
        height: (geometry.border_h - bt - bb - pt - pb).max(0.0),
    };
    BoxModel {
        sticky_edges: None,
        border_box,
        padding_box,
        content_box,
        children_box: content_box,
    }
}

impl CustomLayouter for CustomNodeBridge {
    fn layout(&mut self, ctx: &LayoutContext) -> LayoutBox {
        match self.layout_style.display {
            Display::OutsideInner {
                outer: OuterDisplay::Inline,
                ..
            } => {
                let x = ctx.start_pos.0;
                let y = ctx.start_pos.1;

                let resolved = self.resolve_size(
                    Some(ctx.available_inline_size),
                    None,
                    ctx.viewport_width,
                    ctx.viewport_height,
                );
                let box_model = make_box_model(
                    &BoxGeometry {
                        x,
                        y,
                        border_w: resolved.width,
                        border_h: resolved.height,
                        cw: Some(ctx.available_inline_size),
                        ch: None,
                        vw: ctx.viewport_width,
                        vh: ctx.viewport_height,
                    },
                    &self.layout_style,
                );

                LayoutBox::InlineBox(InlineBox {
                    box_model,
                    // Atomic inline replaced elements leave positioning to
                    // the flow engine. A pre-populated span is interpreted as
                    // text-flow output and only contributes `line-height`,
                    // which collapses a tall image's containing inline-block.
                    line_spans: Vec::new(),
                })
            }
            Display::OutsideInner {
                outer: OuterDisplay::Block,
                ..
            } => {
                let resolved = self.resolve_size(
                    ctx.containing_block_width,
                    ctx.containing_block_height,
                    ctx.viewport_width,
                    ctx.viewport_height,
                );
                let box_model = make_box_model(
                    &BoxGeometry {
                        x: 0.0,
                        y: 0.0,
                        border_w: resolved.width,
                        border_h: resolved.height,
                        cw: ctx.containing_block_width,
                        ch: ctx.containing_block_height,
                        vw: ctx.viewport_width,
                        vh: ctx.viewport_height,
                    },
                    &self.layout_style,
                );

                LayoutBox::BlockBox(box_model)
            }
            Display::None | Display::Contents => LayoutBox::None,
        }
    }

    fn measure(&self, ctx: &LayoutContext) -> ui_layout::MeasureResult {
        let resolved = self.resolve_size(
            ctx.containing_block_width,
            ctx.containing_block_height,
            ctx.viewport_width,
            ctx.viewport_height,
        );

        ui_layout::MeasureResult {
            width: resolved.width,
            height: resolved.height,
        }
    }

    fn write_debug(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "CustomNodeBridge")
    }
}

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

    use crate::engine::layouter::types::{TextFlowStyle, TextStyle};
    use crate::engine::renderer_model::DrawCommand;
    use ui_layout::InnerDisplay;

    #[derive(Debug)]
    struct TestNode {
        width: f32,
        height: f32,
    }

    impl CustomNode for TestNode {
        fn draw_sized(
            &self,
            _cmd_buf: &mut Vec<DrawCommand>,
            _text_style: &TextStyle,
            _text_flow_style: &TextFlowStyle,
            _style: &Style,
            _size: ContentSize,
        ) {
        }

        fn intrinsic_size(&self) -> ContentSize {
            ContentSize {
                width: self.width,
                height: self.height,
            }
        }
    }

    fn bridge(display: Display) -> CustomNodeBridge {
        let style = Style {
            display,
            ..Style::default()
        };
        CustomNodeBridge::new(
            std::sync::Arc::new(TestNode {
                width: 200.0,
                height: 100.0,
            }),
            style,
        )
    }

    #[test]
    fn block_context_reports_block() {
        assert_eq!(
            bridge(Display::OutsideInner {
                outer: OuterDisplay::Block,
                inner: InnerDisplay::Flow,
            })
            .style()
            .display
            .outer(),
            Some(OuterDisplay::Block)
        );
    }

    #[test]
    fn block_layout_returns_block_box_at_origin() {
        let mut b = bridge(Display::OutsideInner {
            outer: OuterDisplay::Block,
            inner: InnerDisplay::Flow,
        });
        match b.layout(&LayoutContext::default()) {
            LayoutBox::BlockBox(bm) => {
                assert_eq!(bm.border_box.x, 0.0);
                assert_eq!(bm.border_box.y, 0.0);
                assert_eq!(bm.border_box.width, 200.0);
                assert_eq!(bm.border_box.height, 100.0);
            }
            other => panic!("expected BlockBox, got {:?}", other),
        }
    }

    #[test]
    fn block_measure_returns_intrinsic_size() {
        let b = bridge(Display::OutsideInner {
            outer: OuterDisplay::Block,
            inner: InnerDisplay::Flow,
        });
        let m = b.measure(&LayoutContext::default());
        assert_eq!(m.width, 200.0);
        assert_eq!(m.height, 100.0);
    }

    #[test]
    fn inline_context_reports_inline() {
        assert_eq!(
            bridge(Display::OutsideInner {
                outer: OuterDisplay::Inline,
                inner: InnerDisplay::Flow,
            })
            .style()
            .display
            .outer(),
            Some(OuterDisplay::Inline)
        );
    }

    #[test]
    fn inline_layout_returns_an_atomic_unpositioned_box() {
        let mut b = bridge(Display::OutsideInner {
            outer: OuterDisplay::Inline,
            inner: InnerDisplay::Flow,
        });
        let ctx = LayoutContext {
            start_pos: (10.0, 20.0),
            available_inline_size: 300.0,
            viewport_width: 800.0,
            viewport_height: 600.0,
            ..LayoutContext::default()
        };
        match b.layout(&ctx) {
            LayoutBox::InlineBox(inline) => {
                assert_eq!(inline.box_model.border_box.x, 10.0);
                assert_eq!(inline.box_model.border_box.y, 20.0);
                assert_eq!(inline.box_model.border_box.width, 200.0);
                assert_eq!(inline.box_model.border_box.height, 100.0);
                assert!(inline.line_spans.is_empty());
            }
            other => panic!("expected InlineBox, got {:?}", other),
        }
    }

    #[test]
    fn content_bridge_does_not_apply_element_spacing_or_size_twice() {
        use ui_layout::{Length, LengthOrAuto};

        let style = Style {
            display: Display::OutsideInner {
                outer: OuterDisplay::Inline,
                inner: InnerDisplay::FlowRoot,
            },
            size: SizeStyle {
                width: LengthOrAuto::Length(Length::Px(300.0)),
                height: LengthOrAuto::Length(Length::Px(200.0)),
                ..Default::default()
            },
            spacing: ui_layout::Spacing {
                padding_left: Length::Px(13.0),
                padding_right: Length::Px(13.0),
                border_left: Length::Px(1.0),
                border_right: Length::Px(1.0),
                ..Default::default()
            },
            ..Default::default()
        };
        let mut bridge = CustomNodeBridge::new_content(
            std::sync::Arc::new(TestNode {
                width: 40.0,
                height: 20.0,
            }),
            &style,
        );
        let ctx = LayoutContext {
            available_inline_size: 500.0,
            viewport_width: 800.0,
            viewport_height: 600.0,
            ..LayoutContext::default()
        };

        match bridge.layout(&ctx) {
            LayoutBox::InlineBox(inline) => {
                assert_eq!(inline.box_model.border_box.size(), (40.0, 20.0));
                assert_eq!(inline.box_model.content_box.size(), (40.0, 20.0));
            }
            other => panic!("expected InlineBox, got {:?}", other),
        }
    }

    #[test]
    fn inline_measure_returns_intrinsic_size() {
        let b = bridge(Display::OutsideInner {
            outer: OuterDisplay::Inline,
            inner: InnerDisplay::Flow,
        });
        let m = b.measure(&LayoutContext::default());
        assert_eq!(m.width, 200.0);
        assert_eq!(m.height, 100.0);
    }

    #[test]
    fn none_context_skips_element() {
        let mut b = bridge(Display::None);
        assert_eq!(b.style().display, Display::None);
        assert!(matches!(
            b.layout(&LayoutContext::default()),
            LayoutBox::None
        ));
    }

    #[test]
    fn inline_size_resolves_against_available_inline_size() {
        use ui_layout::{Length, LengthOrAuto};

        let mut style = Style {
            size: ui_layout::SizeStyle {
                width: LengthOrAuto::Length(Length::Percent(50.0)),
                ..Default::default()
            },
            ..Default::default()
        };
        style.display = Display::OutsideInner {
            outer: OuterDisplay::Inline,
            inner: InnerDisplay::Flow,
        };
        let b = CustomNodeBridge::new(
            std::sync::Arc::new(TestNode {
                width: 200.0,
                height: 100.0,
            }),
            style,
        );
        let mut b = b;
        let ctx = LayoutContext {
            start_pos: (0.0, 0.0),
            available_inline_size: 150.0,
            viewport_width: 800.0,
            viewport_height: 600.0,
            ..LayoutContext::default()
        };
        match b.layout(&ctx) {
            LayoutBox::InlineBox(inline) => {
                assert_eq!(inline.box_model.border_box.width, 75.0);
            }
            other => panic!("expected InlineBox, got {:?}", other),
        }
    }
}