A row given its height centres its line; a fill-width row on that line fills it; top and bottom shell panes lay their bar on one line

A container given its height whose body is an unwrapped row sets the row's line at the middle of its band and
pads only along the line. A fill-width container with a row body on such a line is given the line's height, so a
bar in a top or bottom slot fills the slot. A container whose first line is its own row's line sits on an outer
row's line by it even with a child of two lines. The shell's top and bottom panes lay their content out as a row;
the egui centring wrapper and the slot's surface under the bar are gone.
This commit is contained in:
aiongg
2026-11-16 15:59:53 +00:00
parent 63a4811416
commit 81078945af
8 changed files with 135 additions and 34 deletions
+21 -7
View File
@@ -288,7 +288,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
self.overflow = self.wanted_width(props).map_or(0.0, |wanted| (wanted - room.max(0.0)).max(0.0));
let (header, end) = (self.measured_header.unwrap_or(Vec2::ZERO), self.measured_end.unwrap_or(Vec2::ZERO));
let height = self.regions_size(props, body, header, self.measured_footer, end).y;
Vec2::new(width, height) + Vec2::splat(2.0 * pad_of(scx.tokens, props.pad))
Vec2::new(width, height) + 2.0 * self.pads(props, scx.tokens)
}
/// The regions run once in an invisible sizing pass over the room, as `content` runs them, and the container takes
@@ -371,7 +371,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
if at.ui.is_sizing_pass() && self.given == (true, true) && self.room.is_finite() && !scrolled_share {
return self.room;
}
let pad = Vec2::splat(2.0 * pad_of(at.scx.tokens, props.pad));
let pad = 2.0 * self.pads(&props, at.scx.tokens);
let vertical = scroll_of(&props).is_some_and(|scroll| scroll.vertical_on());
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
@@ -500,7 +500,13 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
// where it is shown: its measure never sets the column's width.
let held = !self.given.0 && self.held(props, &Env::of(ui));
let room = if held { room.min(crate::layout::flow_room(ui).x) } else { room };
Vec2::new(crate::layout::fill_size(ui, id, craft_behavior::Axis::X, size.x, room, self.given.0 || held), size.y)
// Given the height of the row line it sits on, it fills that line (`given_axes`).
let height = if self.given.1 {
crate::layout::fill_size(ui, id, craft_behavior::Axis::Y, size.y, crate::layout::flow_room(ui).y, true)
} else {
size.y
};
Vec2::new(crate::layout::fill_size(ui, id, craft_behavior::Axis::X, size.x, room, self.given.0 || held), height)
}
Sizing::Content => size,
}
@@ -520,6 +526,12 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
layout_memory::measured(ctx, sub(id, "first")).map(|found| found.took.y)
}
/// A container with no header whose body is an unwrapped row reports that row's line as its first line.
fn first_is_row_line(&self, comp: &C) -> bool {
let props = comp.props(Internal::new());
props.header.is_none() && super::size::unwrapped_row(props)
}
fn member(&self, comp: &C) -> bool {
comp.props(Internal::new()).label.is_some()
}
@@ -539,7 +551,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
return None;
}
let tokens = cx.tokens;
let inner = content.shrink(pad_of(tokens, props.pad));
let inner = content.shrink2(self.pads(&props, tokens));
let regions = self.regions(&props, inner, pad_of(tokens, props.pad), self.room_size(rect, inner), rtl, self.measured_sizes());
let (_, slots) = self.header_line(regions.header, pad_of(tokens, header.inset), parts, rtl);
Some(std::rc::Rc::new(slots))
@@ -550,7 +562,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
let ctx = pcx.ui.ctx().clone();
let rtl = pcx.flow.is_rtl();
let tokens = pcx.tokens;
let inner = pcx.content_rect.shrink(pad_of(tokens, props.pad));
let inner = pcx.content_rect.shrink2(self.pads(&props, tokens));
let room = self.room_size(rect, inner);
let regions = self.regions(&props, inner, pad_of(tokens, props.pad), room, rtl, self.measured_sizes());
let scroll = scroll_of(&props);
@@ -678,7 +690,7 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
let node = matches!(C::ROLE, Role::Node(_));
let scroll = scroll_of(&props);
let pad = pad_of(&env.tokens, props.pad);
let inner = cx.core.content_rect.shrink(pad);
let inner = cx.core.content_rect.shrink2(self.pads(&props, &env.tokens));
let room = self.room_size(rect, inner);
let mut regions = self.regions(&props, inner, pad, room, rtl, self.measured_sizes());
let surface_slot = SurfaceSlot::reserve(ui, matches!(props.mount, Mount::Layer(_)));
@@ -781,6 +793,8 @@ impl<C: Container> ShapeHooks<C> for BodyHooks<'_> {
(regions.body, regions.beside) = (placed.body, placed.beside);
}
let line = shared_line(&props, beside);
// A row given its height sets its line at the middle of its band: the line is as high as the band.
let line = if self.centres_line(&props) { Some(line.unwrap_or(0.0).max(regions.body.height())) } else { line };
// B2 label: the control gets the rect the label leaves; the label column adds to the container's extent.
let mut body_rect = regions.body;
let mut label_rect = Rect::NOTHING;
@@ -1246,7 +1260,7 @@ impl BodyHooks<'_> {
) -> Vec2 {
let props = Arc::clone(&self.props);
let (id, ctx) = (cx.core.id, at.ui.ctx().clone());
let pad = Vec2::splat(2.0 * pad_of(at.scx.tokens, props.pad));
let pad = 2.0 * self.pads(&props, at.scx.tokens);
#[cfg(feature = "testing")]
crate::runtime::measure::count_body(&ctx, id);
layout_memory::begin_measure(&ctx, id);
+24 -1
View File
@@ -117,9 +117,13 @@ impl<'b> BodyHooks<'b> {
/// The axes the container is given where `env` is its parent's: a rect it is shown at gives both; an inline
/// container that fills an axis takes the room only where its parent was given that axis.
///
/// A fill-width container whose body is a row, shown on the line of a row given its height, is given that height
/// too: the line is a fixed cross extent, and the container fills it (a bar in a shell slot).
pub(super) fn given_axes(&self, props: &ContainerProps, env: &Env, at: ShowAt) -> (bool, bool) {
let sizing = self.sizing(props);
let (x, y) = (sizing != Sizing::Content, sizing == Sizing::Fill);
let fills_line = sizing == Sizing::FillWidth && unwrapped_row(props) && env.row_line.is_some();
let (x, y) = (sizing != Sizing::Content, sizing == Sizing::Fill || fills_line);
match (at, &props.mount) {
(ShowAt::Rect(_), _) => (true, true),
(ShowAt::Flow, Mount::Inline) => (x && env.gives_width(), y && !env.content.1),
@@ -134,6 +138,20 @@ impl<'b> BodyHooks<'b> {
matches!((at, &props.mount), (ShowAt::Flow, Mount::Inline)) && self.sizing(props) == Sizing::Content && env.given_column
}
/// Whether the container centres its body's line in the height it is given: its body is a row that does not scroll
/// along the height, and the container is given its height (a rect it is shown at, a fill, a fixed row line it
/// fills). Its padding then keeps the members off the start and end edges only (`pads`).
pub(super) fn centres_line(&self, props: &ContainerProps) -> bool {
self.given.1 && unwrapped_row(props) && !scroll_of(props).is_some_and(|scroll| scroll.vertical_on())
}
/// The container's padding along each axis: `ContainerProps::pad` on both, or along the line only where the
/// container centres its line in its height.
pub(super) fn pads(&self, props: &ContainerProps, tokens: &crate::style::UiTokens) -> Vec2 {
let pad = super::regions::pad_of(tokens, props.pad);
Vec2::new(pad, if self.centres_line(props) { 0.0 } else { pad })
}
/// Whether the container's body is laid out across the width it is offered: the container is given the width,
/// passes it on, or is held across the width its column settled on.
pub(super) fn wide(&self) -> bool {
@@ -293,3 +311,8 @@ impl<'b> BodyHooks<'b> {
}
}
}
/// Whether the container's body is a `Row` that does not wrap: its children sit on one line.
pub(super) fn unwrapped_row(props: &ContainerProps) -> bool {
matches!(props.layout, crate::layout::BodyLayout::Row { wrap: false, .. })
}
+11 -2
View File
@@ -144,6 +144,13 @@ pub(crate) trait ShapeHooks<C: Component> {
Some(height / 2.0)
}
/// Whether the root's first line is the line of its own unwrapped `Row` body: it sits on a `Row`'s line by that
/// line even where a child of more than one line makes it taller, so the members of a row nested in a row share
/// the outer row's line.
fn first_is_row_line(&self, _comp: &C) -> bool {
false
}
/// Whether the root is one member of a bar's line, shown whole or not at all: a leaf is; a body is when it has a
/// side label (a captioned field), and otherwise only lays out the members it holds.
fn member(&self, _comp: &C) -> bool {
@@ -557,6 +564,7 @@ pub(crate) trait ErasedPass<'a> {
fn sized(&self, ui: &Ui, id: Id, size: Vec2) -> Vec2;
fn fills_width(&self) -> bool;
fn first_line(&self, ctx: &Context, id: Id, height: f32) -> Option<f32>;
fn first_is_row_line(&self) -> bool;
fn member(&self) -> bool;
fn fills_width_only(&self) -> bool;
fn arena(&self) -> bool;
@@ -804,7 +812,8 @@ fn place_root(p: &Pass<'_, '_, '_>, ui: &mut Ui, at: ShowAt, env: &Env, size: Ve
.then(|| crate::layout::flow_room(ui).x)
.filter(|width| width.is_finite())
.unwrap_or(0.0);
let flowed = steps::place(ui, at, Vec2::new(p.measured.x.min(size.x), size.y), InFlow { fill: false, first: first(size.y) });
let line = p.p.first_is_row_line();
let flowed = steps::place(ui, at, Vec2::new(p.measured.x.min(size.x), size.y), InFlow { fill: false, first: first(size.y), line });
// The column's first sweep learns which of its held children measured narrower than it settles on.
if let Some(ColumnSweep::Count(column)) = env.column {
crate::layout::report_held(&ctx, column, flowed.width());
@@ -814,7 +823,7 @@ fn place_root(p: &Pass<'_, '_, '_>, ui: &mut Ui, at: ShowAt, env: &Env, size: Ve
} else {
let fill = p.p.fills_width() && !p.p.fills_width_only();
let size = if inert { Vec2::ZERO } else { size };
steps::place(ui, at, size, InFlow { fill, first: first(size.y) })
steps::place(ui, at, size, InFlow { fill, first: first(size.y), line: p.p.first_is_row_line() })
};
(rect, held)
}
@@ -405,6 +405,10 @@ impl<'a, C: Component> ErasedPass<'a> for TypedPass<'_, 'a, C> {
self.hooks.first_line(self.comp, ctx, id, height)
}
fn first_is_row_line(&self) -> bool {
self.hooks.first_is_row_line(self.comp)
}
fn member(&self) -> bool {
self.hooks.member(self.comp)
}
+5 -2
View File
@@ -898,6 +898,9 @@ pub(crate) struct InFlow {
/// rows run along Y, or a container whose first child is one. The child is one line when that centre lies at
/// half its height (`one_line`).
pub first: Option<f32>,
/// `first` is the line of the child's own unwrapped `Row` body: the child sits on a row's line by it even when it
/// is more than one line (a nested row with a child of two lines).
pub line: bool,
}
/// How far a one-line child's first-line centre may lie from half its height: half a pixel at the scales the box runs.
@@ -919,7 +922,7 @@ fn one_line(first: Option<f32>, height: f32) -> Option<f32> {
/// sits at the vertical centre of its cell.
#[doc(hidden)]
pub fn place_in_flow(ui: &mut Ui, size: Vec2) -> Rect {
place_in_cell(ui, size, InFlow { fill: false, first: Some(size.y / 2.0) })
place_in_cell(ui, size, InFlow { fill: false, first: Some(size.y / 2.0), line: false })
}
/// `place_in_flow` for a child that is `child`. In a measuring run the child reports its line to the row around it
@@ -927,7 +930,7 @@ pub fn place_in_flow(ui: &mut Ui, size: Vec2) -> Rect {
pub(crate) fn place_in_cell(ui: &mut Ui, size: Vec2, child: InFlow) -> Rect {
let env = Env::of(ui);
let (line, target) = (env.row_line, env.first_line);
let child = InFlow { first: one_line(child.first, size.y), ..child };
let child = InFlow { first: if child.line { child.first } else { one_line(child.first, size.y) }, ..child };
let above = line.and_then(|line| line.centre).zip(child.first).map_or(0.0, |(centre, first)| (centre - first).max(0.0));
let slot = Vec2::new(size.x, line.and_then(|line| line.height).map_or(above + size.y, |height| height.max(above + size.y)));
let (rect, in_cell) = take_in(ui, env.grid, slot);
+8 -18
View File
@@ -14,7 +14,7 @@ use super::screen_mode::{ScreenMode, ScreenModeCommands, ScreenModeFollow};
use super::words::ShellWords;
use crate::contract::overlay::Resize;
use crate::contract::{
Bind, BodyCx, Common, Component, Container, ContainerProps, Cx, Mount, NoValue, Outcome, PaneEdge, Props as _, Remember as _, Role, ShellPane,
Bind, BodyCx, BodyLayout, Common, Component, Container, ContainerProps, Cx, Mount, NoValue, Outcome, PaneEdge, Props as _, Remember as _, Role, ShellPane,
ShowContainer as _, Sizing,
};
use crate::notices::ToastStack;
@@ -120,9 +120,12 @@ impl ShellRegion {
ShellRegion { common: Common::new(), props, shell: Some(shell), senses_surface: false }
}
/// A pane of the window; it fills the room its edge gives it.
/// A pane of the window; it fills the room its edge gives it. A top or bottom pane lays its content along its edge
/// on one line at the middle of its height, so a bar in it fills that height and centres its members there; a
/// start, end or centre pane stacks its content.
pub fn pane(pane: ShellPane) -> Self {
let props = ContainerProps::new().mount(Mount::Pane(pane)).focus(FocusPolicy::PANE);
let layout = if matches!(pane.edge, PaneEdge::Top | PaneEdge::Bottom) { BodyLayout::row() } else { BodyLayout::stack() };
let props = ContainerProps::new().mount(Mount::Pane(pane)).focus(FocusPolicy::PANE).layout(layout);
ShellRegion { common: Common::new(), props, shell: None, senses_surface: false }
}
}
@@ -520,26 +523,13 @@ impl<'a, S> AppShell<'a, S> {
continue;
}
let extent = placed.extent(&tokens);
let Placed { slot, edge, named, add, title, .. } = placed;
let Placed { slot, edge, named, add, .. } = placed;
let pane = ShellPane::new(slot.key()).edge(*edge).extent(extent).at(rect_of(slot.key()));
let mut region = ShellRegion::pane(pane).id_salt(("slot", slot.key()));
// A bar is as high as its content and the slot as high as its token, so the slot paints the bar's
// surface under it, and the bar sits at the slot's centre line: no band of the backdrop shows
// between the bar and the body.
let centred = !*title && matches!(edge, PaneEdge::Top | PaneEdge::Bottom);
if centred {
region = region.surface(SurfaceKind::Chrome);
}
if let Some(label) = slot.name().cloned().or_else(|| named.map(|name| name(&words))) {
region = region.label(label);
}
region.show(ui, |ui, bcx| {
if centred {
ui.with_layout(egui::Layout::left_to_right(egui::Align::Center), |ui| add(ui, bcx, app));
} else {
add(ui, bcx, app);
}
});
region.show(ui, |ui, bcx| add(ui, bcx, app));
}
};
show_slots(ui, false, app);
+60 -3
View File
@@ -1,10 +1,17 @@
//! The app shell's named slots: a slot keeps its region name on either edge.
//! The app shell's named slots: a slot keeps its region name on either edge, and a bar in a top or bottom slot fills
//! it with its members on the slot's middle.
use craft_ui::contract::{PaneEdge, Role, Show as _};
use craft_ui::bars::{Bar, BarKind};
use craft_ui::buttons::Button;
use craft_ui::contract::{PaneEdge, Role, Show as _, ShowContainer as _};
use craft_ui::display::Text;
use craft_ui::layout_components::{Row, Stack};
use craft_ui::runtime::env::WindowKey;
use craft_ui::shell::AppShell;
use craft_ui::testing::{Frames, trial};
use craft_ui::testing::{Fixture, Frames, trial};
use egui::{Rect, Vec2};
use std::cell::Cell;
use std::rc::Rc;
/// A tool rail placed at the end edge sits at the window's end and screen readers still find it as the Tools region.
#[trial]
@@ -29,3 +36,53 @@ fn the_tool_rail_at_the_end_edge_is_the_tools_region() {
let names: Vec<&str> = tree.with_role(Role::GROUP).into_iter().filter_map(|key| tree.name_of(key)).collect();
assert!(names.contains(&"Tools"), "the end-edge rail is the Tools region: {names:?}");
}
/// What the options-bar trial saw: the slot, the bar, a member of the bar and a member of a row nested in it.
#[derive(Clone, Copy)]
struct InSlot {
slot: Rect,
bar: Rect,
member: Rect,
nested: Rect,
}
/// A bar in the options slot is as high as the slot, whatever its own padding and members take, and its members sit
/// on the slot's middle: a member of the bar's own row and a member of a row nested in it beside a child of two lines.
#[trial]
fn a_bar_in_a_top_slot_fills_it_and_centres_its_members_on_one_line() {
let seen = Rc::new(Cell::new(None::<InSlot>));
let out = Rc::clone(&seen);
let mut fixture = Fixture::new(move |ui| {
let (mut bar, mut member, mut nested) = (Rect::NOTHING, Rect::NOTHING, Rect::NOTHING);
let shown = AppShell::new(WindowKey::main())
.options_bar(true, |ui, _, _: &mut ()| {
bar = Bar::new("Options", BarKind::Options)
.show(ui, |ui, _| {
member = Button::new("Alpha").show(ui).rect;
Row::new().show(ui, |ui, _| {
nested = Button::new("Beta").show(ui).rect;
Stack::new().show(ui, |ui, _| {
Text::new("Above").show(ui);
Text::new("Below").show(ui);
});
});
})
.output
.response
.rect;
})
.body(|_, _, _| {})
.show(ui, &mut ());
let slot = shown.regions.slots.iter().find(|(key, _)| *key == "options").map(|(_, rect)| *rect);
if let Some(slot) = slot {
out.set(Some(InSlot { slot, bar, member, nested }));
}
});
fixture.room(Vec2::new(600.0, 300.0)).settle();
let InSlot { slot, bar, member, nested } = seen.get().expect("the options slot shows");
const SLACK: f32 = 1.0;
assert!((bar.min.y - slot.min.y).abs() <= SLACK && (bar.max.y - slot.max.y).abs() <= SLACK, "the bar {bar:?} fills the slot {slot:?}");
for (name, rect) in [("the bar's member", member), ("the nested row's member", nested)] {
assert!((rect.center().y - slot.center().y).abs() <= SLACK, "{name} {rect:?} sits on the middle of the slot {slot:?}");
}
}
+2 -1
View File
@@ -77,7 +77,8 @@ impl Outcome for BarOutput {
/// A bar over a chrome surface whose body holds the members in reading order: a tool bar's at the standard control
/// size, an options or status bar's at the small one. They are one roving group unless the bar is made of
/// [`tab_stops`](Bar::tab_stops). The bar is as tall as its tallest member plus the control padding, and takes the
/// width it is offered. A bar of one row lays its body out as a row; a bar of several rows as a stack whose rows the
/// width it is offered. On the line of a row given its height (a top or bottom slot of the shell) it fills that height
/// and its members sit on the line's middle, with its padding at the start and end only. A bar of one row lays its body out as a row; a bar of several rows as a stack whose rows the
/// caller makes with `Row`. A member that fills (a leaf with `Sizing::FillWidth`, a fill-width `Row`) takes the room the view
/// leaves. A row too long for the bar first narrows its selects and elidable text, the last first, down to their
/// readable least (`TextRun::READABLE_CHARACTERS`), then scrolls, so a member past the edge is reached by Tab and