ai-app/iris/src/widget/position/span.rs

use crate::prelude::*;
use std::marker::PhantomData;

pub struct Span {
    pub children: Vec<StrongWidget>,
    pub dir: Dir,
    /// A `Len` (not a bare `f32`) so `dp(4)` resolves against the display's
    /// density the same way any other size in the tree does -- see
    /// `Len::dp`'s field doc. Only the `abs` component (folded from `dp` at
    /// draw time, `Widget::draw` below) is meaningful here; `rel`/`rest`
    /// were never supported for a gap and still are not.
    pub gap: Len,
}

impl Widget for Span {
    fn draw(&mut self, painter: &mut Painter) -> Size {
        let axis = self.dir.axis;
        let gap = self.gap.apply_rest(painter.density()).abs;

        // Phase 1: draw each child once, at the ambient (unmodified, full)
        // region a size-only query used to see before this migration, to
        // learn its length along the layout axis. This paints real
        // primitives at a provisional slot; phase 2 below places each
        // child for real via the normal `widget_within` dispatch, which
        // only actually redraws it when that slot's *size* differs from
        // this provisional one (most children: a resize, since the
        // provisional slot is the whole span, not this child's share).
        let lens: Vec<Len> = self
            .children
            .iter()
            .map(|child| painter.widget(child).axis(axis))
            .collect();

        let gap_total = gap * self.children.len().saturating_sub(1) as f32;
        let total = lens.iter().fold(Len::abs(gap_total), |s, &l| s + l);

        // Phase 2: place each child for real, using the lengths just
        // learned -- the same arithmetic this loop always used. The cross-
        // axis length of *this* draw (used for `Span`'s own reported size
        // below) falls out of each child's real, resolved-width `used`
        // here for free -- this is what replaces `desired_ortho`'s former
        // duplicate simulation of this same loop (see LAYOUT.md section 4).
        let mut start = UiScalar::rel_min();
        let mut ortho_len = Len::ZERO;
        let mut ortho_mixed = false;
        for (child, &len) in self.children.iter().zip(&lens) {
            let mut span = UiSpan::FULL;
            span.start = start;
            if len.rest > 0.0 {
                let offset = UiScalar::new(total.rel, total.abs);
                let rel_end = UiScalar::rel(len.rest / total.rest);
                let end = (UiScalar::rel_max() + start) - offset;
                start = rel_end.within(&start.to(end));
            }
            start.abs += len.abs;
            start.rel += len.rel;
            span.end = start;
            let mut child_region = UiRegion::from_axis(axis, span, UiSpan::FULL);
            if self.dir.sign == Sign::Neg {
                child_region.flip(axis);
            }
            let used = painter.widget_within(child, child_region);
            start.abs += gap;

            let ortho = used.axis(!axis);
            if ortho.rel > 0.0 || ortho.rest > 0.0 {
                ortho_mixed = true;
            } else {
                ortho_len.abs = ortho_len.abs.max(ortho.abs);
            }
        }
        if ortho_mixed {
            ortho_len = Len::default();
        }

        let along = if total.rest == 0.0 && total.rel == 0.0 {
            total
        } else {
            Len::default()
        };

        Size::from_axis(axis, along, ortho_len)
    }
}

impl Span {
    pub fn empty(dir: Dir) -> Self {
        Self {
            children: Vec::new(),
            dir,
            gap: Len::ZERO,
        }
    }

    pub fn gap(mut self, gap: impl Into<Len>) -> Self {
        self.gap = gap.into();
        self
    }

    pub fn push(&mut self, w: StrongWidget) {
        self.children.push(w);
    }

    pub fn pop(&mut self) -> Option<StrongWidget> {
        self.children.pop()
    }
}

pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
    pub children: Wa,
    pub dir: Dir,
    pub gap: Len,
    _pd: PhantomData<(State, Tag)>,
}

impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
    for SpanBuilder<Rsc, LEN, Wa, Tag>
{
    type Widget = Span;

    #[track_caller]
    fn run(self, rsc: &mut Rsc) -> Self::Widget {
        Span {
            children: self.children.add(rsc).arr.into_iter().collect(),
            dir: self.dir,
            gap: self.gap,
        }
    }
}

impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
    SpanBuilder<State, LEN, Wa, Tag>
{
    pub fn new(children: Wa, dir: Dir) -> Self {
        Self {
            children,
            dir,
            gap: Len::ZERO,
            _pd: PhantomData,
        }
    }

    pub fn gap(mut self, gap: impl Into<Len>) -> Self {
        self.gap = gap.into();
        self
    }
}

impl std::ops::Deref for Span {
    type Target = Vec<StrongWidget>;

    fn deref(&self) -> &Self::Target {
        &self.children
    }
}

impl std::ops::DerefMut for Span {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.children
    }
}