Struct Cell 

pub struct Cell { /* private fields */ }

A leaf cell in the layout tree. Carries an optional Measure and an optional CellId. Build with Cell::empty or Cell::measured; shorthand: Grid::cell returns Cell::empty().

Implementations

impl Cell

pub fn empty() -> Self

An empty leaf with zero intrinsic size. Useful as a tagged placeholder inside a parent grid track.

Examples found in repository

examples/nesting_deep.rs (line 30)

fn plain(id: &str) -> Patch {
    Patch::new(id).slot(Slot::Panel, Cell::empty())
}

fn color_for_region(region: &str) -> Color {
    match region {
        "panel" => rgb8(40, 60, 90),
        "axis_top" => rgb8(200, 100, 130),
        "axis_bottom" => rgb8(160, 100, 130),
        _ => rgb8(120, 120, 120),
    }
}

fn main() {
    let (w, h) = (1400u32, 400u32);
    let dpi = 96.0;

    // Deepest level: two plots, the first carries the chrome that needs
    // to propagate all the way up to the root composition.
    let leaf = beside(
        Patch::new("leaf_l")
            .slot(Slot::AxisTop, text_cell("axis_top from deepest leaf", 14.0))
            .slot(Slot::AxisBottom, text_cell("axis_bottom from leaf", 11.0))
            .slot(Slot::Panel, Cell::empty()),
        plain("leaf_r"),
    );
    // Mid level: a plain plot beside the leaf composition.
    let mid = beside(plain("mid"), leaf);
    // Root level: a plain plot beside the mid composition.
    let composed = beside(plain("root"), mid);

    let layout = composed.solve(hephaestus::Size::new(w as f64, h as f64), dpi);

    let mut renderer = VelloRenderer::new().expect("vello renderer init");
    {
        let scene = renderer.scene();
        let stroke = hephaestus::stroke::Stroke::new(1.0);
        let text_brush: Brush = rgb8(20, 20, 30).into();

        for (_id, region, rect) in layout.iter() {
            if region == "panel" {
                continue;
            }
            let c = color_for_region(region);
            let tint = Color::new([c.components[0], c.components[1], c.components[2], 0.20]);
            let path: Path = rect.to_path(0.1);
            scene.fill(
                FillRule::NonZero,
                Affine::IDENTITY,
                &Brush::Solid(tint),
                None,
                &path,
                PickId::Skip,
            );
            scene.stroke(
                &stroke,
                Affine::IDENTITY,
                &Brush::Solid(c),
                None,
                &path,
                PickId::Skip,
            );
        }
        for (_id, region, rect) in layout.iter() {
            if region != "panel" {
                continue;
            }
            let path: Path = rect.to_path(0.1);
            scene.fill(
                FillRule::NonZero,
                Affine::IDENTITY,
                &Brush::Solid(color_for_region(region)),
                None,
                &path,
                PickId::Skip,
            );
            scene.stroke(
                &stroke,
                Affine::IDENTITY,
                &Brush::Solid(rgb8(255, 255, 255)),
                None,
                &path,
                PickId::Skip,
            );
        }

        if let Some(rect) = layout.get("leaf_l", Slot::AxisTop) {
            let run = TextRun::new("axis_top from deepest leaf", &TextStyle::new(14.0), 96.0);
            draw_text_in_rect(scene, &run, rect, &text_brush, PickId::Skip);
        }
        if let Some(rect) = layout.get("leaf_l", Slot::AxisBottom) {
            let run = TextRun::new("axis_bottom from leaf", &TextStyle::new(11.0), 96.0);
            draw_text_in_rect(scene, &run, rect, &text_brush, PickId::Skip);
        }
    }

    let mut pixels = vec![0u8; (w * h * 4) as usize];
    let bg: Color = rgb8(248, 248, 252);
    renderer
        .render_to_buffer(w, h, bg, &mut pixels)
        .expect("render");

    let path = std::env::current_dir()
        .unwrap()
        .join("examples/nesting_deep.png");
    hephaestus::image::write_png(&path, w, h, &pixels).expect("write png");
    println!("wrote {}", path.display());

    // Print panel y0s so the user can verify alignment across all 3 nesting levels.
    let root_panel = layout.get("root", Slot::Panel).unwrap();
    let mid_panel = layout.get("mid", Slot::Panel).unwrap();
    let leaf_l_panel = layout.get("leaf_l", Slot::Panel).unwrap();
    let leaf_r_panel = layout.get("leaf_r", Slot::Panel).unwrap();
    println!(
        "panel y0: root={}, mid={}, leaf_l={}, leaf_r={}",
        root_panel.y0, mid_panel.y0, leaf_l_panel.y0, leaf_r_panel.y0
    );
    println!("(all four should be equal — propagation across 3 nesting levels)");
}

examples/nesting_fixed_aspect.rs (line 48)

fn plain(id: &str) -> Patch {
    Patch::new(id).slot(Slot::Panel, Cell::empty())
}

fn fixed_square(id: &str, label: &str) -> Patch {
    // Chrome on a fixed patch is fine — the solver's second iteration
    // picks up the resolved Auto-row heights from iter 0 and reshapes
    // the respected fr distribution to honour the lock anyway. The
    // axis_top here proves it: panels still report ratio = 1.000.
    Patch::new(id)
        .aspect(1.0, 1.0)
        .slot(Slot::AxisTop, text_cell(label, 12.0))
        .slot(Slot::Panel, Cell::empty())
}

examples/nesting_chrome_coupling.rs (line 40)

fn plain_plot(id: &str) -> Patch {
    Patch::new(id).slot(Slot::Panel, Cell::empty())
}

fn plot_with_axis_top(id: &str, axis_top_text: &str) -> Patch {
    Patch::new(id)
        .slot(Slot::AxisTop, text_cell(axis_top_text, 14.0))
        .slot(Slot::Panel, Cell::empty())
}

examples/nesting_outer_chrome_propagates.rs (line 46)

fn plain_plot(id: &str) -> Patch {
    Patch::new(id).slot(Slot::Panel, Cell::empty())
}

fn color_for_region(region: &str) -> Color {
    match region {
        "panel" => rgb8(40, 60, 90),
        "axis_top" => rgb8(200, 100, 130),
        _ => rgb8(120, 120, 120),
    }
}

fn main() {
    let (w, h) = (1400u32, 400u32);
    let dpi = 96.0;

    // Top-level chrome lives on the LEFT sibling. The right side is a
    // nested composition with three plain inner patches.
    let outer_with_chrome = Patch::new("outer_plain")
        .slot(
            Slot::AxisTop,
            text_cell(
                "axis_top on the outer SIBLING patch\nspans multiple lines\nto propagate INTO the nested composition",
                14.0,
            ),
        )
        .slot(Slot::Panel, Cell::empty());
    let nested = grid(
        1,
        3,
        vec![
            plain_plot("c1").into(),
            plain_plot("c2").into(),
            plain_plot("c3").into(),
        ],
    );
    let composed = beside(outer_with_chrome, nested);
    let layout = composed.solve(hephaestus::Size::new(w as f64, h as f64), dpi);

    let mut renderer = VelloRenderer::new().expect("vello renderer init");
    {
        let scene = renderer.scene();
        let stroke = hephaestus::stroke::Stroke::new(1.0);
        let text_brush: Brush = rgb8(20, 20, 30).into();

        for (_id, region, rect) in layout.iter() {
            if region == "panel" {
                continue;
            }
            let c = color_for_region(region);
            let tint = Color::new([c.components[0], c.components[1], c.components[2], 0.20]);
            let path: Path = rect.to_path(0.1);
            scene.fill(
                FillRule::NonZero,
                Affine::IDENTITY,
                &Brush::Solid(tint),
                None,
                &path,
                PickId::Skip,
            );
            scene.stroke(
                &stroke,
                Affine::IDENTITY,
                &Brush::Solid(c),
                None,
                &path,
                PickId::Skip,
            );
        }
        for (_id, region, rect) in layout.iter() {
            if region != "panel" {
                continue;
            }
            let path: Path = rect.to_path(0.1);
            scene.fill(
                FillRule::NonZero,
                Affine::IDENTITY,
                &Brush::Solid(color_for_region(region)),
                None,
                &path,
                PickId::Skip,
            );
            scene.stroke(
                &stroke,
                Affine::IDENTITY,
                &Brush::Solid(rgb8(255, 255, 255)),
                None,
                &path,
                PickId::Skip,
            );
        }

        if let Some(rect) = layout.get("outer_plain", Slot::AxisTop) {
            let run = TextRun::new(
                "axis_top on the outer SIBLING patch\nspans multiple lines\nto propagate INTO the nested composition",
                &TextStyle::new(14.0),
                96.0,
            );
            draw_text_in_rect(scene, &run, rect, &text_brush, PickId::Skip);
        }
    }

    let mut pixels = vec![0u8; (w * h * 4) as usize];
    let bg: Color = rgb8(248, 248, 252);
    renderer
        .render_to_buffer(w, h, bg, &mut pixels)
        .expect("render");

    let path = std::env::current_dir()
        .unwrap()
        .join("examples/nesting_outer_chrome_propagates.png");
    hephaestus::image::write_png(&path, w, h, &pixels).expect("write png");
    println!("wrote {}", path.display());

    // Sanity check: all four panels share y0, even though only the outer
    // sibling carries the axis_top content. The back sizer drives the
    // nested inner row 8 from the outer-resolved row 8.
    let outer_y = layout.get("outer_plain", Slot::Panel).unwrap();
    let c1_y = layout.get("c1", Slot::Panel).unwrap();
    let c2_y = layout.get("c2", Slot::Panel).unwrap();
    let c3_y = layout.get("c3", Slot::Panel).unwrap();
    println!(
        "panel y0: outer_plain={}, c1={}, c2={}, c3={}",
        outer_y.y0, c1_y.y0, c2_y.y0, c3_y.y0
    );
    println!("(all four should be equal — outer chrome propagated INTO the nested composition via back sizers)");
}

examples/nesting_faceted_title.rs (line 48)

fn facet(id: &str, axis_left: &str, axis_bottom: &str) -> Patch {
    Patch::new(id)
        .slot(Slot::AxisLeft, text_cell(axis_left, 11.0))
        .slot(Slot::AxisBottom, text_cell(axis_bottom, 11.0))
        .slot(Slot::Panel, Cell::empty())
}

examples/nesting_asymmetric.rs (line 30)

fn plot(id: &str, title: &str, axis_left: &str, axis_bottom: &str) -> Patch {
    Patch::new(id)
        .slot(Slot::Title, text_cell(title, 16.0))
        .slot(Slot::AxisLeft, text_cell(axis_left, 11.0))
        .slot(Slot::AxisBottom, text_cell(axis_bottom, 11.0))
        .slot(Slot::Panel, Cell::empty())
}

Additional examples can be found in:

• examples/composition_demo.rs

pub fn measured(m: impl Measure + 'static) -> Self

A leaf whose intrinsic size comes from m.

Examples found in repository

examples/composition_demo.rs (line 20)

fn text_cell(text: &str, size: f32) -> Cell {
    Cell::measured(TextRun::new(text, &TextStyle::new(size), 96.0))
}

fn weighted_text_cell(text: &str, size: f32, weight: u16) -> Cell {
    Cell::measured(TextRun::new(
        text,
        &TextStyle::new(size).weight(weight),
        96.0,
    ))
}

examples/nesting_asymmetric.rs (line 22)

fn text_cell(text: &str, size: f32) -> Cell {
    Cell::measured(TextRun::new(text, &TextStyle::new(size), 96.0))
}

examples/nesting_chrome_coupling.rs (line 36)

fn text_cell(text: &str, size: f32) -> Cell {
    Cell::measured(TextRun::new(text, &TextStyle::new(size), 96.0))
}

examples/nesting_deep.rs (line 26)

fn text_cell(text: &str, size: f32) -> Cell {
    Cell::measured(TextRun::new(text, &TextStyle::new(size), 96.0))
}

examples/nesting_faceted_title.rs (line 33)

fn text_cell(text: &str, size: f32) -> Cell {
    Cell::measured(TextRun::new(text, &TextStyle::new(size), 96.0))
}

fn weighted_text_cell(text: &str, size: f32, weight: u16) -> Cell {
    Cell::measured(TextRun::new(
        text,
        &TextStyle::new(size).weight(weight),
        96.0,
    ))
}

examples/nesting_fixed_aspect.rs (line 44)

fn text_cell(text: &str, size: f32) -> Cell {
    Cell::measured(TextRun::new(text, &TextStyle::new(size), 96.0))
}

Additional examples can be found in:

• examples/nesting_outer_chrome_propagates.rs

pub fn measured_boxed(m: Box<dyn Measure>) -> Self

Like Self::measured but takes an already-boxed measure. Used when a caller has extracted a Box<dyn Measure> from another cell (via Self::into_measure) and wants to re-wrap it without unboxing.

pub fn id(self, id: CellId) -> Self

Tag this cell so its resolved rect is retrievable from Layout::rect.

Examples found in repository

examples/layout_demo.rs (line 26)

fn main() {
    let (w, h) = (800u32, 600u32);
    let dpi = 96.0;

    // Outer: 5 columns × 3 rows of fr(1).
    let mut root = Grid::new(vec![Track::Fr(1.0); 5], vec![Track::Fr(1.0); 3]);

    // Tag every outer cell so we can outline the underlying grid.
    let mut outer_id = 1u64;
    for r in 1..=3u16 {
        for c in 1..=5u16 {
            root.place_mut(Placement::at(r, c), Grid::cell().id(CellId(outer_id)));
            outer_id += 1;
        }
    }

    // Inner 2×2 in row 2, cols 3..=5, with 1cm left + 25% right insets.
    let mut inner = Grid::new(
        [Track::Fr(1.0), Track::Fr(1.0)],
        [Track::Fr(1.0), Track::Fr(1.0)],
    );
    for r in 1..=2u16 {
        for c in 1..=2u16 {
            inner.place_mut(
                Placement::at(r, c),
                Grid::cell().id(CellId(100 + (r as u64) * 2 + c as u64)),
            );
        }
    }
    root.place_mut(
        Placement::at(2, 3).span(1, 3).inset(
            Inset::default()
                .left(Extent::cm(1.0))
                .right(Extent::percent(0.25)),
        ),
        inner,
    );

    // A 2:1 cell in the top-left, expressed via respect + fr weights.
    root.place_mut(
        Placement::at(1, 1),
        Grid::new([Track::Fr(2.0)], [Track::Fr(1.0)])
            .respect()
            .id(CellId(200)),
    );

    let layout = root.solve(hephaestus::Size::new(w as f64, h as f64), dpi);

    // Render.
    let mut renderer = VelloRenderer::new().expect("vello renderer init");
    {
        let scene = renderer.scene();
        let outer_brush: Brush = rgb8(80, 90, 110).into();
        let outer_stroke = Stroke::new(1.0);
        for id in 1..=15u64 {
            if let Some(rect) = layout.rect(CellId(id)) {
                let path: Path = rect.to_path(0.1);
                scene.stroke(
                    &outer_stroke,
                    Affine::IDENTITY,
                    &outer_brush,
                    None,
                    &path,
                    PickId::Skip,
                );
            }
        }

        let inner_brush: Brush = rgb8(240, 180, 60).into();
        let inner_stroke = Stroke::new(2.0);
        for id in [103u64, 104, 105, 106] {
            if let Some(rect) = layout.rect(CellId(id)) {
                let path: Path = rect.to_path(0.1);
                scene.fill(
                    FillRule::NonZero,
                    Affine::IDENTITY,
                    &Brush::Solid(rgb8(245, 220, 160)),
                    None,
                    &path,
                    PickId::Skip,
                );
                scene.stroke(
                    &inner_stroke,
                    Affine::IDENTITY,
                    &inner_brush,
                    None,
                    &path,
                    PickId::Skip,
                );
            }
        }

        let aspect_brush: Brush = rgb8(60, 160, 220).into();
        if let Some(rect) = layout.rect(CellId(200)) {
            let path: Path = rect.to_path(0.1);
            scene.fill(
                FillRule::NonZero,
                Affine::IDENTITY,
                &aspect_brush,
                None,
                &path,
                PickId::Skip,
            );
        }
    }

    let mut pixels = vec![0u8; (w * h * 4) as usize];
    let bg: Color = rgb8(20, 22, 28);
    renderer
        .render_to_buffer(w, h, bg, &mut pixels)
        .expect("render");

    let path = std::env::current_dir()
        .unwrap()
        .join("examples/layout_demo.png");
    hephaestus::image::write_png(&path, w, h, &pixels).expect("write png");
    println!("wrote {}", path.display());
}

pub fn into_measure(self) -> Box<dyn Measure>

Consume this cell and return its Measure. Callers that need to merge multiple cells into one (e.g. the orchestrator when several plots contribute to the same patch slot) extract the inner measures here and wrap them in MaxMergeMeasure.

pub fn cell_id(&self) -> Option<CellId>

Borrow this cell’s identifier tag, if any.

Trait Implementations

impl From<Cell> for Node

fn from(c: Cell) -> Self

Converts to this type from the input type.