Dialog form cards widen their label column for the current language (#10620) (#10646)

* claim: #10620

* widen dialog form-card label columns to the measured label width (#10620)

* fix compile of the grow tests

* grow the card only past the label cap and tag the form scope in place (#10620)

* keep scope_grow crate-internal so the gallery scan stays element-only (#10620)

---------

Co-authored-by: Dahak Builds <dahakbuilds@users.noreply.github.com>
This commit is contained in:
Dahak BuildsandDahak Builds authored and GitHub committed 2026-11-02 00:04:41 +00:00
1 parent 7d86a8cfd3
commit d68d86dae9
6 files changed
+128 -13

No files matched your search

+17 -9
View File
@@ -3372,6 +3372,20 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
let (ok_label, close_label) = action_labels(&d.kind);
// What the footer's OK takes, for the check in the view's corner too (#6709).
let ok_enabled = valid && !ok_label.is_empty() && app.applying.is_none();
// #10620: the card widens to fit its widest label in the current language. The body
// publishes the extra it needs under this key each pass; the card applies it next pass,
// so the label column grows and the control column keeps its design width. Manager cards
// keep their approved fixed width.
let manager = matches!(
d.kind,
Kind::Material { .. }
| Kind::Appearance(_)
| Kind::Motion(crate::dialogs_motion::Mo::Configurations { .. })
| Kind::Sheet(crate::dialogs_sheet::Sm::Rules { .. })
| Kind::Plastic(crate::dialogs_plastic::Pl::Rules { .. })
);
let grow_key = egui::Id::new(("sc_dialog_label_grow", raw_title));
let label_grow = ctx.data(|data| data.get_temp::<f32>(grow_key)).unwrap_or(0.0).min((vp.width() - t.space_24 - card_width(&d)).max(0.0));
let panel = crate::ui_kit::Panel::new(&heading, egui::Id::new(("sc_dialog", title(&d.kind))), anchor, drag_bounds, side, frame)
.actions(ok_label, close_label);
let panel = if let Some(column) = column {
@@ -3379,8 +3393,10 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
} else if wide && side == crate::frame::Side::Left {
let available = app.viewport.palette_rect.map_or(vp.width(), |r| (r.left() - vp.left() - t.space_8).max(0.0));
panel.width(card_width(&d).min(available))
} else {
} else if manager {
panel.width(card_width(&d))
} else {
panel.width(card_width(&d) + label_grow).grow_label(grow_key)
};
let reset_scroll = d.reset_scroll;
let panel =
@@ -3414,14 +3430,6 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
let heading = crate::ui_kit::FeatureOptions { icon, title: label, drag_key, moved, docked, apply_label: repeatable.then_some("Apply") };
let applying = app.applying.is_some();
let mut collapsed = d.collapsed;
let manager = matches!(
d.kind,
Kind::Material { .. }
| Kind::Appearance(_)
| Kind::Motion(crate::dialogs_motion::Mo::Configurations { .. })
| Kind::Sheet(crate::dialogs_sheet::Sm::Rules { .. })
| Kind::Plastic(crate::dialogs_plastic::Pl::Rules { .. })
);
// A study/configuration owns Enter for its cells, including when folded.
let cell_enter = matches!(&d.kind, Kind::Motion(k) if k.wide()) || matches!(&d.kind, Kind::Material { editor, .. } if editor.editing());
if cell_enter && collapsed {
+32
View File
@@ -578,6 +578,38 @@ fn new_cards_settle_before_the_first_click_in_both_layouts() {
}
}
#[test]
fn the_loft_dialog_widens_its_label_column_for_the_current_language() {
// #10620: German "Anpassung an Leitkurve" (Rail Fit) clipped to "Anpassung an Leit…" in
// the fixed-width Loft card. The label column now measures the dialog's labels in the
// active language and the card widens by the same amount, so the label fits and the
// control column keeps its design width. English, whose labels fit the design, is unchanged.
let t = Tokens::get();
let shoot = |language: &str| {
let mut h = fixture();
h.call("ui.resize", json!({"width": 1400, "height": 950}));
h.app.preferences.language = language.into();
h.app.dialog = Some(representative(&h, "solid.loft"));
h.frames(4);
(h, scenario::rect_of("dialog:card").unwrap(), scenario::rect_of("dialog:label:Rail Fit").unwrap())
};
let (h, card, label) = shoot("de");
let (_, english_card, english_label) = shoot("en");
assert!(card.width() > english_card.width(), "the German card widened: {card:?} vs {english_card:?}");
assert!(label.width() > t.form_label_width * 1.6, "past the ordinary cap: {label:?}");
assert!(english_label.width() <= t.form_label_width * 1.6, "English keeps the design's label column: {english_label:?}");
// The drawn galley holds the whole translation: no ellipsis.
let drawn = h
.shapes
.iter()
.find_map(|shape| match &shape.shape {
egui::Shape::Text(text) if text.galley.job.text.contains("Anpassung") => Some(text.galley.job.text.to_string()),
_ => None,
})
.expect("the Rail Fit row drew its German label");
assert!(drawn.contains("Leitkurve") && !drawn.contains('…'), "the label is not ellipsized: {drawn:?}");
}
#[test]
fn remaining_dialogs_keep_kit_chrome_and_cancel_restores_preview() {
for command in [
+18 -1
View File
@@ -7,6 +7,15 @@ pub(super) const FORM: &str = "sc_dense_form";
pub(super) const LABEL: &str = "sc_form_label";
pub(super) const FIXED_LABEL: &str = "sc_fixed_label_width";
pub(super) const GROW_LABEL: &str = "sc_grow_label_column";
/// A form whose card widens so its widest label fits (#10620). Each pass the form publishes,
/// under `key`, the width its label column needs beyond the design's 1.6x cap; the card's
/// owner reads that before opening the card, so the card settles one frame later.
/// Tokens: `form_label_width, font_label, dialog_label, space_4`.
pub(super) fn scope_grow<R>(ui: &mut Ui, key: egui::Id, add: impl FnOnce(&mut Ui) -> R) -> R {
scope_inner(ui, Some(key), add)
}
/// A deliberate label grid for multi-column settings, inherited by the existing shared rows.
pub(crate) fn settings_form<R>(ui: &mut Ui, label_width: f32, add: impl FnOnce(&mut Ui) -> R) -> R {
@@ -17,7 +26,15 @@ pub(crate) fn settings_form<R>(ui: &mut Ui, label_width: f32, add: impl FnOnce(&
/// Mark a form without global state: children inherit this tag through their UI stack.
/// Inherited form styling and label-column identity. Tokens: `space_4/8, form_gap_y, control_height, font_label, accent, selected_bg, dialog_rule, control_fill/border/radius, text`.
pub(crate) fn scope<R>(ui: &mut Ui, add: impl FnOnce(&mut Ui) -> R) -> R {
ui.scope_builder(egui::UiBuilder::new().ui_stack_info(egui::UiStackInfo::default().with_tag(FORM)), |ui| {
scope_inner(ui, None, add)
}
fn scope_inner<R>(ui: &mut Ui, grow: Option<egui::Id>, add: impl FnOnce(&mut Ui) -> R) -> R {
let mut info = egui::UiStackInfo::default().with_tag(FORM);
if let Some(key) = grow {
info = info.with_tag_value(GROW_LABEL, key);
}
ui.scope_builder(egui::UiBuilder::new().ui_stack_info(info), |ui| {
let t = Tokens::get();
ui.spacing_mut().item_spacing = vec2(t.space_4, t.form_gap_y);
ui.spacing_mut().interact_size.y = row_height();
+15 -1
View File
@@ -107,7 +107,21 @@ pub(super) fn label_column(ui: &Ui, text: &str, row_width: f32) -> f32 {
}
None => natural,
};
(widest + t.space_4).clamp(base, base * LABEL_COLUMN_MAX).min(row_width * 0.5)
let needed = widest + t.space_4;
if let Some(&key) = ui.stack().iter().find_map(|node| node.tags().get_downcast::<egui::Id>(super::layout::GROW_LABEL)) {
// A growing card (#10620): labels up to the ordinary 1.6x cap keep the design's card
// width; a longer label grows the column past the cap, and the extra the card must
// gain is published under `key` so the card widens by the same amount and the
// control column keeps its design width.
let extra = (needed - base * LABEL_COLUMN_MAX).max(0.0);
let previous = ui.ctx().data(|d| d.get_temp::<f32>(key)).unwrap_or(0.0);
if (extra - previous).abs() > 0.5 {
ui.ctx().request_discard("dialog label column width");
}
ui.ctx().data_mut(|d| d.insert_temp(key, extra));
return needed.max(base).min(row_width * 0.7);
}
needed.clamp(base, base * LABEL_COLUMN_MAX).min(row_width * 0.5)
}
#[cfg(test)]
@@ -1,3 +1,4 @@
use crate::theme::Tokens;
use crate::ui_kit::metrics::dimension;
use crate::ui_kit::test_support::*;
use crate::ui_kit::*;
@@ -22,6 +23,36 @@ fn non_finite_and_tiny_row_widths_are_sanitized() {
}
}
#[test]
fn a_growing_form_widens_past_the_cap_and_publishes_the_card_extra() {
// #10620: inside `grow_form` the label column takes the width the widest label needs,
// past the 1.6x cap an ordinary form clamps to, and the card's owner is told by how much
// the card must widen so the control column keeps its room.
let ctx = egui::Context::default();
crate::fonts::setup_fonts(&ctx);
let t = Tokens::get();
let key = egui::Id::new("grow-test");
let long = "Anpassung an Leitkurve";
let mut label = None;
for _ in 0..3 {
let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
ui.set_width(300.0);
scope_grow(ui, key, |ui| {
let mut value = String::new();
row(ui, long, |ui| field(ui, &mut value));
});
});
output.textures_delta.clear();
label = scenario::rect_of(&format!("dialog:label:{long}"));
}
let label = label.unwrap();
let measured = ctx.fonts_mut(|f| f.layout_no_wrap(long.to_owned(), egui::FontId::proportional(t.font_label), t.dialog_label)).size().x;
assert!(label.width() > t.form_label_width * 1.6, "past the ordinary cap: {label:?}");
assert!(label.width() >= measured, "the label fits its column: {label:?} vs {measured}");
let extra = ctx.data(|d| d.get_temp::<f32>(key)).unwrap();
assert!((extra - (label.width() - t.form_label_width * 1.6)).abs() < 0.01, "the card grows only past the cap: {extra}");
}
#[test]
fn file_tiles_are_fixed_height_bounded_and_disabled_actions_stay_inert() {
let ctx = crate::fonts::test_context();
+15 -2
View File
@@ -282,6 +282,7 @@ pub(crate) struct Panel<'a> {
cancel: &'a str,
reset_scroll: bool,
joined: Option<super::DockEdges>,
grow_key: Option<egui::Id>,
}
pub(crate) struct WorkspaceOptions<'a> {
@@ -600,6 +601,7 @@ impl<'a> Panel<'a> {
cancel: "Cancel",
reset_scroll: false,
joined: None,
grow_key: None,
}
}
@@ -621,6 +623,13 @@ impl<'a> Panel<'a> {
self
}
/// The feature card's form measures its labels and publishes the width it needs under
/// this key, so the card can widen for the current language (#10620).
pub(crate) fn grow_label(mut self, key: egui::Id) -> Self {
self.grow_key = Some(key);
self
}
/// The footer's primary and closing actions when they are not OK and Cancel. An empty `ok`
/// leaves the primary action out (a card that only closes, e.g. Measure).
pub(crate) fn actions(mut self, ok: &'a str, cancel: &'a str) -> Self {
@@ -759,7 +768,7 @@ impl<'a> Panel<'a> {
mut collapsed: Option<&mut bool>,
body: impl FnOnce(&mut Ui) -> ComputeStatus,
) -> (bool, super::Action) {
super::scope(ui, |ui| {
let card = |ui: &mut Ui| {
let t = Tokens::get();
let min = ui.cursor().min;
let band = egui::Rect::from_min_size(min, vec2(ui.available_width(), super::header_height()));
@@ -845,7 +854,11 @@ impl<'a> Panel<'a> {
);
super::Container::finish_content(ui, self.positioned_frame(ui.ctx()));
(close, action)
})
};
match self.grow_key {
Some(key) => super::scope_grow(ui, key, card),
None => super::scope(ui, card),
}
}
/// Palette composition retains its compact padding and whole-card scrolling on short views.