Enum LayoutNode

pub enum LayoutNode {
    Leaf,
    Padding {
        padding: EdgeInsets,
        child: Box<LayoutNode>,
    },
    Stack {
        children: Vec<LayoutNode>,
    },
    Column {
        children: Vec<LayoutNode>,
    },
    Clip {
        child: Box<LayoutNode>,
    },
    ScrollY {
        scroll_y: f32,
        child: Box<LayoutNode>,
    },
}

Retained layout tree node (experimental; coexists with Widget trait layout).

This is not a compatibility shim; it is intended as the future retained layout engine base. Geometry is in logical pixels and values are not validated for finiteness. ScrollY::scroll_y is currently retained but deliberately has no effect on child offsets; callers must not yet rely on this node for visible scrolling.

Examples

use ailloli_ui_core::{Constraints, EdgeInsets, Scale, Size};
use ailloli_ui_runtime::layout::{LayoutCtx, LayoutNode};

let mut node = LayoutNode::Padding {
    padding: EdgeInsets::all(2.0),
    child: Box::new(LayoutNode::Leaf),
};
let result = node.layout(&LayoutCtx::new(Scale::new(1.0)), Constraints::tight(20.0, 10.0));
assert_eq!(result.size, Size::new(20.0, 10.0));
assert_eq!(result.children[0].offset.x, 2.0);

Variants

Leaf

Fills the stored maximum constraints and has no children.

Padding

Insets one child by per-side logical pixels.

Fields

padding: EdgeInsets

Insets subtracted from child constraints and added around its size.

child: Box<LayoutNode>

Sole retained child.

Stack

Overlays every child at offset (0, 0) and fills the maximum constraints.

Fields

children: Vec<LayoutNode>

Children painted in stored order.

Column

Places children top-to-bottom, giving each the full maximum height.

Fields

children: Vec<LayoutNode>

Children laid out in stored order; heights are summed then constrained.

Clip

Replaces one child’s bounds with a rectangular clip matching its size.

Fields

child: Box<LayoutNode>

Sole clipped child.

ScrollY

Measures a vertically unbounded child inside a fixed viewport.

Fields

scroll_y: f32

Requested vertical offset in logical pixels; currently stored but ignored.

child: Box<LayoutNode>

Content measured with infinite maximum height.

Implementations

impl LayoutNode

Provides the operations defined for LayoutNode.

pub fn layout( &mut self, _ctx: &LayoutCtx<'_>, constraints: Constraints, ) -> LayoutResult

Recursively lays out this experimental node tree.

Leaf and Stack use the raw maximum constraints, so an unbounded axis can produce an infinite size. Column does not reduce remaining height between children. Padding preserves only child geometry, while child clips, overlays, and artifacts are not propagated into its parent result. ScrollY clips to the viewport but currently ignores its scroll_y value and does not translate child geometry.

Panics

Constraint operations may panic when normalized bounds contain NaN.

Examples

use ailloli_ui_core::{Constraints, Scale, Size};
use ailloli_ui_runtime::layout::{LayoutCtx, LayoutNode};

let mut node = LayoutNode::Column {
    children: vec![LayoutNode::Leaf, LayoutNode::Leaf],
};
let result = node.layout(&LayoutCtx::new(Scale::new(1.0)), Constraints::tight(10.0, 5.0));
assert_eq!(result.size, Size::new(10.0, 5.0));
assert_eq!(result.children[1].offset.y, 5.0);

Trait Implementations

impl Clone for LayoutNode

fn clone(&self) -> LayoutNode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LayoutNode

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

Formats the value using the given formatter.