Struct LayoutNode 

#[non_exhaustive]
pub struct LayoutNode {
    pub style: Style,
    pub self_fragments: Vec<ItemFragment>,
    pub children: Vec<LayoutNode>,
    pub layout_boxes: LayoutBoxes,
    pub placements: Vec<FragmentPlacement>,
    /* private fields */
}

A node in the layout tree.

A LayoutNode represents a single layout object and is responsible for:

• Holding layout-related style information
• Owning child layout nodes (structural hierarchy)
• Providing inline fragment inputs
• Storing layout results (box model and fragment placements)

Fragment model

self_fragments represent the input fragments provided by the user. They are immutable logical units and are never reordered by the layout engine.

placements represent the layout result for fragments. Each entry corresponds 1:1 to self_fragments and stores relative placement information computed during layout.

Only inline-level nodes are expected to have non-empty self_fragments. For block-level or flex-level nodes, this vector should be empty.

Layout invariants

• The order of self_fragments is preserved during layout
• placements.len() == self_fragments.len() after layout
• placements are meaningful only after layout computation

This structure intentionally does not distinguish between inline, block, or flex nodes at the type level; their behavior is defined by Style::display.

Results storage

Results of the layout process are stored directly within each LayoutNode, allowing for easy access and further processing after layout computation. This includes the computed BoxModel and fragment placements.

• layout_boxes: The computed box model for this node after layout.
• placements: The computed placements for each fragment in self_fragments.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

style: Style

self_fragments: Vec<ItemFragment>

children: Vec<LayoutNode>

layout_boxes: LayoutBoxes

placements: Vec<FragmentPlacement>

Implementations

impl LayoutNode

pub fn new(style: Style) -> Self

Examples found in repository

examples/layout_flex_chain_bench.rs (lines 6-23)

fn node(display: Display) -> LayoutNode {
    LayoutNode::new(Style {
        display,
        spacing: Spacing {
            margin_left: Length::Px(2.0),
            margin_right: Length::Px(2.0),
            padding_left: Length::Px(1.0),
            padding_right: Length::Px(1.0),
            border_left: Length::Px(1.0),
            border_right: Length::Px(1.0),
            ..Default::default()
        },
        size: SizeStyle {
            min_width: Length::Px(0.0),
            max_width: Length::Px(10_000.0),
            ..Default::default()
        },
        ..Default::default()
    })
}

examples/layout_bench.rs (lines 5-37)

fn make_node(is_flex: bool) -> LayoutNode {
    LayoutNode::new(Style {
        display: if is_flex {
            Display::Flex {
                flex_direction: FlexDirection::Row,
            }
        } else {
            Display::Block
        },
        size: SizeStyle {
            width: Length::Auto,
            height: Length::Auto,
            min_width: Length::Px(0.0),
            max_width: Length::Px(10_000.0),
            min_height: Length::Px(0.0),
            max_height: Length::Px(10_000.0),
        },
        spacing: Spacing {
            margin_left: Length::Px(2.0),
            margin_right: Length::Px(2.0),
            margin_top: Length::Px(1.0),
            margin_bottom: Length::Px(1.0),
            padding_left: Length::Px(1.0),
            padding_right: Length::Px(1.0),
            padding_top: Length::Px(1.0),
            padding_bottom: Length::Px(1.0),
            border_left: Length::Px(1.0),
            border_right: Length::Px(1.0),
            border_top: Length::Px(1.0),
            border_bottom: Length::Px(1.0),
            ..Default::default()
        },
        ..Default::default()
    })
}

pub fn with_children(style: Style, children: Vec<LayoutNode>) -> Self

pub fn set_fragments(&mut self, fragments: Vec<ItemFragment>)

Sets input fragments for this node.

This method defines the inline content owned by the node. Any previously computed fragment placements become invalid and must be recomputed during the next layout pass.

Trait Implementations

impl Debug for LayoutNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.