Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Merge #281: Keep menus and dialogs usable at larger UI scales

aiongg79e6ab656928
diff --cc crates/ui-egui/src/dialogs.rs
index a3c278ca6,ae5f7c23b..b2ba5ab2b
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@@ -1025,13 -841,12 +1030,17 @@@ pub fn show(app: &mut DesignApp, ctx: &
},
};
egui::Modal::new(egui::Id::new("dialog")).show(ctx, |ui| {
- ui.set_min_width(380.0);
- ui.set_max_width(match d.id.as_str() {
+ let frame_margin = egui::Frame::popup(ui.style()).total_margin().sum();
+ let available = (ctx.content_rect().size() - frame_margin - egui::vec2(16.0, 16.0)).max(egui::Vec2::splat(1.0));
- let preferred_width: f32 = if d.id == "newDocument" && crate::i18n::is_rtl(&app.ui.language) { 380.0 } else { 640.0 };
++ let preferred_width: f32 = match d.id.as_str() {
+ "alert" => 440.0,
+ "closeDocument" => 380.0,
+ "newDocument" if crate::i18n::is_rtl(&app.ui.language) => 380.0,
+ _ => 640.0,
- });
++ };
+ let width = preferred_width.min(available.x);
+ ui.set_min_width(380.0_f32.min(width));
+ ui.set_max_width(width);
if crate::i18n::is_rtl(&app.ui.language) {
ui.horizontal(|ui| {
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
@@@ -1256,10 -1071,10 +1270,10 @@@
"insertXref" => insert_xref(app, ui, &mut d),
"findFont" => find_font(app, ui, &mut d),
"colorPicker" => color_picker(ui, &mut d),
- "preferences" => preferences(app, ui, &mut d),
+ "preferences" => preferences(app, ui, &mut d, body_height),
"print" => print_dialog(app, ui, &mut d),
"pdfImport" => {
- ui.label(egui::RichText::new(d.s("path")).size(11.0));
+ ui.label(egui::RichText::new(if d.b("async") { d.s("name") } else { d.s("path") }).size(11.0));
ui.horizontal(|ui| {
crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Page (1–{count}):").replace("{count}", &d.n("pages").unwrap_or(1.0).to_string()));
text_field(ui, &mut d, "page", 60.0);
@@@ -1546,26 -1357,33 +1560,27 @@@
});
}
"textFrameOptions" => {
- egui::Grid::new("tfo").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {
- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Number of columns"));
- text_field(ui, &mut d, "columns", 80.0);
- ui.end_row();
- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Gutter"));
- text_field(ui, &mut d, "gutter", 80.0);
- ui.end_row();
- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Inset spacing"));
- text_field(ui, &mut d, "inset", 80.0);
- ui.end_row();
- crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Vertical justification"));
- let cur = d.s("verticalJustification");
- egui::ComboBox::from_id_salt("vj").selected_text(crate::rtl::widget(ui, crate::i18n::tr(&app.ui.language, &cur))).show_ui(ui, |ui| {
- for v in ["top", "center", "bottom", "justify"] {
- if ui.selectable_label(cur == v, crate::rtl::widget(ui, crate::i18n::tr(&app.ui.language, v))).clicked() {
- d.fields.insert("verticalJustification".into(), json!(v));
- }
- }
- });
- ui.end_row();
- });
+ seed_text_frame_options(app, &mut d);
+ text_frame_options_dialog(app, ui, &mut d);
}
"documentSetup" => document_setup(app, ui, &mut d),
+ "alert" => {
+ let file = d.s("file");
+ if !file.is_empty() {
+ crate::rtl::label(ui, egui::RichText::new(crate::rtl::isolate(&file)).font(semibold(13.0)));
+ ui.add_space(4.0);
+ }
+ crate::rtl::label(ui, d.s("message"));
+ }
_ => {}
}
+ });
ui.add_space(12.0);
+ let ok_label = match d.id.as_str() {
+ "closeDocument" => " Save ",
+ "findFont" => "Replace All",
+ _ => " OK ",
+ };
ui.horizontal(|ui| {
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui
@@@ -3651,192 -2669,262 +3666,448 @@@ fn find_font(app: &mut DesignApp, ui: &
mod tests {
use super::*;
+ fn command_app(id: &str, fields: Value) -> DesignApp {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.ui.dialog = Some(Dialog::new(&format!("cmd:{id}"), fields));
+ app
+ }
+
+ #[test]
+ fn generic_new_document_preserves_typed_values_and_text_entry() {
+ for pages in [json!(2), json!(" 2 ")] {
+ let mut app = command_app(
+ "file.new",
+ json!({
+ "preset": "A4", "pages": pages, "facingPages": false, "gutter": 0,
+ "margins": {"top": 10, "bottom": 20, "inside": 30, "outside": 40},
+ "title": " ", "status": "internal", "primaryTextFrame": true
+ }),
+ );
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ assert_eq!(doc.page_count(), 2);
+ assert!(!doc.settings.facing_pages);
+ assert!(doc.title.starts_with("Untitled-"));
+ for page in doc.spreads.iter().flat_map(|s| &s.pages) {
+ assert!((page.width - 595.2755905511812).abs() < 0.01);
+ assert!((page.height - 841.8897637795277).abs() < 0.01);
+ assert_eq!(page.columns.gutter, 0.0);
+ assert_eq!(page.margins.top, 10.0);
+ assert_eq!(page.margins.outside, 40.0);
+ }
+ assert!(doc.spreads.iter().all(|s| s.items.is_empty()), "undocumented fields stay excluded");
+ assert!(app.ui.dialog.is_none());
+ }
+ }
+
+ #[test]
+ fn generic_command_preserves_array_geometry() {
+ let mut app = command_app("file.new", json!({}));
+ confirm(&mut app).unwrap();
+ app.ui.dialog = Some(Dialog::new("cmd:frame.create", json!({"rect": [10, 20, 110, 220]})));
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ let item = doc.spreads.iter().flat_map(|s| &s.items).next().unwrap();
+ assert_eq!(item.bounds(), designcraft_geom::Rect::new(10.0, 20.0, 110.0, 220.0));
+ }
+
+ #[test]
+ fn generic_explicit_null_uses_the_commands_existing_semantics() {
+ // file.new accepts null width by using the selected preset's width.
+ for width in [Value::Null, json!("null")] {
+ let mut app = command_app("file.new", json!({"preset": "A4", "width": width, "title": " Sample layout "}));
+ confirm(&mut app).unwrap();
+ let doc = &app.session.active().unwrap().doc;
+ assert_eq!(doc.title, "Sample layout");
+ assert!((doc.settings.page_width - 595.2755905511812).abs() < 0.01);
+ }
+ }
+
+ #[test]
+ fn generic_invalid_number_retains_dialog_without_creating_document() {
+ let mut app = command_app("file.new", json!({"width": 0}));
+ assert!(confirm(&mut app).is_err());
+ assert!(app.session.active().is_none());
+ let dialog = app.ui.dialog.as_ref().unwrap();
+ assert_eq!(dialog.fields["width"], 0);
+ assert!(dialog.fields["status"].as_str().unwrap().contains("page size out of range"));
+ }
+
+ fn draw(app: &mut DesignApp, ctx: &egui::Context) {
+ let input =
+ egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1400.0, 900.0))), ..Default::default() };
+ let mut out = ctx.run_ui(input, |ui| {
+ app.logic(&ui.ctx().clone());
+ app.ui(ui);
+ });
+ out.textures_delta.clear();
+ }
+
+ /// A paragraph styled "Ruled Child", whose Rule Below comes from its parent "Ruled".
+ fn ruled_paragraph() -> (DesignApp, Value) {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let rule = json!({"on": true, "weight": 3.0, "color": "[Black]", "tint": 0.5, "columnWidth": false, "offset": 4.0, "leftIndent": 6.0, "rightIndent": 2.0});
+ app.run("style.paragraph.create", json!({"name": "Ruled", "para": {"ruleBelow": rule}})).unwrap();
+ app.run("style.paragraph.create", json!({"name": "Ruled Child", "basedOn": "Ruled"})).unwrap();
+ let r = app.run("frame.create", json!({"rect": [72, 72, 300, 400], "content": "text", "text": "One"})).unwrap();
+ app.run("text.select", json!({"story": r["story"], "anchor": 0, "focus": 0})).unwrap();
+ app.run("style.paragraph.apply", json!({"name": "Ruled Child"})).unwrap();
+ (app, rule)
+ }
+
+ fn undo_steps(app: &DesignApp) -> usize {
+ app.session.doc().map_or(0, |st| st.history.undo.len())
+ }
+
+ #[test]
+ fn paragraph_rules_dialog_shows_the_rule_and_applies_one_field() {
+ let (mut app, rule) = ruled_paragraph();
+ let ctx = egui::Context::default();
+ app.run("app.paragraphRulesDialog", json!({"rule": "ruleBelow"})).unwrap();
+ draw(&mut app, &ctx);
+ let d = app.ui.dialog.clone().unwrap();
+ assert_eq!(d.id, "paragraphRules");
+ let current = d.fields["current"].clone();
+ assert_eq!(shown_rule(&d, "", "ruleBelow", &current), rule, "the inherited rule");
+ assert_eq!(shown_rule(&d, "", "ruleAbove", &current)["on"], false);
+ // Pick a colour, as the Color menu does.
+ app.ui.dialog.as_mut().unwrap().fields.insert("ruleBelow.color".into(), json!("[Registration]"));
+ draw(&mut app, &ctx);
+ let before = undo_steps(&app);
+ confirm(&mut app).unwrap();
+ assert_eq!(undo_steps(&app), before + 1, "one undo step");
+ let mut want = rule.clone();
+ want["color"] = json!("[Registration]");
+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], want);
+ app.run("edit.undo", json!({})).unwrap();
+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], rule);
+ }
+
+ #[test]
+ fn paragraph_style_options_edit_one_rule_field() {
+ let (mut app, rule) = ruled_paragraph();
+ let ctx = egui::Context::default();
+ app.ui.dialog = Some(Dialog::new("paragraphStyleOptions", json!({"name": "Ruled Child", "section": "rules", "rule": "ruleBelow"})));
+ draw(&mut app, &ctx);
+ let resolved = |app: &DesignApp| serde_json::to_value(app.session.doc().unwrap().doc.styles.resolve_para_style("Ruled Child").0).unwrap();
+ let d = app.ui.dialog.clone().unwrap();
+ assert_eq!(shown_rule(&d, "p.", "ruleBelow", &resolved(&app)), rule, "inherited from the parent style");
+ app.ui.dialog.as_mut().unwrap().fields.insert("p.ruleBelow.weight".into(), json!(1.5));
+ draw(&mut app, &ctx);
+ let before = undo_steps(&app);
+ confirm(&mut app).unwrap();
+ assert_eq!(undo_steps(&app), before + 1, "one undo step");
+ let mut want = rule.clone();
+ want["weight"] = json!(1.5);
+ assert_eq!(resolved(&app)["ruleBelow"], want);
+ assert_eq!(app.run("type.selectionAttrs", json!({})).unwrap()["para"]["ruleBelow"], want, "the paragraph follows its style");
+ app.run("edit.undo", json!({})).unwrap();
+ assert_eq!(resolved(&app)["ruleBelow"], rule);
+ }
+
+ #[test]
+ fn text_frame_options_change_only_what_was_edited() {
+ let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let r = app.run("frame.create", json!({"rect": [36, 36, 336, 236], "content": "text", "text": "Hello"})).unwrap();
+ let id = designcraft_doc::ItemId(r["id"].as_u64().unwrap());
+ app.run("object.textFrameOptions", json!({"ids": [id.0], "columns": 2, "inset": [1, 2, 3, 4]})).unwrap();
+ let opts = |app: &DesignApp| app.session.doc().unwrap().doc.item(id).unwrap().text_frame().unwrap().options.clone();
+ let before = opts(&app);
+ let open = |app: &mut DesignApp, fields: &[(&str, Value)]| {
+ app.ui.dialog = Some(Dialog::new("textFrameOptions", json!({})));
+ let mut d = app.ui.dialog.take().unwrap();
+ seed_text_frame_options(app, &mut d);
+ for (k, v) in fields {
+ d.fields.insert((*k).into(), v.clone());
+ }
+ app.ui.dialog = Some(d);
+ confirm(app)
+ };
+ // OK without edits changes nothing (no undo step either).
+ assert_eq!(open(&mut app, &[]).unwrap(), Value::Null);
+ assert_eq!(opts(&app), before);
+ // The rule's weight is in points; unequal insets the user didn't touch stay.
+ open(&mut app, &[("columnRule", json!(true)), ("columnRuleWeight", json!("6"))]).unwrap();
+ let o = opts(&app);
+ assert!(o.column_rule && o.column_rule_weight == 6.0, "{o:?}");
+ assert_eq!((o.inset, o.columns, o.gutter), (before.inset, before.columns, before.gutter));
+ // One of the rule's insets edited: the other rule settings stay.
+ open(&mut app, &[("columnRuleBottomInset", json!("0p9")), ("columnRuleTint", json!("40"))]).unwrap();
+ let o = opts(&app);
+ assert_eq!((o.column_rule_bottom_inset, o.column_rule_top_inset, o.column_rule_offset, o.column_rule_weight), (9.0, 0.0, 0.0, 6.0));
+ assert!((o.column_rule_tint - 0.4).abs() < 1e-6 && o.column_rule);
+ // One inset side edited: the others keep their values.
+ open(&mut app, &[("insetLeft", json!("1p0"))]).unwrap();
+ assert_eq!(opts(&app).inset, [1.0, 12.0, 3.0, 4.0]);
+ // An unknown swatch is an error and the dialog stays open.
+ let e = open(&mut app, &[("columnRuleColor", json!("Mauve"))]).unwrap_err();
+ assert!(e.contains("Mauve") && app.ui.dialog.is_some(), "{e}");
+ assert_eq!(opts(&app).column_rule_color, designcraft_color::swatch::BLACK);
+ // Each OK is one undo step.
+ for _ in 0..3 {
+ app.run("edit.undo", json!({})).unwrap();
+ }
+ assert_eq!(opts(&app), before);
+ }
+
+ fn dialog_context(language: &str) -> egui::Context {
+ let ctx = egui::Context::default();
+ crate::theme::install_fonts(&ctx, language);
+ crate::theme::apply(&ctx, &crate::theme::Tokens::for_brightness(crate::theme::Brightness::default()));
+ ctx
+ }
+
+ fn dialog_frame(app: &mut DesignApp, ctx: &egui::Context, screen: egui::Rect, events: Vec<egui::Event>) -> Vec<(String, egui::Rect, egui::Rect)> {
+ let time = ctx.input(|i| i.time) + 1.0 / 60.0;
+ let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), time: Some(time), events, ..Default::default() }, |ui| {
+ show(app, ui.ctx());
+ });
+ output.textures_delta.clear();
+ fn collect(shape: &egui::Shape, clip: egui::Rect, labels: &mut Vec<(String, egui::Rect, egui::Rect)>) {
+ match shape {
+ egui::Shape::Text(t) => labels.push((t.galley.job.text.clone(), t.visual_bounding_rect(), clip)),
+ egui::Shape::Vec(shapes) => {
+ for s in shapes {
+ collect(s, clip, labels);
+ }
+ }
+ _ => {}
+ }
+ }
+ let mut labels = Vec::new();
+ for shape in output.shapes {
+ collect(&shape.shape, shape.clip_rect, &mut labels);
+ }
+ labels
+ }
+
+ fn visible_label(labels: &[(String, egui::Rect, egui::Rect)], screen: egui::Rect, expected: &str) -> egui::Rect {
+ let (_, rect, clip) = labels.iter().find(|(text, _, _)| text.trim() == expected).unwrap_or_else(|| panic!("{expected} is painted"));
+ assert!(screen.contains_rect(*rect), "{expected} must stay on screen: {rect:?}");
+ assert!(clip.contains_rect(*rect), "{expected} must not be clipped: {rect:?}, {clip:?}");
+ *rect
+ }
+
+ fn click_dialog(app: &mut DesignApp, ctx: &egui::Context, screen: egui::Rect, pos: egui::Pos2) {
+ for pressed in [true, false] {
+ dialog_frame(
+ app,
+ ctx,
+ screen,
+ vec![
+ egui::Event::PointerMoved(pos),
+ egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE },
+ ],
+ );
+ }
+ }
+
+ fn scroll_dialog(app: &mut DesignApp, ctx: &egui::Context, screen: egui::Rect, pos: egui::Pos2, delta: egui::Vec2) {
+ dialog_frame(
+ app,
+ ctx,
+ screen,
+ vec![
+ egui::Event::PointerMoved(pos),
+ egui::Event::MouseWheel { unit: egui::MouseWheelUnit::Point, delta, phase: egui::TouchPhase::Move, modifiers: egui::Modifiers::NONE },
+ ],
+ );
+ // Let smooth wheel scrolling and scrollbar visibility settle before clicking.
+ for _ in 0..30 {
+ dialog_frame(app, ctx, screen, vec![]);
+ }
+ }
+
+ #[test]
+ fn dialog_title_and_actions_fit_scaled_viewports() {
+ for language in ["en", "ar"] {
+ for size in [egui::vec2(1178.0, 814.0), egui::vec2(589.0, 407.0), egui::vec2(392.0, 271.0), egui::vec2(450.0, 280.0)] {
+ for (command, title) in [("app.preferences", "Preferences"), ("app.newDocumentDialog", "New Document")] {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.ui.language = language.into();
+ app.run("file.new", json!({})).unwrap();
+ app.run(command, json!({})).unwrap();
+ let ctx = dialog_context(language);
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, size);
+ for _ in 0..3 {
+ dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ for expected in [title, "OK", "Cancel"] {
+ visible_label(&labels, screen, crate::i18n::tr(language, expected));
+ }
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn preferences_sidebar_scroll_keeps_selected_options_visible() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ app.run("app.preferences", json!({})).unwrap();
+ let ctx = dialog_context("en");
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(589.0, 407.0));
+ for _ in 0..3 {
+ dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ let sidebar = visible_label(&labels, screen, "General").center();
+ assert!(
+ !labels.iter().any(|(text, rect, clip)| text == "File Handling" && clip.contains_rect(*rect)),
+ "last section starts below the sidebar"
+ );
+ scroll_dialog(&mut app, &ctx, screen, sidebar, egui::vec2(0.0, -600.0));
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ let files = visible_label(&labels, screen, "File Handling").center();
+ click_dialog(&mut app, &ctx, screen, files);
+ assert_eq!(app.ui.dialog.as_ref().unwrap().s("section"), "files");
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ for expected in ["Document Recovery Data", "Save recovery data every:", "OK", "Cancel"] {
+ visible_label(&labels, screen, expected);
+ }
+ }
+
+ #[test]
+ fn preferences_horizontal_scroll_reaches_clipped_options() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("app.preferences", json!({})).unwrap();
+ let ctx = dialog_context("en");
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(450.0, 280.0));
+ for _ in 0..3 {
+ dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ let body = visible_label(&labels, screen, "When Scaling").center();
+ let option = "Absolute Numbering (instead of Section Numbering)";
+ let (_, rect, clip) = labels.iter().find(|(text, _, _)| text == option).unwrap();
+ assert!(rect.right() > clip.right(), "rightmost option starts horizontally clipped: {rect:?}, {clip:?}");
+ scroll_dialog(&mut app, &ctx, screen, body, egui::vec2(-600.0, 0.0));
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ for expected in [option, "Preferences", "OK", "Cancel"] {
+ visible_label(&labels, screen, expected);
+ }
+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, option).center());
+ assert!(app.ui.dialog.as_ref().unwrap().b("absolutePageNumbers"));
+ }
+
+ #[test]
+ fn new_document_vertical_scroll_reaches_last_field() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("app.newDocumentDialog", json!({})).unwrap();
+ let ctx = dialog_context("en");
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(392.0, 271.0));
+ for _ in 0..3 {
+ dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ let body = visible_label(&labels, screen, "Width").center();
+ let (_, rect, clip) = labels.iter().find(|(text, _, _)| text == "Primary Text Frame").unwrap();
+ assert!(rect.bottom() > clip.bottom(), "last field starts vertically clipped");
+ scroll_dialog(&mut app, &ctx, screen, body, egui::vec2(0.0, -600.0));
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ for expected in ["Primary Text Frame", "New Document", "OK", "Cancel"] {
+ visible_label(&labels, screen, expected);
+ }
+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "Primary Text Frame").center());
+ assert!(app.ui.dialog.as_ref().unwrap().b("primaryTextFrame"));
+ }
+
+ #[test]
+ fn arabic_new_document_leftmost_fields_remain_reachable() {
+ for size in [egui::vec2(392.0, 271.0), egui::vec2(450.0, 280.0)] {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.ui.language = "ar".into();
+ app.run("app.newDocumentDialog", json!({})).unwrap();
+ let fields = [("height", "66p1"), ("gutter", "1p2"), ("marginBottom", "3p3"), ("marginOutside", "3p4")];
+ for (field, value) in fields {
+ app.ui.dialog.as_mut().unwrap().fields.insert(field.into(), json!(value));
+ }
+ let ctx = dialog_context("ar");
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, size);
+ for _ in 0..3 {
+ dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ for (_, value) in fields {
+ visible_label(&labels, screen, value);
+ }
+ let body = visible_label(&labels, screen, "66p1").center();
+ for x in [-600.0, 600.0] {
+ scroll_dialog(&mut app, &ctx, screen, body, egui::vec2(x, 0.0));
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ for (_, value) in fields {
+ visible_label(&labels, screen, value);
+ }
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "66p1").center());
+ dialog_frame(
+ &mut app,
+ &ctx,
+ screen,
+ vec![
+ egui::Event::Key {
+ key: egui::Key::A,
+ physical_key: None,
+ pressed: true,
+ repeat: false,
+ modifiers: egui::Modifiers { ctrl: true, command: true, ..Default::default() },
+ },
+ egui::Event::Text("88p8".into()),
+ ],
+ );
+ assert_eq!(app.ui.dialog.as_ref().unwrap().s("height"), "88p8", "leftmost numeric field accepts edits");
+ scroll_dialog(&mut app, &ctx, screen, body, egui::vec2(0.0, -600.0));
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ let label = crate::i18n::tr("ar", "Primary Text Frame");
+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, label).center());
+ assert!(app.ui.dialog.as_ref().unwrap().b("primaryTextFrame"), "leftmost checkbox remains clickable after scrolling");
+ }
+ }
+
+ #[test]
+ fn resized_dialogs_cancel_and_reopen_without_applying_edits() {
+ for (command, title, field) in [("app.preferences", "Preferences", "recoveryMinutes"), ("app.newDocumentDialog", "New Document", "pages")] {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run(command, json!({})).unwrap();
+ let original = app.ui.dialog.as_ref().unwrap().fields[field].clone();
+ app.ui.dialog.as_mut().unwrap().fields.insert(field.into(), json!(42));
+ let ctx = dialog_context("en");
+ for size in [egui::vec2(1178.0, 814.0), egui::vec2(392.0, 271.0), egui::vec2(589.0, 407.0)] {
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, size);
+ for _ in 0..3 {
+ dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ for expected in [title, "OK", "Cancel"] {
+ visible_label(&labels, screen, expected);
+ }
+ }
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(589.0, 407.0));
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ click_dialog(&mut app, &ctx, screen, visible_label(&labels, screen, "Cancel").center());
+ assert!(app.ui.dialog.is_none());
+ assert!(app.session.active().is_none(), "cancelling must not create a document");
+ app.run(command, json!({})).unwrap();
+ assert_eq!(app.ui.dialog.as_ref().unwrap().fields[field], original, "cancelled edits must not survive reopening");
+ for _ in 0..3 {
+ dialog_frame(&mut app, &ctx, screen, vec![]);
+ }
+ let labels = dialog_frame(&mut app, &ctx, screen, vec![]);
+ visible_label(&labels, screen, title);
+ dialog_frame(
+ &mut app,
+ &ctx,
+ screen,
+ vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }],
+ );
+ assert!(app.ui.dialog.is_none(), "Escape must also close the reopened dialog");
+ }
+ }
+
#[test]
fn parses_command_params() {
let f = command_fields("{name, type: custom|lastPageNumber|chapterNumber, text?, rule?: {on, weight}, flag?: bool} — creates");
diff --cc crates/ui-egui/src/menus.rs
index 296588e3d,9f200fbd6..fa2da83b0
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@@ -1890,21 -1751,25 +1890,28 @@@ pub fn menu_bar(app: &mut DesignApp, ui
menus.reverse();
}
for (menu, entries) in menus {
- ui.menu_button(crate::rtl::widget(ui, crate::i18n::tr(&lang, menu)), |ui| {
- if crate::i18n::is_rtl(&lang) {
- ui.set_max_width(320.0);
- }
- ui.with_layout(egui::Layout::top_down_justified(if crate::i18n::is_rtl(&lang) { egui::Align::Max } else { egui::Align::Min }), |ui| {
- ui.set_min_width(240.0);
- let hidden = menu_items(app, ui, &entries, menu);
- if hidden > 0 && !app.ui.show_full_menus {
- ui.separator();
- if ui.button(crate::rtl::widget(ui, crate::i18n::tr(&lang, "Show All Menu Items"))).clicked() {
- app.ui.show_full_menus = true;
- }
+ egui::containers::menu::MenuButton::new(crate::rtl::widget(ui, crate::i18n::tr(&lang, menu)))
+ .config(egui::containers::menu::MenuConfig::new().close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside))
+ .ui(ui, |ui| {
+ if crate::i18n::is_rtl(&lang) {
+ ui.set_max_width(320.0);
}
+ scroll_menu(ui, |ui| {
- ui.with_layout(egui::Layout::top_down(if crate::i18n::is_rtl(&lang) { egui::Align::Max } else { egui::Align::Min }), |ui| {
- ui.set_min_width(240.0);
- let hidden = menu_items(app, ui, &entries, menu);
- if hidden > 0 && !app.ui.show_full_menus {
- ui.separator();
- if ui.button(crate::rtl::widget(ui, crate::i18n::tr(&lang, "Show All Menu Items"))).clicked() {
- app.ui.show_full_menus = true;
++ ui.with_layout(
++ egui::Layout::top_down_justified(if crate::i18n::is_rtl(&lang) { egui::Align::Max } else { egui::Align::Min }),
++ |ui| {
++ ui.set_min_width(240.0);
++ let hidden = menu_items(app, ui, &entries, menu);
++ if hidden > 0 && !app.ui.show_full_menus {
++ ui.separator();
++ if ui.button(crate::rtl::widget(ui, crate::i18n::tr(&lang, "Show All Menu Items"))).clicked() {
++ app.ui.show_full_menus = true;
++ }
+ }
- }
- });
++ },
++ );
+ });
});
- });
}
}
@@@ -2173,31 -2055,97 +2213,122 @@@ mod tests
}
}
+ /// Exercise the real dropdown, including clipping and wheel input, on a short viewport.
+ #[test]
+ fn oversized_edit_menu_scrolls_to_preferences() {
+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ let ctx = egui::Context::default();
+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(700.0, 260.0));
+ let mut tick = 0;
+ let mut frame = |app: &mut DesignApp, events: Vec<egui::Event>| {
+ tick += 1;
+ let mut output =
+ ctx.run_ui(egui::RawInput { screen_rect: Some(screen), time: Some(tick as f64 / 60.0), events, ..Default::default() }, |ui| {
+ egui::MenuBar::new().ui(ui, |ui| menu_bar(app, ui));
+ });
+ output.textures_delta.clear();
+ let mut labels = Vec::new();
+ fn collect(shape: &egui::Shape, clip: egui::Rect, labels: &mut Vec<(String, egui::Rect, egui::Rect)>) {
+ match shape {
+ egui::Shape::Text(t) => labels.push((t.galley.job.text.clone(), t.visual_bounding_rect(), clip)),
+ egui::Shape::Vec(shapes) => {
+ for shape in shapes {
+ collect(shape, clip, labels);
+ }
+ }
+ _ => {}
+ }
+ }
+ for shape in output.shapes {
+ collect(&shape.shape, shape.clip_rect, &mut labels);
+ }
+ labels
+ };
+ frame(&mut app, vec![]);
+ let labels = frame(&mut app, vec![]);
+ let edit = labels.iter().find(|(text, _, _)| text == "Edit").unwrap().1.center();
+ for pressed in [true, false] {
+ frame(
+ &mut app,
+ vec![
+ egui::Event::PointerMoved(edit),
+ egui::Event::PointerButton { pos: edit, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE },
+ ],
+ );
+ }
+ for _ in 0..3 {
+ frame(&mut app, vec![]);
+ }
+ let layer = ctx.layer_id_at(egui::pos2(edit.x + 80.0, 100.0)).expect("menu layer");
+ let bounds = ctx.memory(|m| m.area_rect(layer.id)).expect("menu bounds");
+ let track = egui::pos2(bounds.right() - 9.0, bounds.bottom() - 25.0);
+ for pressed in [true, false] {
+ frame(
+ &mut app,
+ vec![
+ egui::Event::PointerMoved(track),
+ egui::Event::PointerButton { pos: track, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE },
+ ],
+ );
+ }
+ assert!(egui::Popup::is_any_open(&ctx), "clicking the scroll track must not dismiss the menu");
+ frame(
+ &mut app,
+ vec![
+ egui::Event::PointerMoved(egui::pos2(edit.x + 80.0, 100.0)),
+ egui::Event::MouseWheel {
+ unit: egui::MouseWheelUnit::Point,
+ delta: egui::vec2(0.0, -3000.0),
+ phase: egui::TouchPhase::Move,
+ modifiers: egui::Modifiers::NONE,
+ },
+ ],
+ );
+ let mut labels = Vec::new();
+ for _ in 0..60 {
+ labels = frame(&mut app, vec![]);
+ }
+ let (_, rect, clip) = labels.iter().find(|(text, _, _)| text == "Preferences…").expect("Preferences is rendered");
+ assert!(screen.contains_rect(*rect) && clip.contains_rect(*rect), "Preferences must be visible after scrolling: {rect:?}, {clip:?}");
+ let pos = rect.center();
+ for pressed in [true, false] {
+ frame(
+ &mut app,
+ vec![
+ egui::Event::PointerMoved(pos),
+ egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE },
+ ],
+ );
+ }
+ assert_eq!(app.ui.dialog.as_ref().map(|d| d.id.as_str()), Some("preferences"));
+ assert!(!egui::Popup::is_any_open(&ctx), "choosing a command dismisses the menu");
+ }
+
+ #[test]
+ fn formatting_affects_text_sends_swatches_to_the_text() {
+ let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+ app.run("file.new", json!({})).unwrap();
+ let r = app.run("frame.create", json!({"rect": [72, 72, 300, 200], "content": "text", "text": "words", "caret": false})).unwrap();
+ let (fid, sid) = (r["id"].as_u64().unwrap(), r["story"].as_u64().unwrap());
+ app.run("selection.set", json!({"ids": [fid]})).unwrap();
+ let text_fill = |app: &crate::DesignApp| {
+ let st = app.session.active().unwrap().doc.story(designcraft_doc::StoryId(sid)).unwrap().clone();
+ st.char_format_at(2).over.fill.clone()
+ };
+ let frame_fill = |app: &crate::DesignApp| app.session.active().unwrap().doc.item(designcraft_doc::ItemId(fid)).unwrap().fill.swatch.clone();
+ assert!(!crate::panels::colors_affect_text(&app));
+ crate::panels::apply_swatch(&mut app, false, "Cyan", None).unwrap();
+ assert_eq!(frame_fill(&app), "Cyan");
+ assert_eq!(text_fill(&app), None);
+ let r = run_ui(&mut app, "app.formattingAffectsText", &json!({})).unwrap().unwrap();
+ assert_eq!(r["on"], true, "toggles on");
+ assert!(crate::panels::colors_affect_text(&app));
+ crate::panels::apply_swatch(&mut app, false, "Magenta", Some(0.5)).unwrap();
+ assert_eq!(frame_fill(&app), "Cyan", "the frame is left alone");
+ assert_eq!(text_fill(&app).as_deref(), Some("Magenta"));
+ assert_eq!(crate::panels::color_target(&mut app).map(|t| (t.0, t.1)), Some(("Magenta".to_string(), 0.5)));
+ }
+
#[test]
fn transform_menu_items_open_their_dialogs() {
for id in ["transform.move", "transform.scale", "transform.rotate", "transform.shear"] {