tessera_components/

row.rs

//! A horizontal layout component.
//!
//! ## Usage
//!
//! Use to stack children horizontally.
use tessera_ui::{
    __private::configure_layout_node,
    AxisConstraint, ComputedData, Constraint, LayoutResult, MeasurementError, Modifier,
    NoopDrawModifier, Px, PxPosition, RenderSlot,
    layout::{LayoutChild, LayoutPlacementTarget, MeasureScope, PlacementResult, PlacementScope},
    tessera,
};

use crate::{
    alignment::{CrossAxisAlignment, MainAxisAlignment},
    layout_flex::{classify_children, cross_axis_child_constraint},
};

struct PlaceChildrenArgs<'a, T> {
    children_sizes: &'a [Option<ComputedData>],
    children: &'a [T],
    final_row_width: Px,
    final_row_height: Px,
    total_children_width: Px,
    main_axis_alignment: MainAxisAlignment,
    cross_axis_alignment: CrossAxisAlignment,
    child_count: usize,
}

struct MeasureWeightedChildrenArgs<'a> {
    weighted_indices: &'a [usize],
    children_sizes: &'a mut [Option<ComputedData>],
    max_child_height: &'a mut Px,
    remaining_width: Px,
    total_weight: f32,
    row_parent_constraint: &'a Constraint,
    child_weights: &'a [f32],
    cross_axis_alignment: CrossAxisAlignment,
}

#[derive(Clone, PartialEq)]
struct RowLayout {
    main_axis_alignment: MainAxisAlignment,
    cross_axis_alignment: CrossAxisAlignment,
}

impl tessera_ui::LayoutModifierNode for RowLayout {
    fn measure_eq(&self, other: &Self) -> bool {
        (self.cross_axis_alignment == CrossAxisAlignment::Stretch)
            == (other.cross_axis_alignment == CrossAxisAlignment::Stretch)
    }

    fn place_children(
        &self,
        scope: &PlacementScope<'_>,
        _inner: &PlacementResult,
    ) -> Option<PlacementResult> {
        let children = scope.children();
        let children_sizes = children
            .iter()
            .map(|child| Some(child.size()))
            .collect::<Vec<_>>();
        let total_children_width = children
            .iter()
            .map(|child| child.size().width)
            .fold(Px::ZERO, |total, size| total + size);
        let mut result = LayoutResult::new(scope.size());
        place_children_with_alignment(
            &PlaceChildrenArgs {
                children_sizes: &children_sizes,
                children: &children,
                final_row_width: scope.size().width,
                final_row_height: scope.size().height,
                total_children_width,
                main_axis_alignment: self.main_axis_alignment,
                cross_axis_alignment: self.cross_axis_alignment,
                child_count: children.len(),
            },
            &mut result,
        );
        Some(result.into_placement_result())
    }

    fn measure(&self, input: &mut MeasureScope<'_>) -> Result<LayoutResult, MeasurementError> {
        let mut result = LayoutResult::default();
        let children = input.children();
        let child_weights = collect_child_weights(input, &children);
        let row_parent_constraint = *input.parent_constraint().as_ref();

        let has_weighted_children = child_weights.iter().any(|&weight| weight > 0.0);
        let should_use_weight_for_width =
            has_weighted_children && row_parent_constraint.width.resolve_max().is_some();

        if should_use_weight_for_width {
            measure_weighted_row(
                &children,
                input,
                &mut result,
                self.main_axis_alignment,
                self.cross_axis_alignment,
                &child_weights,
                &row_parent_constraint,
            )
        } else {
            measure_unweighted_row(
                &children,
                input,
                &mut result,
                self.main_axis_alignment,
                self.cross_axis_alignment,
                &row_parent_constraint,
            )
        }
    }
}

/// # row
///
/// A layout component that arranges its children in a horizontal row.
///
/// ## Usage
///
/// Stack components horizontally, with options for alignment and flexible
/// spacing.
///
/// ## Parameters
///
/// - `modifier` — modifier chain applied to the row container.
/// - `main_axis_alignment` — alignment along the horizontal axis.
/// - `cross_axis_alignment` — alignment along the vertical axis.
/// - `children` — child slot rendered inside the row.
///
/// ## Examples
///
/// ```
/// use tessera_components::{modifier::ModifierExt as _, row::row, spacer::spacer, text::text};
/// use tessera_ui::Modifier;
///
/// # use tessera_ui::tessera;
/// # #[tessera]
/// # fn component() {
/// row().children(|| {
///     text("First");
///     spacer().modifier(Modifier::new().weight(1.0));
///     text("Last");
/// });
/// # }
/// # tessera_ui::testing::layout_test(component).run();
/// ```
#[tessera(tessera_ui, layout)]
pub fn row(
    modifier: Option<Modifier>,
    main_axis_alignment: Option<MainAxisAlignment>,
    cross_axis_alignment: Option<CrossAxisAlignment>,
    children: Option<RenderSlot>,
) {
    let modifier = modifier.unwrap_or_default();
    let main_axis_alignment = main_axis_alignment.unwrap_or_default();
    let cross_axis_alignment = cross_axis_alignment.unwrap_or_default();
    configure_layout_node(
        RowLayout {
            main_axis_alignment,
            cross_axis_alignment,
        },
        NoopDrawModifier,
        modifier,
    );
    children.unwrap_or_else(RenderSlot::empty).render();
}

fn measure_weighted_row(
    children: &[LayoutChild],
    input: &mut MeasureScope<'_>,
    result: &mut LayoutResult,
    main_axis_alignment: MainAxisAlignment,
    cross_axis_alignment: CrossAxisAlignment,
    child_weights: &[f32],
    row_parent_constraint: &Constraint,
) -> Result<LayoutResult, MeasurementError> {
    let mut children_sizes = vec![None; child_weights.len()];
    let mut max_child_height = Px(0);
    let available_width_for_children = row_parent_constraint
        .width
        .resolve_max()
        .expect("Row width Fill expected with finite max constraint");

    let (weighted_indices, unweighted_indices, total_weight) = classify_children(child_weights);

    let total_width_of_unweighted_children = measure_unweighted_children(
        children,
        input,
        &unweighted_indices,
        &mut children_sizes,
        &mut max_child_height,
        row_parent_constraint,
        cross_axis_alignment,
    )?;

    measure_weighted_children(
        children,
        input,
        &mut MeasureWeightedChildrenArgs {
            weighted_indices: &weighted_indices,
            children_sizes: &mut children_sizes,
            max_child_height: &mut max_child_height,
            remaining_width: (available_width_for_children - total_width_of_unweighted_children)
                .max(Px::ZERO),
            total_weight,
            row_parent_constraint,
            child_weights,
            cross_axis_alignment,
        },
    )?;

    let final_row_width = available_width_for_children;
    let final_row_height = row_parent_constraint.height.clamp(max_child_height);

    let total_measured_children_width: Px = children_sizes
        .iter()
        .filter_map(|s| s.map(|s| s.width))
        .fold(Px(0), |acc, w| acc + w);

    place_children_with_alignment(
        &PlaceChildrenArgs {
            children_sizes: &children_sizes,
            children,
            final_row_width,
            final_row_height,
            total_children_width: total_measured_children_width,
            main_axis_alignment,
            cross_axis_alignment,
            child_count: child_weights.len(),
        },
        result,
    );

    result.size = ComputedData {
        width: final_row_width,
        height: final_row_height,
    };
    Ok(result.clone())
}

fn measure_unweighted_row(
    children: &[LayoutChild],
    input: &mut MeasureScope<'_>,
    result: &mut LayoutResult,
    main_axis_alignment: MainAxisAlignment,
    cross_axis_alignment: CrossAxisAlignment,
    row_parent_constraint: &Constraint,
) -> Result<LayoutResult, MeasurementError> {
    let mut children_sizes = vec![None; children.len()];
    let mut total_children_measured_width = Px(0);
    let mut max_child_height = Px(0);

    for (i, child_id) in children.iter().enumerate() {
        let parent_offered_constraint_for_child = Constraint::new(
            AxisConstraint::new(
                Px::ZERO,
                row_parent_constraint
                    .width
                    .resolve_max()
                    .map(|max| (max - total_children_measured_width).max(Px::ZERO)),
            ),
            cross_axis_child_constraint(row_parent_constraint.height, cross_axis_alignment),
        );
        let child_result = child_id.measure(input, &parent_offered_constraint_for_child)?;
        children_sizes[i] = Some(child_result.size());
        total_children_measured_width += child_result.width;
        max_child_height = max_child_height.max(child_result.height);
    }

    let final_row_width = row_parent_constraint
        .width
        .clamp(total_children_measured_width);
    let final_row_height = row_parent_constraint.height.clamp(max_child_height);

    place_children_with_alignment(
        &PlaceChildrenArgs {
            children_sizes: &children_sizes,
            children,
            final_row_width,
            final_row_height,
            total_children_width: total_children_measured_width,
            main_axis_alignment,
            cross_axis_alignment,
            child_count: children_sizes.len(),
        },
        result,
    );

    result.size = ComputedData {
        width: final_row_width,
        height: final_row_height,
    };
    Ok(result.clone())
}

fn measure_unweighted_children(
    children: &[LayoutChild],
    input: &mut MeasureScope<'_>,
    unweighted_indices: &[usize],
    children_sizes: &mut [Option<ComputedData>],
    max_child_height: &mut Px,
    row_parent_constraint: &Constraint,
    cross_axis_alignment: CrossAxisAlignment,
) -> Result<Px, MeasurementError> {
    let mut total_width = Px(0);

    for &child_idx in unweighted_indices {
        let parent_offered_constraint_for_child = Constraint::new(
            AxisConstraint::new(
                Px::ZERO,
                row_parent_constraint
                    .width
                    .resolve_max()
                    .map(|max| (max - total_width).max(Px::ZERO)),
            ),
            cross_axis_child_constraint(row_parent_constraint.height, cross_axis_alignment),
        );
        let child_id = children[child_idx];
        let child_result = child_id.measure(input, &parent_offered_constraint_for_child)?;
        children_sizes[child_idx] = Some(child_result.size());
        total_width += child_result.width;
        *max_child_height = (*max_child_height).max(child_result.height);
    }

    Ok(total_width)
}

fn measure_weighted_children(
    children: &[LayoutChild],
    scope: &mut MeasureScope<'_>,
    args: &mut MeasureWeightedChildrenArgs<'_>,
) -> Result<(), MeasurementError> {
    if args.total_weight <= 0.0 {
        return Ok(());
    }

    for &child_idx in args.weighted_indices {
        let child_weight = args.child_weights[child_idx];
        let allocated_width =
            Px((args.remaining_width.0 as f32 * (child_weight / args.total_weight)) as i32);
        let child_id = children[child_idx];
        let parent_offered_constraint_for_child = Constraint::new(
            AxisConstraint::exact(allocated_width),
            cross_axis_child_constraint(
                args.row_parent_constraint.height,
                args.cross_axis_alignment,
            ),
        );
        let child_result = child_id.measure(scope, &parent_offered_constraint_for_child)?;
        args.children_sizes[child_idx] = Some(child_result.size());
        *args.max_child_height = (*args.max_child_height).max(child_result.height);
    }

    Ok(())
}

fn collect_child_weights(input: &MeasureScope<'_>, children: &[LayoutChild]) -> Vec<f32> {
    children
        .iter()
        .map(|child_id| {
            child_id
                .parent_data::<crate::modifier::WeightParentData>(input)
                .map(|data| data.weight)
                .unwrap_or(0.0)
        })
        .collect()
}

fn place_children_with_alignment<T: LayoutPlacementTarget>(
    args: &PlaceChildrenArgs<'_, T>,
    result: &mut LayoutResult,
) {
    let (mut current_x, spacing) = crate::layout_flex::main_axis_offsets(
        args.final_row_width,
        args.total_children_width,
        args.main_axis_alignment,
        args.child_count,
    );

    for (i, child_size_opt) in args.children_sizes.iter().enumerate() {
        if let Some(child_actual_size) = child_size_opt {
            let child_id = args.children[i];
            let y_offset = crate::layout_flex::cross_axis_offset(
                child_actual_size.height,
                args.final_row_height,
                args.cross_axis_alignment,
            );

            result.place_child(child_id, PxPosition::from_f32_xy(current_x, y_offset));
            current_x += child_actual_size.width.0 as f32;
            if i < args.child_count - 1 {
                current_x += spacing;
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use tessera_ui::{
        AxisConstraint, ComputedData, LayoutResult, MeasurementError, Modifier, NoopDrawModifier,
        Px,
        layout::{MeasureScope, layout},
        tessera,
    };

    use crate::{
        alignment::{CrossAxisAlignment, MainAxisAlignment},
        modifier::{ModifierExt as _, SemanticsArgs},
    };

    use super::row;

    #[derive(Clone, PartialEq)]
    struct FixedTestLayout {
        width: i32,
        height: i32,
    }

    #[derive(Clone, PartialEq)]
    struct FillWidthTestLayout {
        height: i32,
    }

    impl tessera_ui::LayoutModifierNode for FixedTestLayout {
        fn measure(&self, _input: &mut MeasureScope<'_>) -> Result<LayoutResult, MeasurementError> {
            Ok(LayoutResult::new(ComputedData {
                width: Px::new(self.width),
                height: Px::new(self.height),
            }))
        }
    }

    impl tessera_ui::LayoutModifierNode for FillWidthTestLayout {
        fn measure(&self, input: &mut MeasureScope<'_>) -> Result<LayoutResult, MeasurementError> {
            let width = input
                .parent_constraint()
                .width()
                .resolve_max()
                .expect("FillWidthTestLayout requires a bounded width constraint");

            Ok(LayoutResult::new(ComputedData {
                width,
                height: Px::new(self.height),
            }))
        }
    }

    #[tessera]
    fn fixed_test_box(tag: Option<String>, width: Option<i32>, height: Option<i32>) {
        let tag = tag.unwrap_or_default();
        let width = width.unwrap_or_default();
        let height = height.unwrap_or_default();

        layout()
            .policy(FixedTestLayout { width, height })
            .draw(NoopDrawModifier)
            .modifier(Modifier::new().semantics(SemanticsArgs {
                test_tag: Some(tag),
                ..Default::default()
            }));
    }

    #[tessera]
    fn fill_width_test_box(tag: Option<String>, height: Option<i32>) {
        let tag = tag.unwrap_or_default();
        let height = height.unwrap_or_default();

        layout()
            .policy(FillWidthTestLayout { height })
            .draw(NoopDrawModifier)
            .modifier(Modifier::new().semantics(SemanticsArgs {
                test_tag: Some(tag),
                ..Default::default()
            }));
    }

    #[tessera]
    fn row_layout_case() {
        row()
            .modifier(Modifier::new().constrain(
                Some(AxisConstraint::exact(Px::new(100))),
                Some(AxisConstraint::exact(Px::new(30))),
            ))
            .main_axis_alignment(MainAxisAlignment::Start)
            .cross_axis_alignment(CrossAxisAlignment::Start)
            .children(|| {
                row_fixed_box();
                layout().modifier(Modifier::new().weight(1.0)).child(|| {
                    row_weighted_content_box();
                });
            });
    }

    #[tessera]
    fn row_fixed_box() {
        fixed_test_box()
            .tag("row_fixed".to_string())
            .width(20)
            .height(10);
    }

    #[tessera]
    fn row_weighted_content_box() {
        fill_width_test_box()
            .tag("row_weighted_content".to_string())
            .height(10);
    }

    #[tessera]
    fn row_alignment_case() {
        row()
            .modifier(Modifier::new().constrain(
                Some(AxisConstraint::exact(Px::new(100))),
                Some(AxisConstraint::exact(Px::new(30))),
            ))
            .main_axis_alignment(MainAxisAlignment::Center)
            .cross_axis_alignment(CrossAxisAlignment::End)
            .children(|| {
                fixed_test_box()
                    .tag("row_center_first".to_string())
                    .width(20)
                    .height(10);
                fixed_test_box()
                    .tag("row_center_second".to_string())
                    .width(10)
                    .height(12);
            });
    }

    #[test]
    fn row_allocates_remaining_width_to_weighted_child() {
        tessera_ui::assert_layout! {
            viewport: (120, 60),
            content: {
                row_layout_case();
            },
            expect: {
                node("row_fixed").position(0, 0).size(20, 10);
                node("row_weighted_content").position(20, 0).size(80, 10);
            }
        }
    }

    #[test]
    fn row_honors_main_and_cross_axis_alignment() {
        tessera_ui::assert_layout! {
            viewport: (120, 60),
            content: {
                row_alignment_case();
            },
            expect: {
                node("row_center_first").position(35, 20).size(20, 10);
                node("row_center_second").position(55, 18).size(10, 12);
            }
        }
    }

    #[tessera]
    fn constrained_unweighted_case(weighted: bool) {
        row()
            .modifier(Modifier::new().constrain(Some(AxisConstraint::exact(Px(100))), None))
            .children(move || {
                fixed_test_box()
                    .tag("reserved".to_string())
                    .width(20)
                    .height(10);
                fill_width_test_box()
                    .tag("remaining".to_string())
                    .height(10);
                if weighted {
                    layout().modifier(Modifier::new().weight(1.0)).child(|| {
                        fill_width_test_box()
                            .tag("exhausted".to_string())
                            .height(10);
                    });
                } else {
                    fill_width_test_box()
                        .tag("exhausted".to_string())
                        .height(10);
                }
            });
    }

    #[test]
    fn unweighted_children_receive_only_the_remaining_row_width() {
        tessera_ui::assert_layout! {
            viewport: (120, 60),
            content: { constrained_unweighted_case(false); },
            expect: {
                node("reserved").position(0, 0).size(20, 10);
                node("remaining").position(20, 0).size(80, 10);
                node("exhausted").position(100, 0).size(0, 10);
            }
        }
    }

    #[test]
    fn unweighted_children_cannot_overallocate_before_weighted_children() {
        tessera_ui::assert_layout! {
            viewport: (120, 60),
            content: { constrained_unweighted_case(true); },
            expect: {
                node("reserved").position(0, 0).size(20, 10);
                node("remaining").position(20, 0).size(80, 10);
                node("exhausted").position(100, 0).size(0, 10);
            }
        }
    }
}