iris-aiandClaude Opus 5
d98969158f
A widget's region is now held in the coordinates of the slot it draws in rather than the window's, and `Painter::place` is how a container asks for a slot: it draws a child it decides the box of and may decide again. Everything under that slot is a fraction of its box, so placing the child a second time is one entry to write whether it moved or changed length. A child drawn any other way has no slot and shares its nearest ancestor's. That is what keeps the chain short. `chain_cost` measured depth as the cost -- free to 8, +42.6% at 16 -- and a slot per widget put a transcript's glyphs past that for nothing, since almost every slot was zero. `Span`, `Aligned` and `Scroll` are the containers that re-place a child after drawing it, and `tests/layout.rs` pins that four widgets between a span and a leaf leave the leaf's chain one deep. `UiRegion::stretch`, `UiRegion::stretchable` and `UiScalar::stretch` are gone. Nothing is inverted any more: a box that changed length is written to its slot, and the descendants recompose against it in the shader. That also retires the case the guard existed for, where a fixed length has no fraction to recover -- `tests/layout.rs` now stretches a 40-tall row on its other axis, which `stretchable` refused outright. What still walks the CPU is deciding who must draw again, which no chain can answer: `mark_resized` descends from the widget whose box changed and marks anything whose own box changed length and whose drawing reads it. A part of a box with no relative extent on an axis is a fixed length, and composing into it leaves none either, so the walk stops where a length did not change -- an 80-wide child in a widened row is not redrawn though it says `Redraw`. `Span`, `Pad`, `Stack`, `Offset`, `Aligned`, `SetSize` and `LayerOffset` say `Scale`: each places in fractions and offsets of its own box and none reads the box's pixel length. `Scroll` and `MaxSize` do read pixels and stay `Redraw`. 45 tests pass, five of them new. Render verification comes after the CPU side, per the owner. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
133 lines
2.9 KiB
Rust
133 lines
2.9 KiB
Rust
use crate::prelude::*;
|
|
|
|
pub struct Pad {
|
|
pub padding: Padding,
|
|
pub inner: StrongWidget,
|
|
}
|
|
|
|
impl Widget for Pad {
|
|
fn draw(&mut self, painter: &mut Painter) -> Size {
|
|
let inner = painter
|
|
.widget_within(&self.inner, self.padding.region())
|
|
.size();
|
|
Size {
|
|
x: Len {
|
|
abs: inner.x.abs + self.padding.left + self.padding.right,
|
|
..inner.x
|
|
},
|
|
y: Len {
|
|
abs: inner.y.abs + self.padding.top + self.padding.bottom,
|
|
..inner.y
|
|
},
|
|
}
|
|
}
|
|
|
|
/// The padding is an offset from each edge, so a longer box pads the same
|
|
/// amount and the child takes the rest.
|
|
fn on_resize(&self, _: Axis) -> OnResize {
|
|
OnResize::Scale
|
|
}
|
|
}
|
|
|
|
pub struct Padding {
|
|
pub left: f32,
|
|
pub right: f32,
|
|
pub top: f32,
|
|
pub bottom: f32,
|
|
}
|
|
|
|
impl Padding {
|
|
pub const ZERO: Self = Self {
|
|
left: 0.0,
|
|
right: 0.0,
|
|
top: 0.0,
|
|
bottom: 0.0,
|
|
};
|
|
|
|
pub fn uniform(amt: impl UiNum) -> Self {
|
|
let amt = amt.to_f32();
|
|
Self {
|
|
left: amt,
|
|
right: amt,
|
|
top: amt,
|
|
bottom: amt,
|
|
}
|
|
}
|
|
pub fn region(&self) -> UiRegion {
|
|
let mut region = UiRegion::FULL;
|
|
region.x.start.abs += self.left;
|
|
region.y.start.abs += self.top;
|
|
region.x.end.abs -= self.right;
|
|
region.y.end.abs -= self.bottom;
|
|
region
|
|
}
|
|
pub fn x(amt: impl UiNum) -> Self {
|
|
let amt = amt.to_f32();
|
|
Self {
|
|
left: amt,
|
|
right: amt,
|
|
top: 0.0,
|
|
bottom: 0.0,
|
|
}
|
|
}
|
|
pub fn y(amt: impl UiNum) -> Self {
|
|
let amt = amt.to_f32();
|
|
Self {
|
|
left: 0.0,
|
|
right: 0.0,
|
|
top: amt,
|
|
bottom: amt,
|
|
}
|
|
}
|
|
|
|
pub fn top(amt: impl UiNum) -> Self {
|
|
let mut s = Self::ZERO;
|
|
s.top = amt.to_f32();
|
|
s
|
|
}
|
|
|
|
pub fn bottom(amt: impl UiNum) -> Self {
|
|
let mut s = Self::ZERO;
|
|
s.bottom = amt.to_f32();
|
|
s
|
|
}
|
|
|
|
pub fn left(amt: impl UiNum) -> Self {
|
|
let mut s = Self::ZERO;
|
|
s.left = amt.to_f32();
|
|
s
|
|
}
|
|
|
|
pub fn right(amt: impl UiNum) -> Self {
|
|
let mut s = Self::ZERO;
|
|
s.right = amt.to_f32();
|
|
s
|
|
}
|
|
|
|
pub fn with_top(mut self, amt: impl UiNum) -> Self {
|
|
self.top = amt.to_f32();
|
|
self
|
|
}
|
|
|
|
pub fn with_bottom(mut self, amt: impl UiNum) -> Self {
|
|
self.bottom = amt.to_f32();
|
|
self
|
|
}
|
|
|
|
pub fn with_left(mut self, amt: impl UiNum) -> Self {
|
|
self.left = amt.to_f32();
|
|
self
|
|
}
|
|
|
|
pub fn with_right(mut self, amt: impl UiNum) -> Self {
|
|
self.right = amt.to_f32();
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<T: UiNum> From<T> for Padding {
|
|
fn from(amt: T) -> Self {
|
|
Self::uniform(amt.to_f32())
|
|
}
|
|
}
|