iris-aiandClaude Opus 5
a8898aaa54
`UiScalar` was `Len` without the `leftover` weight, which is the separation canonical `main` already had as `Len` beside `LayoutLen` and this branch collapsed. It is needed back for the queued clamp: a cap may not contain a share, because a cap has to read the report a rule otherwise makes moot, and a share puts the container's division into the same equation -- two self-consistent assignments, which is the multiple-fixed-point failure generated seed 13 punished for orthogonal sizing. `min(report, cap)` is not a `LayoutLen` either: it is a sum of parts, and the smaller of two of them is not one. So `UiScalar` is `Len`, what was `Len` is `LayoutLen`, and the two say in their docs which is which: a `Len` is pixels plus a fraction of a box -- a position being the length from the box's start, which is why a span is two of them -- and a `LayoutLen` is a `Len` plus a claim only a container dividing its room can answer. `From<Len> for LayoutLen` is the one-way step between them. Names only; the shader's `UiScalar` is renamed with them. Checked: fmt, clippy, 105 tests, and `tabs`, `minimal`, `view`, `text` and `random` byte-identical at 1920x1200. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
65 lines
2.8 KiB
Rust
65 lines
2.8 KiB
Rust
use crate::{
|
|
Holds, LayerId, LayoutLen, MaskIdx, MoveIdx, PrimitiveHandle, RegionAlign, Size, TextureHandle,
|
|
UiRegion, WidgetId,
|
|
};
|
|
|
|
/// What is kept of a widget its parent has asked about. `drawn` says whether
|
|
/// it currently draws; one that does not is kept so that a change to it, or
|
|
/// under it, still reaches whoever asked.
|
|
#[derive(Debug)]
|
|
pub struct ActiveData {
|
|
pub id: WidgetId,
|
|
/// The box its drawing is in, in `parent_move`'s coordinates.
|
|
pub region: UiRegion,
|
|
/// The box its parent first asked about it in, as a part of the box the
|
|
/// parent was itself asked in. Any later box it was given was decided
|
|
/// knowing its answer, so this is where a question about it is asked
|
|
/// again -- and it is kept relative so that it follows the parent's.
|
|
pub offer: UiRegion,
|
|
/// What it answered there: the size and what that held for.
|
|
pub answer: (Size, [Holds; 2]),
|
|
/// What the widget said it used of its box, the last time it drew.
|
|
pub size: Size,
|
|
/// The pixel lengths of `region`, per axis, that its drawing and `size`
|
|
/// hold for.
|
|
pub holds: [Holds; 2],
|
|
pub drawn: bool,
|
|
pub parent: Option<WidgetId>,
|
|
/// How far down the tree it was drawn, the root being 1. Carried down a
|
|
/// draw rather than worked out by walking up, so it is right for every
|
|
/// widget a frame visits and cannot drift while one is being drawn.
|
|
pub depth: usize,
|
|
pub textures: Vec<TextureHandle>,
|
|
pub primitives: Vec<PrimitiveHandle>,
|
|
pub children: Vec<WidgetId>,
|
|
/// The children whose size this widget read while drawing.
|
|
pub size_deps: Vec<WidgetId>,
|
|
/// The movable region its primitives are positioned through: its own when
|
|
/// opted in, otherwise the nearest ancestor's.
|
|
pub move_idx: MoveIdx,
|
|
/// The declared lengths whoever drew this widget resolved into its box.
|
|
/// A change to one moves a box this widget cannot fix by drawing again,
|
|
/// and comparing them is what says so.
|
|
pub declared: [Option<LayoutLen>; 2],
|
|
/// The alignment its parent asked it with. A local redraw repeats that
|
|
/// question, including an override chosen by a container.
|
|
pub align: RegionAlign,
|
|
/// Whether that alignment was the parent's override rather than the
|
|
/// widget's own property.
|
|
pub align_override: bool,
|
|
/// Its own alignment when it was last drawn. A change to the property is
|
|
/// found against this even when its parent overrode the alignment.
|
|
pub own_align: RegionAlign,
|
|
/// The movable region whose coordinates `region` uses.
|
|
pub parent_move: MoveIdx,
|
|
pub mask: MaskIdx,
|
|
pub layer: LayerId,
|
|
}
|
|
|
|
impl ActiveData {
|
|
/// Whether its drawing and size hold for a box of these pixel lengths.
|
|
pub fn holds_at(&self, px: crate::PxVec2) -> bool {
|
|
self.holds[0].contains(px.x) && self.holds[1].contains(px.y)
|
|
}
|
|
}
|