ai-app/iris/src/widget/trait_fns.rs

use super::*;
use crate::prelude::*;

// these methods should "not require any context" (require unit) because they're in core
widget_trait! {
    pub trait CoreWidget<Rsc: UiRsc + 'static>;

    fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Rsc, Pad> {
        |state| Pad {
            padding: padding.into(),
            inner: self.add_strong(state),
        }
    }

    fn align(self, align: impl Into<Align>) -> impl WidgetFn<Rsc, Aligned> {
        move |state| Aligned {
            inner: self.add_strong(state),
            align: align.into(),
        }
    }

    fn center(self) -> impl WidgetFn<Rsc, Aligned> {
        self.align(Align::CENTER)
    }

    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<Rsc, WL::Widget> {
        |state| {
            let id = self.add(state);
            state.ui_mut().widgets.set_label(id, label.into());
            id
        }
    }

    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, Sized> {
        let size = size.into();
        move |state| Sized {
            inner: self.add_strong(state),
            x: Some(size.x),
            y: Some(size.y),
        }
    }

    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
        let len = len.into();
        move |state| MaxSize {
            inner: self.add_strong(state),
            x: Some(len),
            y: None,
        }
    }

    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
        let len = len.into();
        move |state| MaxSize {
            inner: self.add_strong(state),
            x: None,
            y: Some(len),
        }
    }

    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
        let len = len.into();
        move |state| Sized {
            inner: self.add_strong(state),
            x: Some(len),
            y: None,
        }
    }

    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
        let len = len.into();
        move |state| Sized {
            inner: self.add_strong(state),
            x: None,
            y: Some(len),
        }
    }

    fn offset(self, amt: impl Into<UiVec2>) -> impl WidgetFn<Rsc, Offset> {
        move |state| Offset {
            inner: self.add_strong(state),
            amt: amt.into(),
        }
    }

    fn scrollable(self) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
        self.scrollable_on(Axis::Y)
    }

    /// `scrollable_on`, but starting pinned to the **end** of its content
    /// and staying there while the content grows -- what a composer wants,
    /// where the newest line is the one being written.
    ///
    /// Explicit, because the other kind is not a variation on it: a code
    /// fence opened at the end of its longest line, which is the middle
    /// of a word (seen in `iris/run-headless.sh phone`, 2026-09-08). The
    /// two behaviours are one mechanism with the starting edge passed in,
    /// and both names say which they are rather than one of them being a
    /// default nobody reads.
    fn scrollable_to_end(self, axis: Axis) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
        self.scroll_area(axis, true)
    }

    /// `scrollable` along `axis`. A code fence pans across its own long
    /// lines exactly the way a transcript pans down its rows, so the two
    /// are one function with the axis passed in rather than a second copy
    /// -- `DragArbiter::on` is the other half.
    fn scrollable_on(self, axis: Axis) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
        self.scroll_area(axis, false)
    }

    /// The one implementation behind [`Self::scrollable_on`] and
    /// [`Self::scrollable_to_end`] -- see the latter for what `at_end`
    /// decides.
    fn scroll_area(self, axis: Axis, at_end: bool) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
        move |state| {
            Scroll::new(self.add_strong(state), axis, at_end)
                .on(CursorSense::Scroll, move |ctx, rsc| {
                    let delta = ctx.data.scroll_delta.axis(axis) * 50.0;
                    ctx.widget(rsc).scroll(delta);
                })
                // A finger drag, through the same `DragGesture` the
                // transcript's `List` is panned by -- `Scroll::drag`'s doc
                // has the arbitration and why there is no fling. The wheel
                // above and this are the two inputs of one scroll, so they
                // are registered together rather than left to each caller.
                .on(CursorSense::drag_senses(), |ctx, rsc: &mut Rsc| {
                    let id = ctx.widget.id();
                    let (sense, pos) = (ctx.data.sense, ctx.data.cursor.pos);
                    let flung =
                        ctx.widget(rsc)
                            .drag(ctx.data.pointer, id, sense, pos, ctx.data.cursor.time);
                    // The half that actually makes it move -- a fling is
                    // set by the widget and driven by the frame loop, and
                    // only this side can reach the loop. Only when one
                    // actually started: registering a widget that is not
                    // animating asks the next frame to find that out.
                    if flung {
                        rsc.ui_mut().animate(id);
                    }
                })
                .add(state)
        }
    }

    fn masked(self) -> impl WidgetFn<Rsc, Masked> {
        move |state| Masked {
            shape: None,
            inner: self.add_strong(state),
        }
    }

    /// Clip to `shape` rather than to a plain box: `shape` is drawn
    /// behind this widget, filling the same region, and what clips is the
    /// primitive it drew -- so a rounded background and the corner its
    /// content is cut to are one rect, with no radius passed twice.
    /// Replaces `.masked().background(w)`, which drew the two but clipped
    /// to the box.
    fn masked_by<T>(self, shape: impl WidgetLike<Rsc, T>) -> impl WidgetFn<Rsc, Masked> {
        move |state| Masked {
            shape: Some(shape.add_strong(state)),
            inner: self.add_strong(state),
        }
    }

    fn background<T>(self, w: impl WidgetLike<Rsc, T>) -> impl WidgetFn<Rsc, Stack> {
        move |state| Stack {
            children: vec![w.add_strong(state), self.add_strong(state)],
            size: StackSize::Child(1),
        }
    }

    fn foreground<T>(self, w: impl WidgetLike<Rsc, T>) -> impl WidgetFn<Rsc, Stack> {
        move |state| Stack {
            children: vec![self.add_strong(state), w.add_strong(state)],
            size: StackSize::Child(0),
        }
    }

    fn layer_offset(self, offset: usize) -> impl WidgetFn<Rsc, LayerOffset> {
        move |state| LayerOffset {
            inner: self.add_strong(state),
            offset,
        }
    }

    fn to_any(self) -> impl WidgetIdFn<Rsc> {
        |state| self.add(state)
    }

    fn set_ptr(self, ptr: WeakWidget<WidgetPtr>, state: &mut Rsc) {
        let id = self.add_strong(state);
        state.ui_mut().widgets[ptr].inner = Some(id);
    }
}

pub trait CoreWidgetArr<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> {
    fn span(self, dir: Dir) -> SpanBuilder<Rsc, LEN, Wa, Tag>;
    fn stack(self) -> StackBuilder<Rsc, LEN, Wa, Tag>;
}

impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
    CoreWidgetArr<State, LEN, Wa, Tag> for Wa
{
    fn span(self, dir: Dir) -> SpanBuilder<State, LEN, Wa, Tag> {
        SpanBuilder::new(self, dir)
    }
    fn stack(self) -> StackBuilder<State, LEN, Wa, Tag> {
        StackBuilder::new(self)
    }
}