contract: one read and one props clone per body run, props compared by value, shared inherited env

- pass_extent builds the measuring run's hooks from the run's own read instead of reading again on a peek stage;
  the measuring run of a real pass now sees the kept scroll extent and anchor, as a sizing pass's does.
- BodyHooks holds the container's props in one Arc for the run; the measure key keeps that Arc and compares the
  fields a body's measure reads (ContainerProps::measures_like), replacing the Debug-text fingerprint. Glyph is Sync
  so the props can live in layout memory.
- Scoped keeps the per-scope fields and shares the rarely changed ones (tokens, platform, words, formats, app
  values, commands) in an Arc<Inherited> read through Deref; writers go through inherited_mut/extend_values.
  ItemFacts sits behind an Arc.
- The line env derives only when it changes something; run_body, run_body_measured and run_sharing take the body's
  env instead of looking it up again.
This commit is contained in:
aiongg
2026-11-12 14:32:39 +00:00
parent 635c732488
commit df2b2aa490
19 changed files with 239 additions and 180 deletions
+6 -1
View File
@@ -1,6 +1,7 @@
//! The body step (16.3): the regions of a container (header, body with its scroll region, footer), open and
//! gate state, scroll offset, move and resize, and the zoomed canvas body.
use super::ContainerProps;
use super::cx::BodyCx;
use super::overlay::PlacementChange;
use crate::runtime::memory::SaveKey;
@@ -9,6 +10,7 @@ use crate::runtime::overlay::CloseReason;
use crate::runtime::windows::ResizeEdge;
use craft_behavior::ScrollPos;
use egui::{Rect, Ui, Vec2};
use std::sync::Arc;
mod hooks;
mod inherit;
@@ -39,6 +41,8 @@ struct BodyView {
pub(super) struct BodyHooks<'b> {
pub(super) body: &'b mut dyn FnMut(&mut Ui, &mut BodyCx<'_>),
/// The container's props, cloned once for the run: every hook and the measuring run read this copy.
props: Arc<ContainerProps>,
/// The body's size from this pass's measuring run; `None` inside the measuring run itself.
measured_body: Option<Vec2>,
/// The header's size from this pass's measuring run; `None` without a header or inside the measuring run.
@@ -119,9 +123,10 @@ pub(super) struct BodyHooks<'b> {
}
impl<'b> BodyHooks<'b> {
pub(super) fn new(body: &'b mut dyn FnMut(&mut Ui, &mut BodyCx<'_>)) -> Self {
pub(super) fn new(body: &'b mut dyn FnMut(&mut Ui, &mut BodyCx<'_>), props: Arc<ContainerProps>) -> Self {
BodyHooks {
body,
props,
measured_body: None,
measured_header: None,
measured_footer: Vec2::ZERO,
+45 -30
View File
@@ -127,8 +127,8 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
fn read(&mut self, comp: &mut C, stage: &mut MemoryStage, id: Id, env: &Env) {
let ctx = stage.ctx().clone();
let props = comp.props(Internal::new()).clone();
let props = &props;
let props = Arc::clone(&self.props);
let props = &*props;
let scroll = scroll_of(props);
let collapse = props.collapse;
let save = props.save.clone();
@@ -274,7 +274,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
/// the room. What the regions took is recorded for the rest of the pass; a record this pass already holds serves
/// instead when the room still allows it (`reusable`).
fn measured_extent(&mut self, comp: &mut C, at: &Measuring<'_, '_>, cx: &mut Cx<'_, C>) -> Vec2 {
let props = comp.props(Internal::new()).clone();
let props = Arc::clone(&self.props);
// A mount outside the flow takes no room in a parent's sizing pass, so its regions run only when it is
// measured itself. A pane as tall as its content takes its height in the flow.
let flows = match &props.mount {
@@ -336,7 +336,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
let tolerance = measure_tolerance(crate::runtime::egui::scale::pixels_per_point(&ctx));
// A record a run of this pass left serves as before; a kept one serves only while the inputs it was measured
// under hold.
let key = self.measure_key(&props, at.env, at.width);
let key = self.measure_key(at.env, at.width);
let reused = (self.reuse || at.ui.is_sizing_pass())
.then(|| {
let found = layout_memory::run_found(&ctx, id);
@@ -412,22 +412,32 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
/// an enclosing container left when the room still allows it, else a measuring run of its own now. A closed
/// layer that no longer shows runs none.
fn pass_extent(&mut self, comp: &mut C, at: &Measuring<'_, '_>, style: &C::Style, shown: Option<Arc<ValueOf<C>>>) -> Vec2 {
let props = comp.props(Internal::new()).clone();
let props = Arc::clone(&self.props);
let (ctx, id) = (at.ui.ctx().clone(), at.resolved.id);
let layer = matches!(props.mount, Mount::Layer(_) | Mount::FullWindow | Mount::Viewport { .. });
let fading = layer && !self.open && crate::runtime::motion::layer_fading(&ctx, sub(id, "presence"));
if !layer || self.open || fading {
// The measuring run starts from what this run's `read` found: the measuring run of a sizing parent reads
// the same state.
let mut stage = MemoryStage::open_peek(&ctx, id);
let mut fresh = BodyHooks::new(&mut *self.body);
fresh.read(comp, &mut stage, id, at.env);
// A peek stage holds no session scroll state: the measuring run decides by the offset this pass shows.
fresh.view_offset = self.view_offset;
fresh.open = self.open;
fresh.open_at_read = self.open;
fresh.presence = self.presence;
fresh.open_given = true;
fresh.shown_closed = fading;
fresh.reuse = true;
let mut fresh = BodyHooks {
save: self.save.clone(),
layer: self.layer,
fixed: self.fixed,
open_bound: self.open_bound,
scroll_bound: self.scroll_bound,
last_extent: self.last_extent,
anchor: self.anchor,
follows_end: self.follows_end,
view_offset: self.view_offset,
open: self.open,
open_at_read: self.open,
presence: self.presence,
open_given: true,
shown_closed: fading,
reuse: true,
..BodyHooks::new(&mut *self.body, Arc::clone(&self.props))
};
crate::contract::run::measured_extent(comp, &mut fresh, at, &mut stage, style, shown);
}
let took = |key: Id| layout_memory::measured(&ctx, key).map(|measured| measured.took);
@@ -496,8 +506,8 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
matches!(comp.props(Internal::new()).layout, layout::BodyLayout::Row { wrap: false, .. })
}
fn parts(&mut self, comp: &mut C, rect: Rect, pcx: &mut PartsCx<'_, C>) {
let props = comp.props(Internal::new()).clone();
fn parts(&mut self, _comp: &mut C, rect: Rect, pcx: &mut PartsCx<'_, C>) {
let props = Arc::clone(&self.props);
let ctx = pcx.ui.ctx().clone();
let rtl = pcx.flow.is_rtl();
let tokens = pcx.tokens;
@@ -597,7 +607,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
}
fn content(&mut self, comp: &mut C, ui: &mut Ui, env: &Env, cx: &mut Cx<'_, C>, values: &AppValues) {
let props = comp.props(Internal::new()).clone();
let props = Arc::clone(&self.props);
let (id, ctx, rect) = (cx.core.id, cx.core.ctx.clone(), cx.core.rect);
let rtl = env.direction.is_rtl();
let node = matches!(C::ROLE, Role::Node(_));
@@ -653,15 +663,19 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
let enabled = gate.unwrap_or(true);
// What the body and the end region share: gate, size, roving group and commands. The body adds its arena,
// transform and scroll owner; the end region lies outside them.
let line_env = region_env.derive_local(|scoped| {
scoped.enabled &= enabled;
if let Some(size) = props.child_size {
scoped.size = size;
}
if props.roving.is_some() {
scoped.roving = Some(crate::contract::steps::body_group(id));
}
});
let line_env = if enabled && props.child_size.is_none() && props.roving.is_none() {
region_env.clone()
} else {
region_env.derive_local(|scoped| {
scoped.enabled &= enabled;
if let Some(size) = props.child_size {
scoped.size = size;
}
if props.roving.is_some() {
scoped.roving = Some(crate::contract::steps::body_group(id));
}
})
};
let end_frame = RegionFrame { id, rtl, node, env: &line_env };
// A footer in the end region is part of a column sized from its content: a fill-width child takes its
// measured width there and shows across the column, so it never sets the column's width.
@@ -787,8 +801,9 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
if lays_out {
crate::runtime::lazy::begin(&ctx, id);
}
let region_env = Env::install_for(&region_ui, body_env.derive_local(|scoped| scoped.lazy = Some(view)));
layout::run_body(&mut region_ui, layout_id, layout, gap, |ui| {
let view_env = body_env.derive_local(|scoped| scoped.lazy = Some(view));
let region_env = Env::install_for(&region_ui, view_env.clone());
layout::run_body(&mut region_ui, &view_env, layout_id, layout, gap, |ui| {
shared_labels(ui, id, label_column, room.x, &mut group_extent, |ui| body(ui, bcx))
});
Env::restore(&ctx, region_env);
@@ -816,7 +831,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
}
// A row that places its block itself asks for its children's width, not the room it spans.
None => {
let (_, natural) = layout::run_body_measured(&mut body_ui, layout_id, layout, gap, line, |ui| {
let (_, natural) = layout::run_body_measured(&mut body_ui, &body_env, layout_id, layout, gap, line, |ui| {
shared_labels(ui, id, label_column, room.x, &mut group_extent, |ui| body(ui, bcx))
});
natural.map(|width| Vec2::new(width, body_ui.min_rect().height()))
@@ -51,9 +51,9 @@ impl BodyHooks<'_> {
// The container's own `enabled(false)` greys everything inside it, as a scope would.
scoped.enabled &= cx.core.resolved.enabled;
if let Some(window) = window {
scoped.commands = scoped.commands.pushed(WindowCommand::SCOPE, window);
scoped.inherited_mut().commands = scoped.commands.pushed(WindowCommand::SCOPE, window);
}
scoped.values.extend(values);
scoped.extend_values(values);
if cx.core.resolved.ltr_axis {
scoped.direction = Direction::Ltr;
}
@@ -66,13 +66,13 @@ impl BodyHooks<'_> {
scoped.content_column = true;
}
if props.header.is_some_and(|header| header.band == DragBand::Reorder) {
scoped.commands = scoped.commands.pushed(REORDER_SCOPE, id);
scoped.inherited_mut().commands = scoped.commands.pushed(REORDER_SCOPE, id);
}
// A host env (a layer's) does not carry the push the container's own context made.
if let Some(scope) = props.command_scope
&& scoped.commands.innermost(scope.name()) != Some(id)
{
scoped.commands = scoped.commands.pushed(scope, id);
scoped.inherited_mut().commands = scoped.commands.pushed(scope, id);
}
if let Some(theme) = &props.theme {
theme.apply(ctx, scoped);
+13 -3
View File
@@ -10,12 +10,13 @@ use crate::runtime::env::Env;
use crate::runtime::layout_memory;
use crate::runtime::memory::sub;
use egui::{Context, Id, Rect, Ui, Vec2};
use std::sync::Arc;
/// The inputs a body's measuring run measures under. A later pass offering the same takes the body's kept
/// transcript (`layout_memory::kept_serves`); its real run checks that the content is the same.
#[derive(PartialEq)]
pub(super) struct MeasureKey {
props: u64,
props: MeasuredProps,
room: Vec2,
given: (bool, bool),
width: Option<f32>,
@@ -26,6 +27,15 @@ pub(super) struct MeasureKey {
env: EnvFacts,
}
/// The props a body was measured under, compared on the fields its measure reads.
struct MeasuredProps(Arc<ContainerProps>);
impl PartialEq for MeasuredProps {
fn eq(&self, other: &Self) -> bool {
self.0.measures_like(&other.0)
}
}
/// What a body's measure reads of its env besides the room.
#[derive(PartialEq)]
struct EnvFacts {
@@ -45,9 +55,9 @@ struct EnvFacts {
impl<'b> BodyHooks<'b> {
/// The inputs this body's measuring run measures under, once `measured_extent` has its room.
pub(super) fn measure_key(&self, props: &ContainerProps, env: &Env, width: Option<f32>) -> MeasureKey {
pub(super) fn measure_key(&self, env: &Env, width: Option<f32>) -> MeasureKey {
MeasureKey {
props: props.measure_fingerprint(),
props: MeasuredProps(Arc::clone(&self.props)),
room: self.room,
given: self.given,
width,
+25 -43
View File
@@ -17,7 +17,7 @@ use egui::Rect;
pub use crate::runtime::env::ThemeScope;
/// Where a container lives.
#[derive(Clone, Debug, Default)]
#[derive(Clone, Debug, Default, PartialEq)]
#[non_exhaustive]
pub enum Mount {
/// In the parent's layout.
@@ -607,49 +607,31 @@ impl Default for ContainerProps {
}
impl ContainerProps {
/// A fingerprint of the props a body's measure reads: equal props give equal fingerprints. What it leaves out
/// (focus, arena, gates, commands, live region, roving, save key, set position) does not change a size. Glyphs
/// show as `Glyph(..)`: an icon is a component of the content, which the content check asks.
pub(crate) fn measure_fingerprint(&self) -> u64 {
use std::fmt::Write as _;
/// FNV-1a over the `Debug` text, without building it: `Debug` writes every `f32` so that it reads back
/// exactly.
struct Fnv(u64);
impl std::fmt::Write for Fnv {
fn write_str(&mut self, text: &str) -> std::fmt::Result {
for byte in text.bytes() {
self.0 = (self.0 ^ u64::from(byte)).wrapping_mul(0x0100_0000_01b3);
}
Ok(())
}
}
let mut hash = Fnv(0xcbf2_9ce4_8422_2325);
let _ = write!(
hash,
"{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}|{:?}",
self.mount,
self.surface,
self.pad,
self.sizing,
self.room_height,
self.layout,
self.header,
self.scroll,
self.footer,
self.end,
self.help,
self.collapse,
self.body_gap,
self.least_width,
self.child_size,
self.transform,
self.theme,
self.label,
self.outer_edit,
self.collection_body,
);
hash.0
/// Whether a body measured under `other` measures the same under these props. What it leaves out (focus, arena,
/// gates, commands, live region, roving, save key, set position) does not change a size.
pub(crate) fn measures_like(&self, other: &ContainerProps) -> bool {
self.mount == other.mount
&& self.surface == other.surface
&& self.pad == other.pad
&& self.sizing == other.sizing
&& self.room_height == other.room_height
&& self.layout == other.layout
&& self.header == other.header
&& self.scroll == other.scroll
&& self.footer == other.footer
&& self.end == other.end
&& self.help == other.help
&& self.collapse == other.collapse
&& self.body_gap == other.body_gap
&& self.least_width == other.least_width
&& self.child_size == other.child_size
&& self.transform == other.transform
&& self.theme == other.theme
&& self.label == other.label
&& self.outer_edit == other.outer_edit
&& self.collection_body == other.collection_body
}
/// Props with every field at its default.
pub const fn new() -> Self {
ContainerProps {
@@ -392,7 +392,7 @@ impl<C: Collection> ShapeHooks<C> for ItemsHooks<'_, '_, C> {
}
let child_size = comp.props(Internal::new()).child_size;
let base_env = env.derive(|scoped| {
scoped.values.extend(values);
scoped.extend_values(values);
scoped.arena = Some(ArenaId::new(id));
scoped.size = child_size.unwrap_or(cx.core.resolved.size);
});
@@ -514,7 +514,7 @@ impl<C: Collection> ShapeHooks<C> for ItemsHooks<'_, '_, C> {
base_env.derive_local(|scoped| {
scoped.item = Some(item_id);
scoped.row = Some(row_group);
scoped.item_facts = Some(ItemFacts { item: item_id, flags, position, columns: column_keys, toggles: toggle_keys });
scoped.item_facts = Some(Arc::new(ItemFacts { item: item_id, flags, position, columns: column_keys, toggles: toggle_keys }));
}),
);
item = Props::id(item, item_id);
@@ -663,7 +663,7 @@ impl<C: Collection> ShapeHooks<C> for ItemsHooks<'_, '_, C> {
let mut open = true;
let builder = UiBuilder::new().max_rect(rect).layout(child::column_layout(rtl)).scope_id(sub(id, "empty"));
let mut empty_ui = alloc::child(ui, builder);
let installed = Env::install_for(&empty_ui, env.derive(|scoped| scoped.values.extend(values)));
let installed = Env::install_for(&empty_ui, env.derive(|scoped| scoped.extend_values(values)));
let (resolved, view) = (cx.core.resolved, cx.core.env);
let mut bcx = BodyCx::new(sub(id, "body"), view, resolved, rect, &mut *cx.core.memory, &mut open, None);
comp.empty(&mut empty_ui, &mut bcx);
@@ -112,7 +112,7 @@ impl<'s, 'r, C: Collection> ItemsHooks<'s, 'r, C> {
env.derive_local(|scoped| {
scoped.item = Some(item_id);
scoped.row = Some(rows::row_group(item_id));
scoped.item_facts = Some(facts);
scoped.item_facts = Some(std::sync::Arc::new(facts));
}),
);
widest = widest.max(item.measure_in(ui, Proposal::Ideal).x);
@@ -31,7 +31,7 @@ pub enum Trigger {
/// A component that opens a free-standing popup, and how. A layer with several openers keeps the first as its
/// `Overlay.opener`, which keys the layer's open state, and the others in `others`.
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Opener {
/// The opener's id.
@@ -4,7 +4,7 @@ use craft_behavior::overlay::{Align, Side};
use egui::{Align2, Pos2, Rect, Vec2};
/// Where an overlay hangs from.
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum Anchor {
/// A rect in the opener's layer space.
@@ -40,7 +40,7 @@ impl FloatPlace {
}
/// Where an egui layer sits.
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum Place {
/// Hung from an anchor.
@@ -87,7 +87,7 @@ impl Default for Dismiss {
}
/// Data describing an egui layer. Presets fill focus and dismissal; builders change single fields.
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Overlay {
/// Where it sits.
+6 -3
View File
@@ -927,7 +927,8 @@ fn run<C: Component>(mut comp: C, ui: &mut Ui, at: ShowAt, tip: Option<TipFn<'_>
// A sizing pass reads the cancel and ends nothing: its stage is a copy, and the real run reads the cancel again.
let cancelled: Vec<_> = value.cancelled.into_iter().filter(|_| !sizing).collect();
hooks.read(&mut comp, &mut stage, id, &env);
let own_env = hooks.instance_scope(&comp).map(|scope| env.derive_local(|scoped| scoped.commands = scoped.commands.pushed(scope, id)));
let own_env =
hooks.instance_scope(&comp).map(|scope| env.derive_local(|scoped| scoped.inherited_mut().commands = scoped.commands.pushed(scope, id)));
let env = own_env.as_ref().unwrap_or(&env);
trace.mark(Step::Value);
// 5 measure
@@ -1139,7 +1140,8 @@ pub(crate) fn show_container<C: Container, R>(
inner = Some(body(ui, cx));
};
let ctx = ui.ctx().clone();
let output = run(comp, ui, at, tip, &mut super::body::BodyHooks::new(&mut call));
let props = Arc::new(comp.props(Internal::new()).clone());
let output = run(comp, ui, at, tip, &mut super::body::BodyHooks::new(&mut call, props));
let id = crate::contract::Outcome::response(&output).id;
let settle = ran.then(|| super::settle::SettleAt { ctx, body: sub(id, "body"), owner: id });
Inner { output, inner, settle }
@@ -1169,7 +1171,8 @@ pub(crate) fn measure_container<C: Container, R>(
let mut call = |ui: &mut Ui, cx: &mut BodyCx<'_>| {
body(ui, cx);
};
measure_shape(comp, ui, None, proposal, None, &mut super::body::BodyHooks::new(&mut call))
let props = Arc::new(comp.props(Internal::new()).clone());
measure_shape(comp, ui, None, proposal, None, &mut super::body::BodyHooks::new(&mut call, props))
}
/// A measuring run's extent: the shape's `measured_extent` under a `Cx` that senses nothing and writes only to the
+12 -12
View File
@@ -227,9 +227,8 @@ fn run_shrinking<R>(ui: &mut Ui, id: Id, mut body: impl FnMut(&mut Ui) -> R) ->
/// what the others and the gaps took with the number that fill. With a child that fills, it sweeps them again: the
/// others reuse what the first sweep recorded, and each child that fills is measured once, at its equal share of the
/// rest. The real run gives each the same share from that record.
fn run_sharing<R>(ui: &mut Ui, id: Id, axis: Axis, layout: egui::Layout, mut body: impl FnMut(&mut Ui) -> R) -> R {
fn run_sharing<R>(ui: &mut Ui, env: &Env, id: Id, axis: Axis, layout: egui::Layout, mut body: impl FnMut(&mut Ui) -> R) -> R {
let ctx = ui.ctx().clone();
let env = Env::of(ui);
let given = if axis == Axis::Y { !env.content.1 } else { !env.content.0 };
if !given {
return child::block(ui, None, layout, body).0;
@@ -239,7 +238,7 @@ fn run_sharing<R>(ui: &mut Ui, id: Id, axis: Axis, layout: egui::Layout, mut bod
let sweep = |ui: &mut Ui, share: Option<f32>, body: &mut dyn FnMut(&mut Ui) -> R| {
let installed = Env::install_for(
ui,
Env::of(ui).derive_local(|scoped| {
env.derive_local(|scoped| {
scoped.fill_body = Some((id, axis));
scoped.fill_share = share;
}),
@@ -526,8 +525,8 @@ fn found(ctx: &egui::Context, sizing: bool, id: Id, room: Vec2, took: Vec2) {
/// run found, `SpaceBetween` shares the room its children left there between them, and `Grid` places its cells from
/// the widest child per column and tallest per row there. Without a measuring run they place as `Start`, spread at
/// the gap and size columns from the cells as they come.
pub(crate) fn run_body<R>(ui: &mut Ui, id: Id, layout: &BodyLayout, gap: Vec2, body: impl FnMut(&mut Ui) -> R) -> R {
run_body_measured(ui, id, layout, gap, None, body).0
pub(crate) fn run_body<R>(ui: &mut Ui, env: &Env, id: Id, layout: &BodyLayout, gap: Vec2, body: impl FnMut(&mut Ui) -> R) -> R {
run_body_measured(ui, env, id, layout, gap, None, body).0
}
/// `run_body`, with the width the children take at the gap alone for a `Row` that places its block itself (`End`,
@@ -535,17 +534,18 @@ pub(crate) fn run_body<R>(ui: &mut Ui, id: Id, layout: &BodyLayout, gap: Vec2, b
/// line the body shares with its container's inline header or end region: an unwrapped `Row` sets its children on it.
pub(crate) fn run_body_measured<R>(
ui: &mut Ui,
env: &Env,
id: Id,
layout: &BodyLayout,
gap: Vec2,
shared: Option<f32>,
mut body: impl FnMut(&mut Ui) -> R,
) -> (R, Option<f32>) {
let rtl = Env::of(ui).direction.is_rtl();
let rtl = env.direction.is_rtl();
let ctx = ui.ctx().clone();
let sizing = measure::active(&ctx);
match layout {
BodyLayout::Stack => (run_sharing(ui, id, Axis::Y, child::column_layout(rtl), body), None),
BodyLayout::Stack => (run_sharing(ui, env, id, Axis::Y, child::column_layout(rtl), body), None),
BodyLayout::Row { wrap: false, align: RowAlign::SpaceBetween } => {
let (inner, _) = child::block(ui, None, child::row_layout(rtl, false), |ui| {
let flow = Flow::new(ui.available_rect_before_wrap(), rtl);
@@ -554,7 +554,7 @@ pub(crate) fn run_body_measured<R>(
let line = on_line(row_line(&ctx, sizing, id), shared);
let installed = Env::install_for(
ui,
Env::of(ui).derive_local(|scoped| {
env.derive_local(|scoped| {
scoped.grid = Some(id);
scoped.row_line = line;
}),
@@ -576,7 +576,7 @@ pub(crate) fn run_body_measured<R>(
BodyLayout::Row { wrap: false, align: RowAlign::Start } => {
let room = ui.available_rect_before_wrap();
let line = on_line(row_line(&ctx, sizing, id), shared);
let inner = run_sharing(ui, id, Axis::X, child::row_layout(rtl, false), |ui| {
let inner = run_sharing(ui, env, id, Axis::X, child::row_layout(rtl, false), |ui| {
let installed = Env::install_for(
ui,
Env::of(ui).derive_local(|scoped| {
@@ -610,7 +610,7 @@ pub(crate) fn run_body_measured<R>(
let (inner, took) = child::block(ui, rect, child::row_layout(rtl, *wrap), |ui| {
let installed = Env::install_for(
ui,
Env::of(ui).derive_local(|scoped| {
env.derive_local(|scoped| {
scoped.row_room = Some(room.width());
scoped.row_line = line;
}),
@@ -631,7 +631,7 @@ pub(crate) fn run_body_measured<R>(
let inner = child::block(ui, None, child::column_layout(rtl), |ui| {
let top = ui.available_rect_before_wrap().top();
let last = measured_tracks(&ctx, sizing, id, columns.len());
let content_run = measure::active(&ctx) && Env::of(ui).content.0;
let content_run = measure::active(&ctx) && env.content.0;
// A measuring run under a body sized from its content gives each fill column the width its cells
// take, as a content column: the room it would share is not the body's to claim.
let cursor = if content_run {
@@ -640,7 +640,7 @@ pub(crate) fn run_body_measured<R>(
GridCursor::new(Flow::new(ui.available_rect_before_wrap(), rtl), columns, gap, &last)
};
Service::<Cursors>::run(&ctx, |cursors| cursors.0.insert(id, Cursor::Grid(cursor)));
let installed = Env::install_for(ui, Env::of(ui).derive_local(|scoped| scoped.grid = Some(id)));
let installed = Env::install_for(ui, env.derive_local(|scoped| scoped.grid = Some(id)));
let inner = body(ui);
Env::restore(&ctx, installed);
// Cells place from last pass's rows, so a measuring run's rows all start at the top: the grid reaches
+3 -2
View File
@@ -22,8 +22,9 @@ pub enum Mirror {
Never,
}
/// A value glyph: an icon drawn from a value.
pub trait Glyph {
/// A value glyph: an icon drawn from a value. It is `Sync` because container props that show one are kept with a
/// body's measurement in layout memory.
pub trait Glyph: Sync {
/// Whether the glyph has a reading direction (an arrow) and so flips under right-to-left.
fn directional(&self) -> bool {
false
+92 -59
View File
@@ -66,42 +66,13 @@ impl Deref for Env {
#[derive(Clone)]
#[non_exhaustive]
pub struct Scoped {
/// The resolved tokens of the scope; read in `style` only.
#[doc(hidden)]
pub tokens: Arc<UiTokens>,
/// What the tokens were resolved from (the light or dark mode among them): the app's, until a scope that
/// resolves its tokens in another mode sets them.
pub(crate) token_inputs: Arc<TokenInputs>,
/// The operating system.
#[doc(hidden)]
pub os: Os,
/// Whether the window is active.
#[doc(hidden)]
pub active: bool,
/// The platform and the running viewport's window facts.
pub(crate) shell: Arc<ShellInfo>,
/// The keyboard layout as the platform reports it and typing has shown it.
pub(crate) keyboard: Arc<craft_keymap::Layout>,
/// What a scope rarely changes, shared by the scopes below until one changes it (`inherited_mut`).
inherited: Arc<Inherited>,
/// The text and icon ink of the surface the scope sits on, set by a container for its body.
pub ink: Ink,
/// The surface the scope's content sits on: the innermost container surface that paints a fill, set by that
/// container for its body. The window's background at the root and where a layer starts.
pub(crate) surface: SurfaceKind,
/// The built-in text of the scope.
#[doc(hidden)]
pub words: Arc<Words>,
/// How the scope writes numbers: the host's catalog format, else the system region's.
pub(crate) format: Arc<Format>,
/// How the scope writes dates: the host's catalog format, else the system region's.
pub(crate) dates: Arc<DateFormat>,
/// Today's date as the host supplied it.
pub(crate) today: Option<CalendarDate>,
/// `RootEnv::tab_toggles_chrome`.
pub(crate) tab_toggles_chrome: bool,
/// The line height per point of text of the leading face of the interface stack, as the frame began: control
/// heights depend on it, so the key covers it.
#[doc(hidden)]
pub line_ratio: f32,
/// The key of everything above that the style cache depends on.
#[doc(hidden)]
pub key: EnvKey,
@@ -120,12 +91,8 @@ pub struct Scoped {
/// The paragraph direction of text: the interface's, which a container that keeps its axis order leaves alone.
/// The bidi order inside a label follows its script.
pub text_direction: Direction,
/// The motion mode in effect.
pub motion: MotionPolicy,
/// False inside the body of a component with an `Auto` id.
pub ids_stable: bool,
/// Root and viewport only: the pixels per point, read back once per pass.
pub scale: Scale,
/// The innermost arena: components shown under it join it.
pub arena: Option<ArenaId>,
/// The roving group of the innermost body with `ContainerProps.roving`: components shown under it put
@@ -176,7 +143,49 @@ pub struct Scoped {
/// Tab leaves the collection and Forward enters the row (17.5).
pub(crate) row: Option<Id>,
/// What the collection's item step recorded for the item it shows this pass.
pub(crate) item_facts: Option<ItemFacts>,
pub(crate) item_facts: Option<Arc<ItemFacts>>,
}
/// The values of an env that a scope rarely changes: the resolved tokens, the platform, the language and the app's
/// values. `Scoped` reads them through `Deref`.
#[derive(Clone)]
#[non_exhaustive]
pub struct Inherited {
/// The resolved tokens of the scope; read in `style` only.
#[doc(hidden)]
pub tokens: Arc<UiTokens>,
/// What the tokens were resolved from (the light or dark mode among them): the app's, until a scope that
/// resolves its tokens in another mode sets them.
pub(crate) token_inputs: Arc<TokenInputs>,
/// The operating system.
#[doc(hidden)]
pub os: Os,
/// Whether the window is active.
#[doc(hidden)]
pub active: bool,
/// The platform and the running viewport's window facts.
pub(crate) shell: Arc<ShellInfo>,
/// The keyboard layout as the platform reports it and typing has shown it.
pub(crate) keyboard: Arc<craft_keymap::Layout>,
/// The built-in text of the scope.
#[doc(hidden)]
pub words: Arc<Words>,
/// How the scope writes numbers: the host's catalog format, else the system region's.
pub(crate) format: Arc<Format>,
/// How the scope writes dates: the host's catalog format, else the system region's.
pub(crate) dates: Arc<DateFormat>,
/// Today's date as the host supplied it.
pub(crate) today: Option<CalendarDate>,
/// `RootEnv::tab_toggles_chrome`.
pub(crate) tab_toggles_chrome: bool,
/// The line height per point of text of the leading face of the interface stack, as the frame began: control
/// heights depend on it, so the key covers it.
#[doc(hidden)]
pub line_ratio: f32,
/// The motion mode in effect.
pub motion: MotionPolicy,
/// Root and viewport only: the pixels per point, read back once per pass.
pub scale: Scale,
/// The container instances above that receive scoped commands.
pub(crate) commands: CommandChain,
pub(crate) host: Option<Arc<Host>>,
@@ -184,6 +193,14 @@ pub struct Scoped {
pub values: AppValues,
}
impl Deref for Scoped {
type Target = Inherited;
fn deref(&self) -> &Inherited {
&self.inherited
}
}
/// The shrink step of an unwrapped `Row` body, as its direct leaf children shown in flow see it.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) enum Shrink {
@@ -230,7 +247,19 @@ impl Scoped {
/// The facts the collection recorded for the item `id`.
pub(crate) fn facts_of(&self, id: Id) -> Option<&ItemFacts> {
self.item_facts.as_ref().filter(|facts| facts.item == id)
self.item_facts.as_deref().filter(|facts| facts.item == id)
}
/// The inherited values, to change: shared with no other scope from here on.
pub(crate) fn inherited_mut(&mut self) -> &mut Inherited {
Arc::make_mut(&mut self.inherited)
}
/// Adds `values` over the scope's app values.
pub(crate) fn extend_values(&mut self, values: &AppValues) {
if !values.is_empty() {
self.inherited_mut().values.extend(values);
}
}
}
@@ -288,16 +317,29 @@ impl Env {
let shell = Arc::new(windows::shell_of(ctx, pass::current_viewport(ctx)));
let active = shell.window.active;
let keyboard = Arc::new(crate::runtime::keys::layout_of(ctx));
let key = EnvKey::new(tokens.key(), root.direction, scale, os, active, root.values.style_hash()).with_line(line_ratio);
Env {
scoped: Arc::new(Scoped {
key: EnvKey::new(tokens.key(), root.direction, scale, os, active, root.values.style_hash()).with_line(line_ratio),
line_ratio,
tokens,
token_inputs: Arc::new(inputs),
os,
active,
shell,
keyboard,
inherited: Arc::new(Inherited {
line_ratio,
tokens,
token_inputs: Arc::new(inputs),
os,
active,
shell,
keyboard,
motion,
scale,
commands: CommandChain::default(),
words: host_words(ctx, host.as_ref()),
format: host_format(ctx, host.as_ref()),
dates: host_dates(ctx, host.as_ref()),
today: root.today,
tab_toggles_chrome: root.tab_toggles_chrome,
host,
values: root.values.clone(),
}),
key,
ink: Ink::default(),
surface: SurfaceKind::Background,
size: ControlSize::Md,
@@ -306,9 +348,7 @@ impl Env {
wheel_gated: false,
direction: root.direction,
text_direction: root.direction,
motion,
ids_stable: true,
scale,
arena: None,
roving: None,
transform: None,
@@ -327,14 +367,6 @@ impl Env {
item: None,
row: None,
item_facts: None,
commands: CommandChain::default(),
words: host_words(ctx, host.as_ref()),
format: host_format(ctx, host.as_ref()),
dates: host_dates(ctx, host.as_ref()),
today: root.today,
tab_toggles_chrome: root.tab_toggles_chrome,
host,
values: root.values.clone(),
}),
}
}
@@ -425,10 +457,11 @@ impl Env {
/// active state, window facts and OS are the viewport's, everything else stays.
pub(crate) fn rebase(&self, root: &Env) -> Env {
self.derive(|s| {
s.scale = root.scale;
s.active = root.active;
s.shell = root.shell.clone();
s.os = root.os;
let inherited = s.inherited_mut();
inherited.scale = root.scale;
inherited.active = root.active;
inherited.shell = root.shell.clone();
inherited.os = root.os;
})
}
+5 -3
View File
@@ -82,11 +82,13 @@ impl AppValues {
self.entries.map.get(&TypeId::of::<T>()).and_then(|value| value.downcast_ref::<T>()).cloned().unwrap_or_else(T::root)
}
/// Whether no value is set.
pub(crate) fn is_empty(&self) -> bool {
self.entries.map.is_empty()
}
/// Takes every value `other` sets over this set's.
pub(crate) fn extend(&mut self, other: &AppValues) {
if other.entries.map.is_empty() {
return;
}
let entries = Arc::make_mut(&mut self.entries);
for (ty, value) in &other.entries.map {
entries.map.insert(*ty, Arc::clone(value));
+12 -7
View File
@@ -13,7 +13,7 @@ use std::sync::Arc;
/// Token-changing values for a container's body: the body and everything under it resolve their styles from the
/// inherited theme in another mode.
#[derive(Clone)]
#[derive(Clone, PartialEq)]
pub struct ThemeScope {
mode: Mode,
}
@@ -28,8 +28,9 @@ impl ThemeScope {
/// Puts the scope's tokens into `scoped`.
pub(crate) fn apply(&self, ctx: &Context, scoped: &mut Scoped) {
let inputs = TokenInputs { mode: self.mode, ..(*scoped.token_inputs).clone() };
scoped.tokens = tokens_for(ctx, &inputs);
scoped.token_inputs = Arc::new(inputs);
let inherited = scoped.inherited_mut();
inherited.tokens = tokens_for(ctx, &inputs);
inherited.token_inputs = Arc::new(inputs);
}
}
@@ -86,18 +87,22 @@ impl Overrides {
scoped.wheel_gated = true;
}
if let Some(motion) = self.motion {
scoped.motion.mode = scoped.motion.mode.lowered_by(motion);
let inherited = scoped.inherited_mut();
inherited.motion.mode = inherited.motion.mode.lowered_by(motion);
}
if let Some(direction) = self.direction {
scoped.direction = direction;
scoped.text_direction = direction;
}
match self.words {
Some(WordsOverride::Replace(words)) => scoped.words = words,
Some(WordsOverride::Overlay(rows)) => scoped.words = overlaid_words(ctx, &scoped.words, rows),
Some(WordsOverride::Replace(words)) => scoped.inherited_mut().words = words,
Some(WordsOverride::Overlay(rows)) => {
let words = overlaid_words(ctx, &scoped.words, rows);
scoped.inherited_mut().words = words;
}
None => {}
}
scoped.values.extend(&self.values);
scoped.extend_values(&self.values);
}
}
@@ -41,7 +41,7 @@ impl WindowLevel {
///
/// A chrome or caption layout the spec leaves unset is the installed decision's for the window's kind
/// (`InstallSpec::frame`); with no decision installed the window has the OS's frame.
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct WindowSpec {
/// What the window is for.
+3 -2
View File
@@ -18,8 +18,9 @@ pub fn body(ui: &mut Ui, key: &'static str, layout: &BodyLayout, sizes: &[Vec2])
let id = sub(ui.scope_id(), key);
let place = |ui: &mut Ui| sizes.iter().map(|size| place_in_flow(ui, *size)).collect::<Vec<_>>();
let builder = egui::UiBuilder::new().max_rect(ui.available_rect_before_wrap()).sizing_pass().invisible();
crate::runtime::measure::run(&ui.ctx().clone(), || ui.scope_builder(builder, |ui| run_body(ui, id, layout, Vec2::ZERO, place)));
run_body(ui, id, layout, Vec2::ZERO, place)
let env = crate::runtime::env::Env::of(ui);
crate::runtime::measure::run(&ui.ctx().clone(), || ui.scope_builder(builder, |ui| run_body(ui, &env, id, layout, Vec2::ZERO, place)));
run_body(ui, &env, id, layout, Vec2::ZERO, place)
}
/// A block that placed itself from `key`'s entry of last pass and measured `real` this pass. Returns the size
+4 -2
View File
@@ -506,8 +506,10 @@ where
columns: Vec::new(),
toggles: Vec::new(),
};
let installed =
crate::runtime::env::Env::install_for(ui, crate::runtime::env::Env::of(ui).derive_local(|scoped| scoped.item_facts = Some(facts)));
let installed = crate::runtime::env::Env::install_for(
ui,
crate::runtime::env::Env::of(ui).derive_local(|scoped| scoped.item_facts = Some(std::sync::Arc::new(facts))),
);
let shown = row.id(id).show(ui);
crate::runtime::env::Env::restore(ui.ctx(), installed);
shown